// NewProgram returns a new SSA Program. // // mode controls diagnostics and checking during SSA construction. // // To construct an SSA program: // // - Call NewProgram to create an empty Program. // - Call CreatePackage providing typed syntax for each package // you want to build, and call it with types but not // syntax for each of those package's direct dependencies. // - Call [Package.Build] on each syntax package you wish to build, // or [Program.Build] to build all of them. // // See the Example tests for simple examples. func NewProgram(fset *token.FileSet, mode BuilderMode) *Program { … } // memberFromObject populates package pkg with a member for the // typechecker object obj. // // For objects from Go source code, syntax is the associated syntax // tree (for funcs and vars only) and goversion defines the // appropriate interpretation; they will be used during the build // phase. func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node, goversion string) { … } // createFunction creates a function or method. It supports both // CreatePackage (with or without syntax) and the on-demand creation // of methods in non-created packages based on their types.Func. func createFunction(prog *Program, obj *types.Func, name string, syntax ast.Node, info *types.Info, goversion string) *Function { … } // membersFromDecl populates package pkg with members for each // typechecker object (var, func, const or type) associated with the // specified decl. func membersFromDecl(pkg *Package, decl ast.Decl, goversion string) { … } // CreatePackage creates and returns an SSA Package from the // specified type-checked, error-free file ASTs, and populates its // Members mapping. // // importable determines whether this package should be returned by a // subsequent call to ImportedPackage(pkg.Path()). // // The real work of building SSA form for each function is not done // until a subsequent call to Package.Build. func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *types.Info, importable bool) *Package { … } var printMu … // AllPackages returns a new slice containing all packages created by // prog.CreatePackage in unspecified order. func (prog *Program) AllPackages() []*Package { … } // ImportedPackage returns the importable Package whose PkgPath // is path, or nil if no such Package has been created. // // A parameter to CreatePackage determines whether a package should be // considered importable. For example, no import declaration can resolve // to the ad-hoc main package created by 'go build foo.go'. // // TODO(adonovan): rethink this function and the "importable" concept; // most packages are importable. This function assumes that all // types.Package.Path values are unique within the ssa.Program, which is // false---yet this function remains very convenient. // Clients should use (*Program).Package instead where possible. // SSA doesn't really need a string-keyed map of packages. // // Furthermore, the graph of packages may contain multiple variants // (e.g. "p" vs "p as compiled for q.test"), and each has a different // view of its dependencies. func (prog *Program) ImportedPackage(path string) *Package { … }