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) } } }