1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
// Copyright 2024 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.
//go:build ignore
// The gcimporter command reads the compiler's export data for the
// named packages and prints the decoded type information.
//
// It is provided for debugging export data problems.
package main
import (
"bytes"
"flag"
"fmt"
"go/token"
"go/types"
"log"
"os"
"sort"
"golang.org/x/tools/go/gcexportdata"
"golang.org/x/tools/go/packages"
"golang.org/x/tools/go/types/typeutil"
"golang.org/x/tools/internal/gcimporter"
)
func main() {
flag.Parse()
cfg := &packages.Config{
Fset: token.NewFileSet(),
// Don't request NeedTypes: we want to be certain that
// we loaded the types ourselves, from export data.
Mode: packages.NeedName | packages.NeedExportFile,
}
pkgs, err := packages.Load(cfg, flag.Args()...)
if err != nil {
log.Fatal(err)
}
if packages.PrintErrors(pkgs) > 0 {
os.Exit(1)
}
for _, pkg := range pkgs {
// Read types from compiler's unified export data file.
// This Package may included non-exported functions if they
// are called by inlinable exported functions.
var tpkg1 *types.Package
{
export, err := os.ReadFile(pkg.ExportFile)
if err != nil {
log.Fatalf("can't read %q export data: %v", pkg.PkgPath, err)
}
r, err := gcexportdata.NewReader(bytes.NewReader(export))
if err != nil {
log.Fatalf("reading export data %s: %v", pkg.ExportFile, err)
}
tpkg1, err = gcexportdata.Read(r, cfg.Fset, make(map[string]*types.Package), pkg.PkgPath)
if err != nil {
log.Fatalf("decoding export data: %v", err)
}
}
fmt.Println("# Read from compiler's unified export data:")
printPackage(tpkg1)
// Now reexport as indexed (deep) export data, and reimport.
// The Package will contain only exported symbols.
var tpkg2 *types.Package
{
var out bytes.Buffer
if err := gcimporter.IExportData(&out, cfg.Fset, tpkg1); err != nil {
log.Fatal(err)
}
var err error
_, tpkg2, err = gcimporter.IImportData(cfg.Fset, make(map[string]*types.Package), out.Bytes(), tpkg1.Path())
if err != nil {
log.Fatal(err)
}
}
fmt.Println("# After round-tripping through indexed export data:")
printPackage(tpkg2)
}
}
func printPackage(pkg *types.Package) {
fmt.Printf("package %s %q\n", pkg.Name(), pkg.Path())
if !pkg.Complete() {
fmt.Printf("\thas incomplete exported type info\n")
}
// imports
var lines []string
for _, imp := range pkg.Imports() {
lines = append(lines, fmt.Sprintf("\timport %q", imp.Path()))
}
sort.Strings(lines)
for _, line := range lines {
fmt.Println(line)
}
// types of package members
qual := types.RelativeTo(pkg)
scope := pkg.Scope()
for _, name := range scope.Names() {
obj := scope.Lookup(name)
fmt.Printf("\t%s\n", types.ObjectString(obj, qual))
if _, ok := obj.(*types.TypeName); ok {
for _, meth := range typeutil.IntuitiveMethodSet(obj.Type(), nil) {
fmt.Printf("\t%s\n", types.SelectionString(meth, qual))
}
}
}
fmt.Println()
}
|
