func ExampleMap() {
const source = `package P
var X []string
var Y []string
const p, q = 1.0, 2.0
func f(offset int32) (value byte, ok bool)
func g(rune) (uint8, bool)
`
// Parse and type-check the package.
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "P.go", source, 0)
if err != nil {
panic(err)
}
pkg, err := new(types.Config).Check("P", fset, []*ast.File{f}, nil)
if err != nil {
panic(err)
}
scope := pkg.Scope()
// Group names of package-level objects by their type.
var namesByType typeutil.Map // value is []string
for _, name := range scope.Names() {
T := scope.Lookup(name).Type()
names, _ := namesByType.At(T).([]string)
names = append(names, name)
namesByType.Set(T, names)
}
// Format, sort, and print the map entries.
var lines []string
namesByType.Iterate(func(T types.Type, names interface{}) {
lines = append(lines, fmt.Sprintf("%s %s", names, T))
})
sort.Strings(lines)
for _, line := range lines {
fmt.Println(line)
}
// Output:
// [X Y] []string
// [f g] func(offset int32) (value byte, ok bool)
// [p q] untyped float
}
func TestDependencies(t *testing.T) {
packages := make(map[string]*types.Package)
conf := types.Config{
Packages: packages,
Import: func(_ map[string]*types.Package, path string) (*types.Package, error) {
return packages[path], nil
},
}
fset := token.NewFileSet()
// All edges go to the right.
// /--D--B--A
// F \_C_/
// \__E_/
for i, content := range []string{
`package A`,
`package C; import (_ "A")`,
`package B; import (_ "A")`,
`package E; import (_ "C")`,
`package D; import (_ "B"; _ "C")`,
`package F; import (_ "D"; _ "E")`,
} {
f, err := parser.ParseFile(fset, fmt.Sprintf("%d.go", i), content, 0)
if err != nil {
t.Fatal(err)
}
pkg, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, nil)
if err != nil {
t.Fatal(err)
}
packages[pkg.Path()] = pkg
}
for _, test := range []struct {
roots, want string
}{
{"A", "A"},
{"B", "AB"},
{"C", "AC"},
{"D", "ABCD"},
{"E", "ACE"},
{"F", "ABCDEF"},
{"BE", "ABCE"},
{"EB", "ACEB"},
{"DE", "ABCDE"},
{"ED", "ACEBD"},
{"EF", "ACEBDF"},
} {
var pkgs []*types.Package
for _, r := range test.roots {
pkgs = append(pkgs, conf.Packages[string(r)])
}
var got string
for _, p := range typeutil.Dependencies(pkgs...) {
got += p.Path()
}
if got != test.want {
t.Errorf("Dependencies(%q) = %q, want %q", test.roots, got, test.want)
}
}
}
