.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/go/gcexportdata/example_test.go

   1 // Copyright 2016 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 // +build go1.7
   6 // +build gc
   7
   8 package gcexportdata_test
   9
  10 import (
  11         "fmt"
  12         "go/ast"
  13         "go/parser"
  14         "go/token"
  15         "go/types"
  16         "log"
  17         "os"
  18         "path/filepath"
  19
  20         "golang.org/x/tools/go/gcexportdata"
  21 )
  22
  23 // ExampleRead uses gcexportdata.Read to load type information for the
  24 // "fmt" package from the fmt.a file produced by the gc compiler.
  25 func ExampleRead() {
  26         // Find the export data file.
  27         filename, path := gcexportdata.Find("fmt", "")
  28         if filename == "" {
  29                 log.Fatalf("can't find export data for fmt")
  30         }
  31         fmt.Printf("Package path:       %s\n", path)
  32         fmt.Printf("Export data:        %s\n", filepath.Base(filename))
  33
  34         // Open and read the file.
  35         f, err := os.Open(filename)
  36         if err != nil {
  37                 log.Fatal(err)
  38         }
  39         defer f.Close()
  40         r, err := gcexportdata.NewReader(f)
  41         if err != nil {
  42                 log.Fatalf("reading export data %s: %v", filename, err)
  43         }
  44
  45         // Decode the export data.
  46         fset := token.NewFileSet()
  47         imports := make(map[string]*types.Package)
  48         pkg, err := gcexportdata.Read(r, fset, imports, path)
  49         if err != nil {
  50                 log.Fatal(err)
  51         }
  52
  53         // Print package information.
  54         members := pkg.Scope().Names()
  55         if members[0] == ".inittask" {
  56                 // An improvement to init handling in 1.13 added ".inittask". Remove so go >= 1.13 and go < 1.13 both pass.
  57                 members = members[1:]
  58         }
  59         fmt.Printf("Package members:    %s...\n", members[:5])
  60         println := pkg.Scope().Lookup("Println")
  61         posn := fset.Position(println.Pos())
  62         posn.Line = 123 // make example deterministic
  63         fmt.Printf("Println type:       %s\n", println.Type())
  64         fmt.Printf("Println location:   %s\n", slashify(posn))
  65
  66         // Output:
  67         //
  68         // Package path:       fmt
  69         // Export data:        fmt.a
  70         // Package members:    [Errorf Formatter Fprint Fprintf Fprintln]...
  71         // Println type:       func(a ...interface{}) (n int, err error)
  72         // Println location:   $GOROOT/src/fmt/print.go:123:1
  73 }
  74
  75 // ExampleNewImporter demonstrates usage of NewImporter to provide type
  76 // information for dependencies when type-checking Go source code.
  77 func ExampleNewImporter() {
  78         const src = `package myrpc
  79
  80 // choosing a package that doesn't change across releases
  81 import "net/rpc"
  82
  83 const serverError rpc.ServerError = ""
  84 `
  85         fset := token.NewFileSet()
  86         f, err := parser.ParseFile(fset, "myrpc.go", src, 0)
  87         if err != nil {
  88                 log.Fatal(err)
  89         }
  90
  91         packages := make(map[string]*types.Package)
  92         imp := gcexportdata.NewImporter(fset, packages)
  93         conf := types.Config{Importer: imp}
  94         pkg, err := conf.Check("myrpc", fset, []*ast.File{f}, nil)
  95         if err != nil {
  96                 log.Fatal(err)
  97         }
  98
  99         // object from imported package
 100         pi := packages["net/rpc"].Scope().Lookup("ServerError")
 101         fmt.Printf("type %s.%s %s // %s\n",
 102                 pi.Pkg().Path(),
 103                 pi.Name(),
 104                 pi.Type().Underlying(),
 105                 slashify(fset.Position(pi.Pos())),
 106         )
 107
 108         // object in source package
 109         twopi := pkg.Scope().Lookup("serverError")
 110         fmt.Printf("const %s %s = %s // %s\n",
 111                 twopi.Name(),
 112                 twopi.Type(),
 113                 twopi.(*types.Const).Val(),
 114                 slashify(fset.Position(twopi.Pos())),
 115         )
 116
 117         // Output:
 118         //
 119         // type net/rpc.ServerError string // $GOROOT/src/net/rpc/client.go:20:1
 120         // const serverError net/rpc.ServerError = "" // myrpc.go:6:7
 121 }
 122
 123 func slashify(posn token.Position) token.Position {
 124         posn.Filename = filepath.ToSlash(posn.Filename) // for MS Windows portability
 125         return posn
 126 }