+++ /dev/null
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package checker defines the implementation of the checker commands.
-// The same code drives the multi-analysis driver, the single-analysis
-// driver that is conventionally provided for convenience along with
-// each analysis package, and the test driver.
-package checker
-
-import (
- "bytes"
- "encoding/gob"
- "flag"
- "fmt"
- "go/format"
- "go/parser"
- "go/token"
- "go/types"
- "io/ioutil"
- "log"
- "os"
- "reflect"
- "runtime"
- "runtime/pprof"
- "runtime/trace"
- "sort"
- "strings"
- "sync"
- "time"
-
- "golang.org/x/tools/go/analysis"
- "golang.org/x/tools/go/analysis/internal/analysisflags"
- "golang.org/x/tools/go/packages"
- "golang.org/x/tools/internal/analysisinternal"
- "golang.org/x/tools/internal/span"
-)
-
-var (
- // Debug is a set of single-letter flags:
- //
- // f show [f]acts as they are created
- // p disable [p]arallel execution of analyzers
- // s do additional [s]anity checks on fact types and serialization
- // t show [t]iming info (NB: use 'p' flag to avoid GC/scheduler noise)
- // v show [v]erbose logging
- //
- Debug = ""
-
- // Log files for optional performance tracing.
- CPUProfile, MemProfile, Trace string
-
- // Fix determines whether to apply all suggested fixes.
- Fix bool
-)
-
-// RegisterFlags registers command-line flags used by the analysis driver.
-func RegisterFlags() {
- // When adding flags here, remember to update
- // the list of suppressed flags in analysisflags.
-
- flag.StringVar(&Debug, "debug", Debug, `debug flags, any subset of "fpstv"`)
-
- flag.StringVar(&CPUProfile, "cpuprofile", "", "write CPU profile to this file")
- flag.StringVar(&MemProfile, "memprofile", "", "write memory profile to this file")
- flag.StringVar(&Trace, "trace", "", "write trace log to this file")
-
- flag.BoolVar(&Fix, "fix", false, "apply all suggested fixes")
-}
-
-// Run loads the packages specified by args using go/packages,
-// then applies the specified analyzers to them.
-// Analysis flags must already have been set.
-// It provides most of the logic for the main functions of both the
-// singlechecker and the multi-analysis commands.
-// It returns the appropriate exit code.
-func Run(args []string, analyzers []*analysis.Analyzer) (exitcode int) {
- if CPUProfile != "" {
- f, err := os.Create(CPUProfile)
- if err != nil {
- log.Fatal(err)
- }
- if err := pprof.StartCPUProfile(f); err != nil {
- log.Fatal(err)
- }
- // NB: profile won't be written in case of error.
- defer pprof.StopCPUProfile()
- }
-
- if Trace != "" {
- f, err := os.Create(Trace)
- if err != nil {
- log.Fatal(err)
- }
- if err := trace.Start(f); err != nil {
- log.Fatal(err)
- }
- // NB: trace log won't be written in case of error.
- defer func() {
- trace.Stop()
- log.Printf("To view the trace, run:\n$ go tool trace view %s", Trace)
- }()
- }
-
- if MemProfile != "" {
- f, err := os.Create(MemProfile)
- if err != nil {
- log.Fatal(err)
- }
- // NB: memprofile won't be written in case of error.
- defer func() {
- runtime.GC() // get up-to-date statistics
- if err := pprof.WriteHeapProfile(f); err != nil {
- log.Fatalf("Writing memory profile: %v", err)
- }
- f.Close()
- }()
- }
-
- // Load the packages.
- if dbg('v') {
- log.SetPrefix("")
- log.SetFlags(log.Lmicroseconds) // display timing
- log.Printf("load %s", args)
- }
-
- // Optimization: if the selected analyzers don't produce/consume
- // facts, we need source only for the initial packages.
- allSyntax := needFacts(analyzers)
- initial, err := load(args, allSyntax)
- if err != nil {
- log.Print(err)
- return 1 // load errors
- }
-
- // Print the results.
- roots := analyze(initial, analyzers)
-
- if Fix {
- applyFixes(roots)
- }
-
- return printDiagnostics(roots)
-}
-
-// load loads the initial packages.
-func load(patterns []string, allSyntax bool) ([]*packages.Package, error) {
- mode := packages.LoadSyntax
- if allSyntax {
- mode = packages.LoadAllSyntax
- }
- conf := packages.Config{
- Mode: mode,
- Tests: true,
- }
- initial, err := packages.Load(&conf, patterns...)
- if err == nil {
- if n := packages.PrintErrors(initial); n > 1 {
- err = fmt.Errorf("%d errors during loading", n)
- } else if n == 1 {
- err = fmt.Errorf("error during loading")
- } else if len(initial) == 0 {
- err = fmt.Errorf("%s matched no packages", strings.Join(patterns, " "))
- }
- }
-
- return initial, err
-}
-
-// TestAnalyzer applies an analysis to a set of packages (and their
-// dependencies if necessary) and returns the results.
-//
-// Facts about pkg are returned in a map keyed by object; package facts
-// have a nil key.
-//
-// This entry point is used only by analysistest.
-func TestAnalyzer(a *analysis.Analyzer, pkgs []*packages.Package) []*TestAnalyzerResult {
- var results []*TestAnalyzerResult
- for _, act := range analyze(pkgs, []*analysis.Analyzer{a}) {
- facts := make(map[types.Object][]analysis.Fact)
- for key, fact := range act.objectFacts {
- if key.obj.Pkg() == act.pass.Pkg {
- facts[key.obj] = append(facts[key.obj], fact)
- }
- }
- for key, fact := range act.packageFacts {
- if key.pkg == act.pass.Pkg {
- facts[nil] = append(facts[nil], fact)
- }
- }
-
- results = append(results, &TestAnalyzerResult{act.pass, act.diagnostics, facts, act.result, act.err})
- }
- return results
-}
-
-type TestAnalyzerResult struct {
- Pass *analysis.Pass
- Diagnostics []analysis.Diagnostic
- Facts map[types.Object][]analysis.Fact
- Result interface{}
- Err error
-}
-
-func analyze(pkgs []*packages.Package, analyzers []*analysis.Analyzer) []*action {
- // Construct the action graph.
- if dbg('v') {
- log.Printf("building graph of analysis passes")
- }
-
- // Each graph node (action) is one unit of analysis.
- // Edges express package-to-package (vertical) dependencies,
- // and analysis-to-analysis (horizontal) dependencies.
- type key struct {
- *analysis.Analyzer
- *packages.Package
- }
- actions := make(map[key]*action)
-
- var mkAction func(a *analysis.Analyzer, pkg *packages.Package) *action
- mkAction = func(a *analysis.Analyzer, pkg *packages.Package) *action {
- k := key{a, pkg}
- act, ok := actions[k]
- if !ok {
- act = &action{a: a, pkg: pkg}
-
- // Add a dependency on each required analyzers.
- for _, req := range a.Requires {
- act.deps = append(act.deps, mkAction(req, pkg))
- }
-
- // An analysis that consumes/produces facts
- // must run on the package's dependencies too.
- if len(a.FactTypes) > 0 {
- paths := make([]string, 0, len(pkg.Imports))
- for path := range pkg.Imports {
- paths = append(paths, path)
- }
- sort.Strings(paths) // for determinism
- for _, path := range paths {
- dep := mkAction(a, pkg.Imports[path])
- act.deps = append(act.deps, dep)
- }
- }
-
- actions[k] = act
- }
- return act
- }
-
- // Build nodes for initial packages.
- var roots []*action
- for _, a := range analyzers {
- for _, pkg := range pkgs {
- root := mkAction(a, pkg)
- root.isroot = true
- roots = append(roots, root)
- }
- }
-
- // Execute the graph in parallel.
- execAll(roots)
-
- return roots
-}
-
-func applyFixes(roots []*action) {
- visited := make(map[*action]bool)
- var apply func(*action) error
- var visitAll func(actions []*action) error
- visitAll = func(actions []*action) error {
- for _, act := range actions {
- if !visited[act] {
- visited[act] = true
- visitAll(act.deps)
- if err := apply(act); err != nil {
- return err
- }
- }
- }
- return nil
- }
-
- // TODO(matloob): Is this tree business too complicated? (After all this is Go!)
- // Just create a set (map) of edits, sort by pos and call it a day?
- type offsetedit struct {
- start, end int
- newText []byte
- } // TextEdit using byteOffsets instead of pos
- type node struct {
- edit offsetedit
- left, right *node
- }
-
- var insert func(tree **node, edit offsetedit) error
- insert = func(treeptr **node, edit offsetedit) error {
- if *treeptr == nil {
- *treeptr = &node{edit, nil, nil}
- return nil
- }
- tree := *treeptr
- if edit.end <= tree.edit.start {
- return insert(&tree.left, edit)
- } else if edit.start >= tree.edit.end {
- return insert(&tree.right, edit)
- }
-
- // Overlapping text edit.
- return fmt.Errorf("analyses applying overlapping text edits affecting pos range (%v, %v) and (%v, %v)",
- edit.start, edit.end, tree.edit.start, tree.edit.end)
-
- }
-
- editsForFile := make(map[*token.File]*node)
-
- apply = func(act *action) error {
- for _, diag := range act.diagnostics {
- for _, sf := range diag.SuggestedFixes {
- for _, edit := range sf.TextEdits {
- // Validate the edit.
- if edit.Pos > edit.End {
- return fmt.Errorf(
- "diagnostic for analysis %v contains Suggested Fix with malformed edit: pos (%v) > end (%v)",
- act.a.Name, edit.Pos, edit.End)
- }
- file, endfile := act.pkg.Fset.File(edit.Pos), act.pkg.Fset.File(edit.End)
- if file == nil || endfile == nil || file != endfile {
- return (fmt.Errorf(
- "diagnostic for analysis %v contains Suggested Fix with malformed spanning files %v and %v",
- act.a.Name, file.Name(), endfile.Name()))
- }
- start, end := file.Offset(edit.Pos), file.Offset(edit.End)
-
- // TODO(matloob): Validate that edits do not affect other packages.
- root := editsForFile[file]
- if err := insert(&root, offsetedit{start, end, edit.NewText}); err != nil {
- return err
- }
- editsForFile[file] = root // In case the root changed
- }
- }
- }
- return nil
- }
-
- visitAll(roots)
-
- fset := token.NewFileSet() // Shared by parse calls below
- // Now we've got a set of valid edits for each file. Get the new file contents.
- for f, tree := range editsForFile {
- contents, err := ioutil.ReadFile(f.Name())
- if err != nil {
- log.Fatal(err)
- }
-
- cur := 0 // current position in the file
-
- var out bytes.Buffer
-
- var recurse func(*node)
- recurse = func(node *node) {
- if node.left != nil {
- recurse(node.left)
- }
-
- edit := node.edit
- if edit.start > cur {
- out.Write(contents[cur:edit.start])
- out.Write(edit.newText)
- }
- cur = edit.end
-
- if node.right != nil {
- recurse(node.right)
- }
- }
- recurse(tree)
- // Write out the rest of the file.
- if cur < len(contents) {
- out.Write(contents[cur:])
- }
-
- // Try to format the file.
- ff, err := parser.ParseFile(fset, f.Name(), out.Bytes(), parser.ParseComments)
- if err == nil {
- var buf bytes.Buffer
- if err = format.Node(&buf, fset, ff); err == nil {
- out = buf
- }
- }
-
- ioutil.WriteFile(f.Name(), out.Bytes(), 0644)
- }
-}
-
-// printDiagnostics prints the diagnostics for the root packages in either
-// plain text or JSON format. JSON format also includes errors for any
-// dependencies.
-//
-// It returns the exitcode: in plain mode, 0 for success, 1 for analysis
-// errors, and 3 for diagnostics. We avoid 2 since the flag package uses
-// it. JSON mode always succeeds at printing errors and diagnostics in a
-// structured form to stdout.
-func printDiagnostics(roots []*action) (exitcode int) {
- // Print the output.
- //
- // Print diagnostics only for root packages,
- // but errors for all packages.
- printed := make(map[*action]bool)
- var print func(*action)
- var visitAll func(actions []*action)
- visitAll = func(actions []*action) {
- for _, act := range actions {
- if !printed[act] {
- printed[act] = true
- visitAll(act.deps)
- print(act)
- }
- }
- }
-
- if analysisflags.JSON {
- // JSON output
- tree := make(analysisflags.JSONTree)
- print = func(act *action) {
- var diags []analysis.Diagnostic
- if act.isroot {
- diags = act.diagnostics
- }
- tree.Add(act.pkg.Fset, act.pkg.ID, act.a.Name, diags, act.err)
- }
- visitAll(roots)
- tree.Print()
- } else {
- // plain text output
-
- // De-duplicate diagnostics by position (not token.Pos) to
- // avoid double-reporting in source files that belong to
- // multiple packages, such as foo and foo.test.
- type key struct {
- pos token.Position
- end token.Position
- *analysis.Analyzer
- message string
- }
- seen := make(map[key]bool)
-
- print = func(act *action) {
- if act.err != nil {
- fmt.Fprintf(os.Stderr, "%s: %v\n", act.a.Name, act.err)
- exitcode = 1 // analysis failed, at least partially
- return
- }
- if act.isroot {
- for _, diag := range act.diagnostics {
- // We don't display a.Name/f.Category
- // as most users don't care.
-
- posn := act.pkg.Fset.Position(diag.Pos)
- end := act.pkg.Fset.Position(diag.End)
- k := key{posn, end, act.a, diag.Message}
- if seen[k] {
- continue // duplicate
- }
- seen[k] = true
-
- analysisflags.PrintPlain(act.pkg.Fset, diag)
- }
- }
- }
- visitAll(roots)
-
- if exitcode == 0 && len(seen) > 0 {
- exitcode = 3 // successfully produced diagnostics
- }
- }
-
- // Print timing info.
- if dbg('t') {
- if !dbg('p') {
- log.Println("Warning: times are mostly GC/scheduler noise; use -debug=tp to disable parallelism")
- }
- var all []*action
- var total time.Duration
- for act := range printed {
- all = append(all, act)
- total += act.duration
- }
- sort.Slice(all, func(i, j int) bool {
- return all[i].duration > all[j].duration
- })
-
- // Print actions accounting for 90% of the total.
- var sum time.Duration
- for _, act := range all {
- fmt.Fprintf(os.Stderr, "%s\t%s\n", act.duration, act)
- sum += act.duration
- if sum >= total*9/10 {
- break
- }
- }
- }
-
- return exitcode
-}
-
-// needFacts reports whether any analysis required by the specified set
-// needs facts. If so, we must load the entire program from source.
-func needFacts(analyzers []*analysis.Analyzer) bool {
- seen := make(map[*analysis.Analyzer]bool)
- var q []*analysis.Analyzer // for BFS
- q = append(q, analyzers...)
- for len(q) > 0 {
- a := q[0]
- q = q[1:]
- if !seen[a] {
- seen[a] = true
- if len(a.FactTypes) > 0 {
- return true
- }
- q = append(q, a.Requires...)
- }
- }
- return false
-}
-
-// An action represents one unit of analysis work: the application of
-// one analysis to one package. Actions form a DAG, both within a
-// package (as different analyzers are applied, either in sequence or
-// parallel), and across packages (as dependencies are analyzed).
-type action struct {
- once sync.Once
- a *analysis.Analyzer
- pkg *packages.Package
- pass *analysis.Pass
- isroot bool
- deps []*action
- objectFacts map[objectFactKey]analysis.Fact
- packageFacts map[packageFactKey]analysis.Fact
- inputs map[*analysis.Analyzer]interface{}
- result interface{}
- diagnostics []analysis.Diagnostic
- err error
- duration time.Duration
-}
-
-type objectFactKey struct {
- obj types.Object
- typ reflect.Type
-}
-
-type packageFactKey struct {
- pkg *types.Package
- typ reflect.Type
-}
-
-func (act *action) String() string {
- return fmt.Sprintf("%s@%s", act.a, act.pkg)
-}
-
-func execAll(actions []*action) {
- sequential := dbg('p')
- var wg sync.WaitGroup
- for _, act := range actions {
- wg.Add(1)
- work := func(act *action) {
- act.exec()
- wg.Done()
- }
- if sequential {
- work(act)
- } else {
- go work(act)
- }
- }
- wg.Wait()
-}
-
-func (act *action) exec() { act.once.Do(act.execOnce) }
-
-func (act *action) execOnce() {
- // Analyze dependencies.
- execAll(act.deps)
-
- // TODO(adonovan): uncomment this during profiling.
- // It won't build pre-go1.11 but conditional compilation
- // using build tags isn't warranted.
- //
- // ctx, task := trace.NewTask(context.Background(), "exec")
- // trace.Log(ctx, "pass", act.String())
- // defer task.End()
-
- // Record time spent in this node but not its dependencies.
- // In parallel mode, due to GC/scheduler contention, the
- // time is 5x higher than in sequential mode, even with a
- // semaphore limiting the number of threads here.
- // So use -debug=tp.
- if dbg('t') {
- t0 := time.Now()
- defer func() { act.duration = time.Since(t0) }()
- }
-
- // Report an error if any dependency failed.
- var failed []string
- for _, dep := range act.deps {
- if dep.err != nil {
- failed = append(failed, dep.String())
- }
- }
- if failed != nil {
- sort.Strings(failed)
- act.err = fmt.Errorf("failed prerequisites: %s", strings.Join(failed, ", "))
- return
- }
-
- // Plumb the output values of the dependencies
- // into the inputs of this action. Also facts.
- inputs := make(map[*analysis.Analyzer]interface{})
- act.objectFacts = make(map[objectFactKey]analysis.Fact)
- act.packageFacts = make(map[packageFactKey]analysis.Fact)
- for _, dep := range act.deps {
- if dep.pkg == act.pkg {
- // Same package, different analysis (horizontal edge):
- // in-memory outputs of prerequisite analyzers
- // become inputs to this analysis pass.
- inputs[dep.a] = dep.result
-
- } else if dep.a == act.a { // (always true)
- // Same analysis, different package (vertical edge):
- // serialized facts produced by prerequisite analysis
- // become available to this analysis pass.
- inheritFacts(act, dep)
- }
- }
-
- // Run the analysis.
- pass := &analysis.Pass{
- Analyzer: act.a,
- Fset: act.pkg.Fset,
- Files: act.pkg.Syntax,
- OtherFiles: act.pkg.OtherFiles,
- IgnoredFiles: act.pkg.IgnoredFiles,
- Pkg: act.pkg.Types,
- TypesInfo: act.pkg.TypesInfo,
- TypesSizes: act.pkg.TypesSizes,
- ResultOf: inputs,
- Report: func(d analysis.Diagnostic) { act.diagnostics = append(act.diagnostics, d) },
- ImportObjectFact: act.importObjectFact,
- ExportObjectFact: act.exportObjectFact,
- ImportPackageFact: act.importPackageFact,
- ExportPackageFact: act.exportPackageFact,
- AllObjectFacts: act.allObjectFacts,
- AllPackageFacts: act.allPackageFacts,
- }
- act.pass = pass
-
- var errors []types.Error
- // Get any type errors that are attributed to the pkg.
- // This is necessary to test analyzers that provide
- // suggested fixes for compiler/type errors.
- for _, err := range act.pkg.Errors {
- if err.Kind != packages.TypeError {
- continue
- }
- // err.Pos is a string of form: "file:line:col" or "file:line" or "" or "-"
- spn := span.Parse(err.Pos)
- // Extract the token positions from the error string.
- line, col, offset := spn.Start().Line(), spn.Start().Column(), -1
- act.pkg.Fset.Iterate(func(f *token.File) bool {
- if f.Name() != spn.URI().Filename() {
- return true
- }
- offset = int(f.LineStart(line)) + col - 1
- return false
- })
- if offset == -1 {
- continue
- }
- errors = append(errors, types.Error{
- Fset: act.pkg.Fset,
- Msg: err.Msg,
- Pos: token.Pos(offset),
- })
- }
- analysisinternal.SetTypeErrors(pass, errors)
-
- var err error
- if act.pkg.IllTyped && !pass.Analyzer.RunDespiteErrors {
- err = fmt.Errorf("analysis skipped due to errors in package")
- } else {
- act.result, err = pass.Analyzer.Run(pass)
- if err == nil {
- if got, want := reflect.TypeOf(act.result), pass.Analyzer.ResultType; got != want {
- err = fmt.Errorf(
- "internal error: on package %s, analyzer %s returned a result of type %v, but declared ResultType %v",
- pass.Pkg.Path(), pass.Analyzer, got, want)
- }
- }
- }
- act.err = err
-
- // disallow calls after Run
- pass.ExportObjectFact = nil
- pass.ExportPackageFact = nil
-}
-
-// inheritFacts populates act.facts with
-// those it obtains from its dependency, dep.
-func inheritFacts(act, dep *action) {
- serialize := dbg('s')
-
- for key, fact := range dep.objectFacts {
- // Filter out facts related to objects
- // that are irrelevant downstream
- // (equivalently: not in the compiler export data).
- if !exportedFrom(key.obj, dep.pkg.Types) {
- if false {
- log.Printf("%v: discarding %T fact from %s for %s: %s", act, fact, dep, key.obj, fact)
- }
- continue
- }
-
- // Optionally serialize/deserialize fact
- // to verify that it works across address spaces.
- if serialize {
- encodedFact, err := codeFact(fact)
- if err != nil {
- log.Panicf("internal error: encoding of %T fact failed in %v", fact, act)
- }
- fact = encodedFact
- }
-
- if false {
- log.Printf("%v: inherited %T fact for %s: %s", act, fact, key.obj, fact)
- }
- act.objectFacts[key] = fact
- }
-
- for key, fact := range dep.packageFacts {
- // TODO: filter out facts that belong to
- // packages not mentioned in the export data
- // to prevent side channels.
-
- // Optionally serialize/deserialize fact
- // to verify that it works across address spaces
- // and is deterministic.
- if serialize {
- encodedFact, err := codeFact(fact)
- if err != nil {
- log.Panicf("internal error: encoding of %T fact failed in %v", fact, act)
- }
- fact = encodedFact
- }
-
- if false {
- log.Printf("%v: inherited %T fact for %s: %s", act, fact, key.pkg.Path(), fact)
- }
- act.packageFacts[key] = fact
- }
-}
-
-// codeFact encodes then decodes a fact,
-// just to exercise that logic.
-func codeFact(fact analysis.Fact) (analysis.Fact, error) {
- // We encode facts one at a time.
- // A real modular driver would emit all facts
- // into one encoder to improve gob efficiency.
- var buf bytes.Buffer
- if err := gob.NewEncoder(&buf).Encode(fact); err != nil {
- return nil, err
- }
-
- // Encode it twice and assert that we get the same bits.
- // This helps detect nondeterministic Gob encoding (e.g. of maps).
- var buf2 bytes.Buffer
- if err := gob.NewEncoder(&buf2).Encode(fact); err != nil {
- return nil, err
- }
- if !bytes.Equal(buf.Bytes(), buf2.Bytes()) {
- return nil, fmt.Errorf("encoding of %T fact is nondeterministic", fact)
- }
-
- new := reflect.New(reflect.TypeOf(fact).Elem()).Interface().(analysis.Fact)
- if err := gob.NewDecoder(&buf).Decode(new); err != nil {
- return nil, err
- }
- return new, nil
-}
-
-// exportedFrom reports whether obj may be visible to a package that imports pkg.
-// This includes not just the exported members of pkg, but also unexported
-// constants, types, fields, and methods, perhaps belonging to oether packages,
-// that find there way into the API.
-// This is an overapproximation of the more accurate approach used by
-// gc export data, which walks the type graph, but it's much simpler.
-//
-// TODO(adonovan): do more accurate filtering by walking the type graph.
-func exportedFrom(obj types.Object, pkg *types.Package) bool {
- switch obj := obj.(type) {
- case *types.Func:
- return obj.Exported() && obj.Pkg() == pkg ||
- obj.Type().(*types.Signature).Recv() != nil
- case *types.Var:
- if obj.IsField() {
- return true
- }
- // we can't filter more aggressively than this because we need
- // to consider function parameters exported, but have no way
- // of telling apart function parameters from local variables.
- return obj.Pkg() == pkg
- case *types.TypeName, *types.Const:
- return true
- }
- return false // Nil, Builtin, Label, or PkgName
-}
-
-// importObjectFact implements Pass.ImportObjectFact.
-// Given a non-nil pointer ptr of type *T, where *T satisfies Fact,
-// importObjectFact copies the fact value to *ptr.
-func (act *action) importObjectFact(obj types.Object, ptr analysis.Fact) bool {
- if obj == nil {
- panic("nil object")
- }
- key := objectFactKey{obj, factType(ptr)}
- if v, ok := act.objectFacts[key]; ok {
- reflect.ValueOf(ptr).Elem().Set(reflect.ValueOf(v).Elem())
- return true
- }
- return false
-}
-
-// exportObjectFact implements Pass.ExportObjectFact.
-func (act *action) exportObjectFact(obj types.Object, fact analysis.Fact) {
- if act.pass.ExportObjectFact == nil {
- log.Panicf("%s: Pass.ExportObjectFact(%s, %T) called after Run", act, obj, fact)
- }
-
- if obj.Pkg() != act.pkg.Types {
- log.Panicf("internal error: in analysis %s of package %s: Fact.Set(%s, %T): can't set facts on objects belonging another package",
- act.a, act.pkg, obj, fact)
- }
-
- key := objectFactKey{obj, factType(fact)}
- act.objectFacts[key] = fact // clobber any existing entry
- if dbg('f') {
- objstr := types.ObjectString(obj, (*types.Package).Name)
- fmt.Fprintf(os.Stderr, "%s: object %s has fact %s\n",
- act.pkg.Fset.Position(obj.Pos()), objstr, fact)
- }
-}
-
-// allObjectFacts implements Pass.AllObjectFacts.
-func (act *action) allObjectFacts() []analysis.ObjectFact {
- facts := make([]analysis.ObjectFact, 0, len(act.objectFacts))
- for k := range act.objectFacts {
- facts = append(facts, analysis.ObjectFact{k.obj, act.objectFacts[k]})
- }
- return facts
-}
-
-// importPackageFact implements Pass.ImportPackageFact.
-// Given a non-nil pointer ptr of type *T, where *T satisfies Fact,
-// fact copies the fact value to *ptr.
-func (act *action) importPackageFact(pkg *types.Package, ptr analysis.Fact) bool {
- if pkg == nil {
- panic("nil package")
- }
- key := packageFactKey{pkg, factType(ptr)}
- if v, ok := act.packageFacts[key]; ok {
- reflect.ValueOf(ptr).Elem().Set(reflect.ValueOf(v).Elem())
- return true
- }
- return false
-}
-
-// exportPackageFact implements Pass.ExportPackageFact.
-func (act *action) exportPackageFact(fact analysis.Fact) {
- if act.pass.ExportPackageFact == nil {
- log.Panicf("%s: Pass.ExportPackageFact(%T) called after Run", act, fact)
- }
-
- key := packageFactKey{act.pass.Pkg, factType(fact)}
- act.packageFacts[key] = fact // clobber any existing entry
- if dbg('f') {
- fmt.Fprintf(os.Stderr, "%s: package %s has fact %s\n",
- act.pkg.Fset.Position(act.pass.Files[0].Pos()), act.pass.Pkg.Path(), fact)
- }
-}
-
-func factType(fact analysis.Fact) reflect.Type {
- t := reflect.TypeOf(fact)
- if t.Kind() != reflect.Ptr {
- log.Fatalf("invalid Fact type: got %T, want pointer", t)
- }
- return t
-}
-
-// allObjectFacts implements Pass.AllObjectFacts.
-func (act *action) allPackageFacts() []analysis.PackageFact {
- facts := make([]analysis.PackageFact, 0, len(act.packageFacts))
- for k := range act.packageFacts {
- facts = append(facts, analysis.PackageFact{k.pkg, act.packageFacts[k]})
- }
- return facts
-}
-
-func dbg(b byte) bool { return strings.IndexByte(Debug, b) >= 0 }
projects / dotfiles / .git / blobdiff