src/go/types/issues_test.go

   1 // Copyright 2013 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 // This file implements tests for various issues.
   6
   7 package types_test
   8
   9 import (
  10         "bytes"
  11         "fmt"
  12         "go/ast"
  13         "go/importer"
  14         "go/parser"
  15         "go/token"
  16         "internal/testenv"
  17         "sort"
  18         "strings"
  19         "testing"
  20
  21         . "go/types"
  22 )
  23
  24 func mustParse(t *testing.T, src string) *ast.File {
  25         f, err := parser.ParseFile(fset, "", src, 0)
  26         if err != nil {
  27                 t.Fatal(err)
  28         }
  29         return f
  30 }
  31 func TestIssue5770(t *testing.T) {
  32         f := mustParse(t, `package p; type S struct{T}`)
  33         conf := Config{Importer: importer.Default()}
  34         _, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, nil) // do not crash
  35         want := "undeclared name: T"
  36         if err == nil || !strings.Contains(err.Error(), want) {
  37                 t.Errorf("got: %v; want: %s", err, want)
  38         }
  39 }
  40
  41 func TestIssue5849(t *testing.T) {
  42         src := `
  43 package p
  44 var (
  45         s uint
  46         _ = uint8(8)
  47         _ = uint16(16) << s
  48         _ = uint32(32 << s)
  49         _ = uint64(64 << s + s)
  50         _ = (interface{})("foo")
  51         _ = (interface{})(nil)
  52 )`
  53         f := mustParse(t, src)
  54
  55         var conf Config
  56         types := make(map[ast.Expr]TypeAndValue)
  57         _, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, &Info{Types: types})
  58         if err != nil {
  59                 t.Fatal(err)
  60         }
  61
  62         for x, tv := range types {
  63                 var want Type
  64                 switch x := x.(type) {
  65                 case *ast.BasicLit:
  66                         switch x.Value {
  67                         case `8`:
  68                                 want = Typ[Uint8]
  69                         case `16`:
  70                                 want = Typ[Uint16]
  71                         case `32`:
  72                                 want = Typ[Uint32]
  73                         case `64`:
  74                                 want = Typ[Uint] // because of "+ s", s is of type uint
  75                         case `"foo"`:
  76                                 want = Typ[String]
  77                         }
  78                 case *ast.Ident:
  79                         if x.Name == "nil" {
  80                                 want = Typ[UntypedNil]
  81                         }
  82                 }
  83                 if want != nil && !Identical(tv.Type, want) {
  84                         t.Errorf("got %s; want %s", tv.Type, want)
  85                 }
  86         }
  87 }
  88
  89 func TestIssue6413(t *testing.T) {
  90         src := `
  91 package p
  92 func f() int {
  93         defer f()
  94         go f()
  95         return 0
  96 }
  97 `
  98         f := mustParse(t, src)
  99
 100         var conf Config
 101         types := make(map[ast.Expr]TypeAndValue)
 102         _, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, &Info{Types: types})
 103         if err != nil {
 104                 t.Fatal(err)
 105         }
 106
 107         want := Typ[Int]
 108         n := 0
 109         for x, tv := range types {
 110                 if _, ok := x.(*ast.CallExpr); ok {
 111                         if tv.Type != want {
 112                                 t.Errorf("%s: got %s; want %s", fset.Position(x.Pos()), tv.Type, want)
 113                         }
 114                         n++
 115                 }
 116         }
 117
 118         if n != 2 {
 119                 t.Errorf("got %d CallExprs; want 2", n)
 120         }
 121 }
 122
 123 func TestIssue7245(t *testing.T) {
 124         src := `
 125 package p
 126 func (T) m() (res bool) { return }
 127 type T struct{} // receiver type after method declaration
 128 `
 129         f := mustParse(t, src)
 130
 131         var conf Config
 132         defs := make(map[*ast.Ident]Object)
 133         _, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, &Info{Defs: defs})
 134         if err != nil {
 135                 t.Fatal(err)
 136         }
 137
 138         m := f.Decls[0].(*ast.FuncDecl)
 139         res1 := defs[m.Name].(*Func).Type().(*Signature).Results().At(0)
 140         res2 := defs[m.Type.Results.List[0].Names[0]].(*Var)
 141
 142         if res1 != res2 {
 143                 t.Errorf("got %s (%p) != %s (%p)", res1, res2, res1, res2)
 144         }
 145 }
 146
 147 // This tests that uses of existing vars on the LHS of an assignment
 148 // are Uses, not Defs; and also that the (illegal) use of a non-var on
 149 // the LHS of an assignment is a Use nonetheless.
 150 func TestIssue7827(t *testing.T) {
 151         const src = `
 152 package p
 153 func _() {
 154         const w = 1        // defs w
 155         x, y := 2, 3       // defs x, y
 156         w, x, z := 4, 5, 6 // uses w, x, defs z; error: cannot assign to w
 157         _, _, _ = x, y, z  // uses x, y, z
 158 }
 159 `
 160         f := mustParse(t, src)
 161
 162         const want = `L3 defs func p._()
 163 L4 defs const w untyped int
 164 L5 defs var x int
 165 L5 defs var y int
 166 L6 defs var z int
 167 L6 uses const w untyped int
 168 L6 uses var x int
 169 L7 uses var x int
 170 L7 uses var y int
 171 L7 uses var z int`
 172
 173         // don't abort at the first error
 174         conf := Config{Error: func(err error) { t.Log(err) }}
 175         defs := make(map[*ast.Ident]Object)
 176         uses := make(map[*ast.Ident]Object)
 177         _, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, &Info{Defs: defs, Uses: uses})
 178         if s := fmt.Sprint(err); !strings.HasSuffix(s, "cannot assign to w") {
 179                 t.Errorf("Check: unexpected error: %s", s)
 180         }
 181
 182         var facts []string
 183         for id, obj := range defs {
 184                 if obj != nil {
 185                         fact := fmt.Sprintf("L%d defs %s", fset.Position(id.Pos()).Line, obj)
 186                         facts = append(facts, fact)
 187                 }
 188         }
 189         for id, obj := range uses {
 190                 fact := fmt.Sprintf("L%d uses %s", fset.Position(id.Pos()).Line, obj)
 191                 facts = append(facts, fact)
 192         }
 193         sort.Strings(facts)
 194
 195         got := strings.Join(facts, "\n")
 196         if got != want {
 197                 t.Errorf("Unexpected defs/uses\ngot:\n%s\nwant:\n%s", got, want)
 198         }
 199 }
 200
 201 // This tests that the package associated with the types.Object.Pkg method
 202 // is the type's package independent of the order in which the imports are
 203 // listed in the sources src1, src2 below.
 204 // The actual issue is in go/internal/gcimporter which has a corresponding
 205 // test; we leave this test here to verify correct behavior at the go/types
 206 // level.
 207 func TestIssue13898(t *testing.T) {
 208         testenv.MustHaveGoBuild(t)
 209
 210         const src0 = `
 211 package main
 212
 213 import "go/types"
 214
 215 func main() {
 216         var info types.Info
 217         for _, obj := range info.Uses {
 218                 _ = obj.Pkg()
 219         }
 220 }
 221 `
 222         // like src0, but also imports go/importer
 223         const src1 = `
 224 package main
 225
 226 import (
 227         "go/types"
 228         _ "go/importer"
 229 )
 230
 231 func main() {
 232         var info types.Info
 233         for _, obj := range info.Uses {
 234                 _ = obj.Pkg()
 235         }
 236 }
 237 `
 238         // like src1 but with different import order
 239         // (used to fail with this issue)
 240         const src2 = `
 241 package main
 242
 243 import (
 244         _ "go/importer"
 245         "go/types"
 246 )
 247
 248 func main() {
 249         var info types.Info
 250         for _, obj := range info.Uses {
 251                 _ = obj.Pkg()
 252         }
 253 }
 254 `
 255         f := func(test, src string) {
 256                 f := mustParse(t, src)
 257                 cfg := Config{Importer: importer.Default()}
 258                 info := Info{Uses: make(map[*ast.Ident]Object)}
 259                 _, err := cfg.Check("main", fset, []*ast.File{f}, &info)
 260                 if err != nil {
 261                         t.Fatal(err)
 262                 }
 263
 264                 var pkg *Package
 265                 count := 0
 266                 for id, obj := range info.Uses {
 267                         if id.Name == "Pkg" {
 268                                 pkg = obj.Pkg()
 269                                 count++
 270                         }
 271                 }
 272                 if count != 1 {
 273                         t.Fatalf("%s: got %d entries named Pkg; want 1", test, count)
 274                 }
 275                 if pkg.Name() != "types" {
 276                         t.Fatalf("%s: got %v; want package types", test, pkg)
 277                 }
 278         }
 279
 280         f("src0", src0)
 281         f("src1", src1)
 282         f("src2", src2)
 283 }
 284
 285 func TestIssue22525(t *testing.T) {
 286         f := mustParse(t, `package p; func f() { var a, b, c, d, e int }`)
 287
 288         got := "\n"
 289         conf := Config{Error: func(err error) { got += err.Error() + "\n" }}
 290         conf.Check(f.Name.Name, fset, []*ast.File{f}, nil) // do not crash
 291         want := `
 292 1:27: a declared but not used
 293 1:30: b declared but not used
 294 1:33: c declared but not used
 295 1:36: d declared but not used
 296 1:39: e declared but not used
 297 `
 298         if got != want {
 299                 t.Errorf("got: %swant: %s", got, want)
 300         }
 301 }
 302
 303 func TestIssue25627(t *testing.T) {
 304         const prefix = `package p; import "unsafe"; type P *struct{}; type I interface{}; type T `
 305         // The src strings (without prefix) are constructed such that the number of semicolons
 306         // plus one corresponds to the number of fields expected in the respective struct.
 307         for _, src := range []string{
 308                 `struct { x Missing }`,
 309                 `struct { Missing }`,
 310                 `struct { *Missing }`,
 311                 `struct { unsafe.Pointer }`,
 312                 `struct { P }`,
 313                 `struct { *I }`,
 314                 `struct { a int; b Missing; *Missing }`,
 315         } {
 316                 f := mustParse(t, prefix+src)
 317
 318                 cfg := Config{Importer: importer.Default(), Error: func(err error) {}}
 319                 info := &Info{Types: make(map[ast.Expr]TypeAndValue)}
 320                 _, err := cfg.Check(f.Name.Name, fset, []*ast.File{f}, info)
 321                 if err != nil {
 322                         if _, ok := err.(Error); !ok {
 323                                 t.Fatal(err)
 324                         }
 325                 }
 326
 327                 ast.Inspect(f, func(n ast.Node) bool {
 328                         if spec, _ := n.(*ast.TypeSpec); spec != nil {
 329                                 if tv, ok := info.Types[spec.Type]; ok && spec.Name.Name == "T" {
 330                                         want := strings.Count(src, ";") + 1
 331                                         if got := tv.Type.(*Struct).NumFields(); got != want {
 332                                                 t.Errorf("%s: got %d fields; want %d", src, got, want)
 333                                         }
 334                                 }
 335                         }
 336                         return true
 337                 })
 338         }
 339 }
 340
 341 func TestIssue28005(t *testing.T) {
 342         // method names must match defining interface name for this test
 343         // (see last comment in this function)
 344         sources := [...]string{
 345                 "package p; type A interface{ A() }",
 346                 "package p; type B interface{ B() }",
 347                 "package p; type X interface{ A; B }",
 348         }
 349
 350         // compute original file ASTs
 351         var orig [len(sources)]*ast.File
 352         for i, src := range sources {
 353                 orig[i] = mustParse(t, src)
 354         }
 355
 356         // run the test for all order permutations of the incoming files
 357         for _, perm := range [][len(sources)]int{
 358                 {0, 1, 2},
 359                 {0, 2, 1},
 360                 {1, 0, 2},
 361                 {1, 2, 0},
 362                 {2, 0, 1},
 363                 {2, 1, 0},
 364         } {
 365                 // create file order permutation
 366                 files := make([]*ast.File, len(sources))
 367                 for i := range perm {
 368                         files[i] = orig[perm[i]]
 369                 }
 370
 371                 // type-check package with given file order permutation
 372                 var conf Config
 373                 info := &Info{Defs: make(map[*ast.Ident]Object)}
 374                 _, err := conf.Check("", fset, files, info)
 375                 if err != nil {
 376                         t.Fatal(err)
 377                 }
 378
 379                 // look for interface object X
 380                 var obj Object
 381                 for name, def := range info.Defs {
 382                         if name.Name == "X" {
 383                                 obj = def
 384                                 break
 385                         }
 386                 }
 387                 if obj == nil {
 388                         t.Fatal("object X not found")
 389                 }
 390                 iface := obj.Type().Underlying().(*Interface) // object X must be an interface
 391
 392                 // Each iface method m is embedded; and m's receiver base type name
 393                 // must match the method's name per the choice in the source file.
 394                 for i := 0; i < iface.NumMethods(); i++ {
 395                         m := iface.Method(i)
 396                         recvName := m.Type().(*Signature).Recv().Type().(*Named).Obj().Name()
 397                         if recvName != m.Name() {
 398                                 t.Errorf("perm %v: got recv %s; want %s", perm, recvName, m.Name())
 399                         }
 400                 }
 401         }
 402 }
 403
 404 func TestIssue28282(t *testing.T) {
 405         // create type interface { error }
 406         et := Universe.Lookup("error").Type()
 407         it := NewInterfaceType(nil, []Type{et})
 408         it.Complete()
 409         // verify that after completing the interface, the embedded method remains unchanged
 410         want := et.Underlying().(*Interface).Method(0)
 411         got := it.Method(0)
 412         if got != want {
 413                 t.Fatalf("%s.Method(0): got %q (%p); want %q (%p)", it, got, got, want, want)
 414         }
 415         // verify that lookup finds the same method in both interfaces (redundant check)
 416         obj, _, _ := LookupFieldOrMethod(et, false, nil, "Error")
 417         if obj != want {
 418                 t.Fatalf("%s.Lookup: got %q (%p); want %q (%p)", et, obj, obj, want, want)
 419         }
 420         obj, _, _ = LookupFieldOrMethod(it, false, nil, "Error")
 421         if obj != want {
 422                 t.Fatalf("%s.Lookup: got %q (%p); want %q (%p)", it, obj, obj, want, want)
 423         }
 424 }
 425
 426 func TestIssue29029(t *testing.T) {
 427         f1 := mustParse(t, `package p; type A interface { M() }`)
 428         f2 := mustParse(t, `package p; var B interface { A }`)
 429
 430         // printInfo prints the *Func definitions recorded in info, one *Func per line.
 431         printInfo := func(info *Info) string {
 432                 var buf bytes.Buffer
 433                 for _, obj := range info.Defs {
 434                         if fn, ok := obj.(*Func); ok {
 435                                 fmt.Fprintln(&buf, fn)
 436                         }
 437                 }
 438                 return buf.String()
 439         }
 440
 441         // The *Func (method) definitions for package p must be the same
 442         // independent on whether f1 and f2 are type-checked together, or
 443         // incrementally.
 444
 445         // type-check together
 446         var conf Config
 447         info := &Info{Defs: make(map[*ast.Ident]Object)}
 448         check := NewChecker(&conf, fset, NewPackage("", "p"), info)
 449         if err := check.Files([]*ast.File{f1, f2}); err != nil {
 450                 t.Fatal(err)
 451         }
 452         want := printInfo(info)
 453
 454         // type-check incrementally
 455         info = &Info{Defs: make(map[*ast.Ident]Object)}
 456         check = NewChecker(&conf, fset, NewPackage("", "p"), info)
 457         if err := check.Files([]*ast.File{f1}); err != nil {
 458                 t.Fatal(err)
 459         }
 460         if err := check.Files([]*ast.File{f2}); err != nil {
 461                 t.Fatal(err)
 462         }
 463         got := printInfo(info)
 464
 465         if got != want {
 466                 t.Errorf("\ngot : %swant: %s", got, want)
 467         }
 468 }
 469
 470 func TestIssue34151(t *testing.T) {
 471         const asrc = `package a; type I interface{ M() }; type T struct { F interface { I } }`
 472         const bsrc = `package b; import "a"; type T struct { F interface { a.I } }; var _ = a.T(T{})`
 473
 474         a, err := pkgFor("a", asrc, nil)
 475         if err != nil {
 476                 t.Fatalf("package %s failed to typecheck: %v", a.Name(), err)
 477         }
 478
 479         bast := mustParse(t, bsrc)
 480         conf := Config{Importer: importHelper{pkg: a}}
 481         b, err := conf.Check(bast.Name.Name, fset, []*ast.File{bast}, nil)
 482         if err != nil {
 483                 t.Errorf("package %s failed to typecheck: %v", b.Name(), err)
 484         }
 485 }
 486
 487 type importHelper struct {
 488         pkg      *Package
 489         fallback Importer
 490 }
 491
 492 func (h importHelper) Import(path string) (*Package, error) {
 493         if path == h.pkg.Path() {
 494                 return h.pkg, nil
 495         }
 496         if h.fallback == nil {
 497                 return nil, fmt.Errorf("got package path %q; want %q", path, h.pkg.Path())
 498         }
 499         return h.fallback.Import(path)
 500 }
 501
 502 // TestIssue34921 verifies that we don't update an imported type's underlying
 503 // type when resolving an underlying type. Specifically, when determining the
 504 // underlying type of b.T (which is the underlying type of a.T, which is int)
 505 // we must not set the underlying type of a.T again since that would lead to
 506 // a race condition if package b is imported elsewhere, in a package that is
 507 // concurrently type-checked.
 508 func TestIssue34921(t *testing.T) {
 509         defer func() {
 510                 if r := recover(); r != nil {
 511                         t.Error(r)
 512                 }
 513         }()
 514
 515         var sources = []string{
 516                 `package a; type T int`,
 517                 `package b; import "a"; type T a.T`,
 518         }
 519
 520         var pkg *Package
 521         for _, src := range sources {
 522                 f := mustParse(t, src)
 523                 conf := Config{Importer: importHelper{pkg: pkg}}
 524                 res, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, nil)
 525                 if err != nil {
 526                         t.Errorf("%q failed to typecheck: %v", src, err)
 527                 }
 528                 pkg = res // res is imported by the next package in this test
 529         }
 530 }
 531
 532 func TestIssue43088(t *testing.T) {
 533         // type T1 struct {
 534         //         _ T2
 535         // }
 536         //
 537         // type T2 struct {
 538         //         _ struct {
 539         //                 _ T2
 540         //         }
 541         // }
 542         n1 := NewTypeName(token.NoPos, nil, "T1", nil)
 543         T1 := NewNamed(n1, nil, nil)
 544         n2 := NewTypeName(token.NoPos, nil, "T2", nil)
 545         T2 := NewNamed(n2, nil, nil)
 546         s1 := NewStruct([]*Var{NewField(token.NoPos, nil, "_", T2, false)}, nil)
 547         T1.SetUnderlying(s1)
 548         s2 := NewStruct([]*Var{NewField(token.NoPos, nil, "_", T2, false)}, nil)
 549         s3 := NewStruct([]*Var{NewField(token.NoPos, nil, "_", s2, false)}, nil)
 550         T2.SetUnderlying(s3)
 551
 552         // These calls must terminate (no endless recursion).
 553         Comparable(T1)
 554         Comparable(T2)
 555 }
 556
 557 func TestIssue44515(t *testing.T) {
 558         typ := Unsafe.Scope().Lookup("Pointer").Type()
 559
 560         got := TypeString(typ, nil)
 561         want := "unsafe.Pointer"
 562         if got != want {
 563                 t.Errorf("got %q; want %q", got, want)
 564         }
 565
 566         qf := func(pkg *Package) string {
 567                 if pkg == Unsafe {
 568                         return "foo"
 569                 }
 570                 return ""
 571         }
 572         got = TypeString(typ, qf)
 573         want = "foo.Pointer"
 574         if got != want {
 575                 t.Errorf("got %q; want %q", got, want)
 576         }
 577 }
 578
 579 func TestIssue43124(t *testing.T) {
 580         // TODO(rFindley) move this to testdata by enhancing support for importing.
 581
 582         // All involved packages have the same name (template). Error messages should
 583         // disambiguate between text/template and html/template by printing the full
 584         // path.
 585         const (
 586                 asrc = `package a; import "text/template"; func F(template.Template) {}; func G(int) {}`
 587                 bsrc = `
 588 package b
 589
 590 import (
 591         "a"
 592         "html/template"
 593 )
 594
 595 func _() {
 596         // Packages should be fully qualified when there is ambiguity within the
 597         // error string itself.
 598         a.F(template /* ERROR cannot use.*html/template.* as .*text/template */ .Template{})
 599 }
 600 `
 601                 csrc = `
 602 package c
 603
 604 import (
 605         "a"
 606         "fmt"
 607         "html/template"
 608 )
 609
 610 // Issue #46905: make sure template is not the first package qualified.
 611 var _ fmt.Stringer = 1 // ERROR cannot use 1.*as fmt\.Stringer
 612
 613 // Packages should be fully qualified when there is ambiguity in reachable
 614 // packages. In this case both a (and for that matter html/template) import
 615 // text/template.
 616 func _() { a.G(template /* ERROR cannot use .*html/template.*Template */ .Template{}) }
 617 `
 618
 619                 tsrc = `
 620 package template
 621
 622 import "text/template"
 623
 624 type T int
 625
 626 // Verify that the current package name also causes disambiguation.
 627 var _ T = template /* ERROR cannot use.*text/template.* as T value */.Template{}
 628 `
 629         )
 630
 631         a, err := pkgFor("a", asrc, nil)
 632         if err != nil {
 633                 t.Fatalf("package a failed to typecheck: %v", err)
 634         }
 635         imp := importHelper{pkg: a, fallback: importer.Default()}
 636
 637         testFiles(t, nil, []string{"b.go"}, [][]byte{[]byte(bsrc)}, false, imp)
 638         testFiles(t, nil, []string{"c.go"}, [][]byte{[]byte(csrc)}, false, imp)
 639         testFiles(t, nil, []string{"t.go"}, [][]byte{[]byte(tsrc)}, false, imp)
 640 }