| 1 |
// Copyright 2015 The Go Authors. All rights reserved. |
| 2 |
// Use of this source code is governed by a BSD-style |
| 3 |
// license that can be found in the LICENSE file. |
| 4 |
|
| 5 |
package irutil |
| 6 |
|
| 7 |
// This file defines utility functions for constructing programs in IR form. |
| 8 |
|
| 9 |
import ( |
| 10 |
"go/ast" |
| 11 |
"go/token" |
| 12 |
"go/types" |
| 13 |
|
| 14 |
"honnef.co/go/tools/go/ir" |
| 15 |
|
| 16 |
//lint:ignore SA1019 go/loader is deprecated, but works fine for our tests |
| 17 |
"golang.org/x/tools/go/loader" |
| 18 |
"golang.org/x/tools/go/packages" |
| 19 |
) |
| 20 |
|
| 21 |
type Options struct { |
| 22 |
// Which function, if any, to print in HTML form |
| 23 |
PrintFunc string |
| 24 |
} |
| 25 |
|
| 26 |
// Packages creates an IR program for a set of packages. |
| 27 |
// |
| 28 |
// The packages must have been loaded from source syntax using the |
| 29 |
// golang.org/x/tools/go/packages.Load function in LoadSyntax or |
| 30 |
// LoadAllSyntax mode. |
| 31 |
// |
| 32 |
// Packages creates an IR package for each well-typed package in the |
| 33 |
// initial list, plus all their dependencies. The resulting list of |
| 34 |
// packages corresponds to the list of initial packages, and may contain |
| 35 |
// a nil if IR code could not be constructed for the corresponding initial |
| 36 |
// package due to type errors. |
| 37 |
// |
| 38 |
// Code for bodies of functions is not built until Build is called on |
| 39 |
// the resulting Program. IR code is constructed only for the initial |
| 40 |
// packages with well-typed syntax trees. |
| 41 |
// |
| 42 |
// The mode parameter controls diagnostics and checking during IR construction. |
| 43 |
func Packages(initial []*packages.Package, mode ir.BuilderMode, opts *Options) (*ir.Program, []*ir.Package) { |
| 44 |
return doPackages(initial, mode, false, opts) |
| 45 |
} |
| 46 |
|
| 47 |
// AllPackages creates an IR program for a set of packages plus all |
| 48 |
// their dependencies. |
| 49 |
// |
| 50 |
// The packages must have been loaded from source syntax using the |
| 51 |
// golang.org/x/tools/go/packages.Load function in LoadAllSyntax mode. |
| 52 |
// |
| 53 |
// AllPackages creates an IR package for each well-typed package in the |
| 54 |
// initial list, plus all their dependencies. The resulting list of |
| 55 |
// packages corresponds to the list of initial packages, and may contain |
| 56 |
// a nil if IR code could not be constructed for the corresponding |
| 57 |
// initial package due to type errors. |
| 58 |
// |
| 59 |
// Code for bodies of functions is not built until Build is called on |
| 60 |
// the resulting Program. IR code is constructed for all packages with |
| 61 |
// well-typed syntax trees. |
| 62 |
// |
| 63 |
// The mode parameter controls diagnostics and checking during IR construction. |
| 64 |
func AllPackages(initial []*packages.Package, mode ir.BuilderMode, opts *Options) (*ir.Program, []*ir.Package) { |
| 65 |
return doPackages(initial, mode, true, opts) |
| 66 |
} |
| 67 |
|
| 68 |
func doPackages(initial []*packages.Package, mode ir.BuilderMode, deps bool, opts *Options) (*ir.Program, []*ir.Package) { |
| 69 |
|
| 70 |
var fset *token.FileSet |
| 71 |
if len(initial) > 0 { |
| 72 |
fset = initial[0].Fset |
| 73 |
} |
| 74 |
|
| 75 |
prog := ir.NewProgram(fset, mode) |
| 76 |
if opts != nil { |
| 77 |
prog.PrintFunc = opts.PrintFunc |
| 78 |
} |
| 79 |
|
| 80 |
isInitial := make(map[*packages.Package]bool, len(initial)) |
| 81 |
for _, p := range initial { |
| 82 |
isInitial[p] = true |
| 83 |
} |
| 84 |
|
| 85 |
irmap := make(map[*packages.Package]*ir.Package) |
| 86 |
packages.Visit(initial, nil, func(p *packages.Package) { |
| 87 |
if p.Types != nil && !p.IllTyped { |
| 88 |
var files []*ast.File |
| 89 |
if deps || isInitial[p] { |
| 90 |
files = p.Syntax |
| 91 |
} |
| 92 |
irmap[p] = prog.CreatePackage(p.Types, files, p.TypesInfo, true) |
| 93 |
} |
| 94 |
}) |
| 95 |
|
| 96 |
var irpkgs []*ir.Package |
| 97 |
for _, p := range initial { |
| 98 |
irpkgs = append(irpkgs, irmap[p]) // may be nil |
| 99 |
} |
| 100 |
return prog, irpkgs |
| 101 |
} |
| 102 |
|
| 103 |
// CreateProgram returns a new program in IR form, given a program |
| 104 |
// loaded from source. An IR package is created for each transitively |
| 105 |
// error-free package of lprog. |
| 106 |
// |
| 107 |
// Code for bodies of functions is not built until Build is called |
| 108 |
// on the result. |
| 109 |
// |
| 110 |
// The mode parameter controls diagnostics and checking during IR construction. |
| 111 |
// |
| 112 |
// Deprecated: use golang.org/x/tools/go/packages and the Packages |
| 113 |
// function instead; see ir.ExampleLoadPackages. |
| 114 |
func CreateProgram(lprog *loader.Program, mode ir.BuilderMode) *ir.Program { |
| 115 |
prog := ir.NewProgram(lprog.Fset, mode) |
| 116 |
|
| 117 |
for _, info := range lprog.AllPackages { |
| 118 |
if info.TransitivelyErrorFree { |
| 119 |
prog.CreatePackage(info.Pkg, info.Files, &info.Info, info.Importable) |
| 120 |
} |
| 121 |
} |
| 122 |
|
| 123 |
return prog |
| 124 |
} |
| 125 |
|
| 126 |
// BuildPackage builds an IR program with IR for a single package. |
| 127 |
// |
| 128 |
// It populates pkg by type-checking the specified file ASTs. All |
| 129 |
// dependencies are loaded using the importer specified by tc, which |
| 130 |
// typically loads compiler export data; IR code cannot be built for |
| 131 |
// those packages. BuildPackage then constructs an ir.Program with all |
| 132 |
// dependency packages created, and builds and returns the IR package |
| 133 |
// corresponding to pkg. |
| 134 |
// |
| 135 |
// The caller must have set pkg.Path() to the import path. |
| 136 |
// |
| 137 |
// The operation fails if there were any type-checking or import errors. |
| 138 |
// |
| 139 |
// See ../ir/example_test.go for an example. |
| 140 |
func BuildPackage(tc *types.Config, fset *token.FileSet, pkg *types.Package, files []*ast.File, mode ir.BuilderMode) (*ir.Package, *types.Info, error) { |
| 141 |
if fset == nil { |
| 142 |
panic("no token.FileSet") |
| 143 |
} |
| 144 |
if pkg.Path() == "" { |
| 145 |
panic("package has no import path") |
| 146 |
} |
| 147 |
|
| 148 |
info := &types.Info{ |
| 149 |
Types: make(map[ast.Expr]types.TypeAndValue), |
| 150 |
Defs: make(map[*ast.Ident]types.Object), |
| 151 |
Uses: make(map[*ast.Ident]types.Object), |
| 152 |
Implicits: make(map[ast.Node]types.Object), |
| 153 |
Scopes: make(map[ast.Node]*types.Scope), |
| 154 |
Selections: make(map[*ast.SelectorExpr]*types.Selection), |
| 155 |
Instances: make(map[*ast.Ident]types.Instance), |
| 156 |
FileVersions: make(map[*ast.File]string), |
| 157 |
} |
| 158 |
if err := types.NewChecker(tc, fset, pkg, info).Files(files); err != nil { |
| 159 |
return nil, nil, err |
| 160 |
} |
| 161 |
|
| 162 |
prog := ir.NewProgram(fset, mode) |
| 163 |
|
| 164 |
// Create IR packages for all imports. |
| 165 |
// Order is not significant. |
| 166 |
created := make(map[*types.Package]bool) |
| 167 |
var createAll func(pkgs []*types.Package) |
| 168 |
createAll = func(pkgs []*types.Package) { |
| 169 |
for _, p := range pkgs { |
| 170 |
if !created[p] { |
| 171 |
created[p] = true |
| 172 |
prog.CreatePackage(p, nil, nil, true) |
| 173 |
createAll(p.Imports()) |
| 174 |
} |
| 175 |
} |
| 176 |
} |
| 177 |
createAll(pkg.Imports()) |
| 178 |
|
| 179 |
// Create and build the primary package. |
| 180 |
irpkg := prog.CreatePackage(pkg, files, info, false) |
| 181 |
irpkg.Build() |
| 182 |
return irpkg, info, nil |
| 183 |
} |