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         "fmt"
  11         "go/ast"
  12         "go/importer"
  13         "go/parser"
  14         "go/token"
  15         "internal/testenv"
  16         "regexp"
  17         "sort"
  18         "strings"
  19         "testing"
  20
  21         . "go/types"
  22 )
  23
  24 func TestIssue5770(t *testing.T) {
  25         _, err := typecheck(`package p; type S struct{T}`, nil, nil)
  26         const want = "undefined: T"
  27         if err == nil || !strings.Contains(err.Error(), want) {
  28                 t.Errorf("got: %v; want: %s", err, want)
  29         }
  30 }
  31
  32 func TestIssue5849(t *testing.T) {
  33         src := `
  34 package p
  35 var (
  36         s uint
  37         _ = uint8(8)
  38         _ = uint16(16) << s
  39         _ = uint32(32 << s)
  40         _ = uint64(64 << s + s)
  41         _ = (interface{})("foo")
  42         _ = (interface{})(nil)
  43 )`
  44         types := make(map[ast.Expr]TypeAndValue)
  45         mustTypecheck(src, nil, &Info{Types: types})
  46
  47         for x, tv := range types {
  48                 var want Type
  49                 switch x := x.(type) {
  50                 case *ast.BasicLit:
  51                         switch x.Value {
  52                         case `8`:
  53                                 want = Typ[Uint8]
  54                         case `16`:
  55                                 want = Typ[Uint16]
  56                         case `32`:
  57                                 want = Typ[Uint32]
  58                         case `64`:
  59                                 want = Typ[Uint] // because of "+ s", s is of type uint
  60                         case `"foo"`:
  61                                 want = Typ[String]
  62                         }
  63                 case *ast.Ident:
  64                         if x.Name == "nil" {
  65                                 want = Typ[UntypedNil]
  66                         }
  67                 }
  68                 if want != nil && !Identical(tv.Type, want) {
  69                         t.Errorf("got %s; want %s", tv.Type, want)
  70                 }
  71         }
  72 }
  73
  74 func TestIssue6413(t *testing.T) {
  75         src := `
  76 package p
  77 func f() int {
  78         defer f()
  79         go f()
  80         return 0
  81 }
  82 `
  83         types := make(map[ast.Expr]TypeAndValue)
  84         mustTypecheck(src, nil, &Info{Types: types})
  85
  86         want := Typ[Int]
  87         n := 0
  88         for x, tv := range types {
  89                 if _, ok := x.(*ast.CallExpr); ok {
  90                         if tv.Type != want {
  91                                 t.Errorf("%s: got %s; want %s", fset.Position(x.Pos()), tv.Type, want)
  92                         }
  93                         n++
  94                 }
  95         }
  96
  97         if n != 2 {
  98                 t.Errorf("got %d CallExprs; want 2", n)
  99         }
 100 }
 101
 102 func TestIssue7245(t *testing.T) {
 103         src := `
 104 package p
 105 func (T) m() (res bool) { return }
 106 type T struct{} // receiver type after method declaration
 107 `
 108         f := mustParse(fset, src)
 109
 110         var conf Config
 111         defs := make(map[*ast.Ident]Object)
 112         _, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, &Info{Defs: defs})
 113         if err != nil {
 114                 t.Fatal(err)
 115         }
 116
 117         m := f.Decls[0].(*ast.FuncDecl)
 118         res1 := defs[m.Name].(*Func).Type().(*Signature).Results().At(0)
 119         res2 := defs[m.Type.Results.List[0].Names[0]].(*Var)
 120
 121         if res1 != res2 {
 122                 t.Errorf("got %s (%p) != %s (%p)", res1, res2, res1, res2)
 123         }
 124 }
 125
 126 // This tests that uses of existing vars on the LHS of an assignment
 127 // are Uses, not Defs; and also that the (illegal) use of a non-var on
 128 // the LHS of an assignment is a Use nonetheless.
 129 func TestIssue7827(t *testing.T) {
 130         const src = `
 131 package p
 132 func _() {
 133         const w = 1        // defs w
 134         x, y := 2, 3       // defs x, y
 135         w, x, z := 4, 5, 6 // uses w, x, defs z; error: cannot assign to w
 136         _, _, _ = x, y, z  // uses x, y, z
 137 }
 138 `
 139         // We need a specific fileset in this test below for positions.
 140         // Cannot use typecheck helper.
 141         fset := token.NewFileSet()
 142         f := mustParse(fset, src)
 143
 144         const want = `L3 defs func p._()
 145 L4 defs const w untyped int
 146 L5 defs var x int
 147 L5 defs var y int
 148 L6 defs var z int
 149 L6 uses const w untyped int
 150 L6 uses var x int
 151 L7 uses var x int
 152 L7 uses var y int
 153 L7 uses var z int`
 154
 155         // don't abort at the first error
 156         conf := Config{Error: func(err error) { t.Log(err) }}
 157         defs := make(map[*ast.Ident]Object)
 158         uses := make(map[*ast.Ident]Object)
 159         _, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, &Info{Defs: defs, Uses: uses})
 160         if s := err.Error(); !strings.HasSuffix(s, "cannot assign to w") {
 161                 t.Errorf("Check: unexpected error: %s", s)
 162         }
 163
 164         var facts []string
 165         for id, obj := range defs {
 166                 if obj != nil {
 167                         fact := fmt.Sprintf("L%d defs %s", fset.Position(id.Pos()).Line, obj)
 168                         facts = append(facts, fact)
 169                 }
 170         }
 171         for id, obj := range uses {
 172                 fact := fmt.Sprintf("L%d uses %s", fset.Position(id.Pos()).Line, obj)
 173                 facts = append(facts, fact)
 174         }
 175         sort.Strings(facts)
 176
 177         got := strings.Join(facts, "\n")
 178         if got != want {
 179                 t.Errorf("Unexpected defs/uses\ngot:\n%s\nwant:\n%s", got, want)
 180         }
 181 }
 182
 183 // This tests that the package associated with the types.Object.Pkg method
 184 // is the type's package independent of the order in which the imports are
 185 // listed in the sources src1, src2 below.
 186 // The actual issue is in go/internal/gcimporter which has a corresponding
 187 // test; we leave this test here to verify correct behavior at the go/types
 188 // level.
 189 func TestIssue13898(t *testing.T) {
 190         testenv.MustHaveGoBuild(t)
 191
 192         const src0 = `
 193 package main
 194
 195 import "go/types"
 196
 197 func main() {
 198         var info types.Info
 199         for _, obj := range info.Uses {
 200                 _ = obj.Pkg()
 201         }
 202 }
 203 `
 204         // like src0, but also imports go/importer
 205         const src1 = `
 206 package main
 207
 208 import (
 209         "go/types"
 210         _ "go/importer"
 211 )
 212
 213 func main() {
 214         var info types.Info
 215         for _, obj := range info.Uses {
 216                 _ = obj.Pkg()
 217         }
 218 }
 219 `
 220         // like src1 but with different import order
 221         // (used to fail with this issue)
 222         const src2 = `
 223 package main
 224
 225 import (
 226         _ "go/importer"
 227         "go/types"
 228 )
 229
 230 func main() {
 231         var info types.Info
 232         for _, obj := range info.Uses {
 233                 _ = obj.Pkg()
 234         }
 235 }
 236 `
 237         f := func(test, src string) {
 238                 info := &Info{Uses: make(map[*ast.Ident]Object)}
 239                 mustTypecheck(src, nil, info)
 240
 241                 var pkg *Package
 242                 count := 0
 243                 for id, obj := range info.Uses {
 244                         if id.Name == "Pkg" {
 245                                 pkg = obj.Pkg()
 246                                 count++
 247                         }
 248                 }
 249                 if count != 1 {
 250                         t.Fatalf("%s: got %d entries named Pkg; want 1", test, count)
 251                 }
 252                 if pkg.Name() != "types" {
 253                         t.Fatalf("%s: got %v; want package types", test, pkg)
 254                 }
 255         }
 256
 257         f("src0", src0)
 258         f("src1", src1)
 259         f("src2", src2)
 260 }
 261
 262 func TestIssue22525(t *testing.T) {
 263         const src = `package p; func f() { var a, b, c, d, e int }`
 264
 265         got := "\n"
 266         conf := Config{Error: func(err error) { got += err.Error() + "\n" }}
 267         typecheck(src, &conf, nil) // do not crash
 268         want := `
 269 p:1:27: a declared and not used
 270 p:1:30: b declared and not used
 271 p:1:33: c declared and not used
 272 p:1:36: d declared and not used
 273 p:1:39: e declared and not used
 274 `
 275         if got != want {
 276                 t.Errorf("got: %swant: %s", got, want)
 277         }
 278 }
 279
 280 func TestIssue25627(t *testing.T) {
 281         const prefix = `package p; import "unsafe"; type P *struct{}; type I interface{}; type T `
 282         // The src strings (without prefix) are constructed such that the number of semicolons
 283         // plus one corresponds to the number of fields expected in the respective struct.
 284         for _, src := range []string{
 285                 `struct { x Missing }`,
 286                 `struct { Missing }`,
 287                 `struct { *Missing }`,
 288                 `struct { unsafe.Pointer }`,
 289                 `struct { P }`,
 290                 `struct { *I }`,
 291                 `struct { a int; b Missing; *Missing }`,
 292         } {
 293                 f := mustParse(fset, prefix+src)
 294
 295                 cfg := Config{Importer: importer.Default(), Error: func(err error) {}}
 296                 info := &Info{Types: make(map[ast.Expr]TypeAndValue)}
 297                 _, err := cfg.Check(f.Name.Name, fset, []*ast.File{f}, info)
 298                 if err != nil {
 299                         if _, ok := err.(Error); !ok {
 300                                 t.Fatal(err)
 301                         }
 302                 }
 303
 304                 ast.Inspect(f, func(n ast.Node) bool {
 305                         if spec, _ := n.(*ast.TypeSpec); spec != nil {
 306                                 if tv, ok := info.Types[spec.Type]; ok && spec.Name.Name == "T" {
 307                                         want := strings.Count(src, ";") + 1
 308                                         if got := tv.Type.(*Struct).NumFields(); got != want {
 309                                                 t.Errorf("%s: got %d fields; want %d", src, got, want)
 310                                         }
 311                                 }
 312                         }
 313                         return true
 314                 })
 315         }
 316 }
 317
 318 func TestIssue28005(t *testing.T) {
 319         // method names must match defining interface name for this test
 320         // (see last comment in this function)
 321         sources := [...]string{
 322                 "package p; type A interface{ A() }",
 323                 "package p; type B interface{ B() }",
 324                 "package p; type X interface{ A; B }",
 325         }
 326
 327         // compute original file ASTs
 328         var orig [len(sources)]*ast.File
 329         for i, src := range sources {
 330                 orig[i] = mustParse(fset, src)
 331         }
 332
 333         // run the test for all order permutations of the incoming files
 334         for _, perm := range [][len(sources)]int{
 335                 {0, 1, 2},
 336                 {0, 2, 1},
 337                 {1, 0, 2},
 338                 {1, 2, 0},
 339                 {2, 0, 1},
 340                 {2, 1, 0},
 341         } {
 342                 // create file order permutation
 343                 files := make([]*ast.File, len(sources))
 344                 for i := range perm {
 345                         files[i] = orig[perm[i]]
 346                 }
 347
 348                 // type-check package with given file order permutation
 349                 var conf Config
 350                 info := &Info{Defs: make(map[*ast.Ident]Object)}
 351                 _, err := conf.Check("", fset, files, info)
 352                 if err != nil {
 353                         t.Fatal(err)
 354                 }
 355
 356                 // look for interface object X
 357                 var obj Object
 358                 for name, def := range info.Defs {
 359                         if name.Name == "X" {
 360                                 obj = def
 361                                 break
 362                         }
 363                 }
 364                 if obj == nil {
 365                         t.Fatal("object X not found")
 366                 }
 367                 iface := obj.Type().Underlying().(*Interface) // object X must be an interface
 368
 369                 // Each iface method m is embedded; and m's receiver base type name
 370                 // must match the method's name per the choice in the source file.
 371                 for i := 0; i < iface.NumMethods(); i++ {
 372                         m := iface.Method(i)
 373                         recvName := m.Type().(*Signature).Recv().Type().(*Named).Obj().Name()
 374                         if recvName != m.Name() {
 375                                 t.Errorf("perm %v: got recv %s; want %s", perm, recvName, m.Name())
 376                         }
 377                 }
 378         }
 379 }
 380
 381 func TestIssue28282(t *testing.T) {
 382         // create type interface { error }
 383         et := Universe.Lookup("error").Type()
 384         it := NewInterfaceType(nil, []Type{et})
 385         it.Complete()
 386         // verify that after completing the interface, the embedded method remains unchanged
 387         want := et.Underlying().(*Interface).Method(0)
 388         got := it.Method(0)
 389         if got != want {
 390                 t.Fatalf("%s.Method(0): got %q (%p); want %q (%p)", it, got, got, want, want)
 391         }
 392         // verify that lookup finds the same method in both interfaces (redundant check)
 393         obj, _, _ := LookupFieldOrMethod(et, false, nil, "Error")
 394         if obj != want {
 395                 t.Fatalf("%s.Lookup: got %q (%p); want %q (%p)", et, obj, obj, want, want)
 396         }
 397         obj, _, _ = LookupFieldOrMethod(it, false, nil, "Error")
 398         if obj != want {
 399                 t.Fatalf("%s.Lookup: got %q (%p); want %q (%p)", it, obj, obj, want, want)
 400         }
 401 }
 402
 403 func TestIssue29029(t *testing.T) {
 404         f1 := mustParse(fset, `package p; type A interface { M() }`)
 405         f2 := mustParse(fset, `package p; var B interface { A }`)
 406
 407         // printInfo prints the *Func definitions recorded in info, one *Func per line.
 408         printInfo := func(info *Info) string {
 409                 var buf strings.Builder
 410                 for _, obj := range info.Defs {
 411                         if fn, ok := obj.(*Func); ok {
 412                                 fmt.Fprintln(&buf, fn)
 413                         }
 414                 }
 415                 return buf.String()
 416         }
 417
 418         // The *Func (method) definitions for package p must be the same
 419         // independent on whether f1 and f2 are type-checked together, or
 420         // incrementally.
 421
 422         // type-check together
 423         var conf Config
 424         info := &Info{Defs: make(map[*ast.Ident]Object)}
 425         check := NewChecker(&conf, fset, NewPackage("", "p"), info)
 426         if err := check.Files([]*ast.File{f1, f2}); err != nil {
 427                 t.Fatal(err)
 428         }
 429         want := printInfo(info)
 430
 431         // type-check incrementally
 432         info = &Info{Defs: make(map[*ast.Ident]Object)}
 433         check = NewChecker(&conf, fset, NewPackage("", "p"), info)
 434         if err := check.Files([]*ast.File{f1}); err != nil {
 435                 t.Fatal(err)
 436         }
 437         if err := check.Files([]*ast.File{f2}); err != nil {
 438                 t.Fatal(err)
 439         }
 440         got := printInfo(info)
 441
 442         if got != want {
 443                 t.Errorf("\ngot : %swant: %s", got, want)
 444         }
 445 }
 446
 447 func TestIssue34151(t *testing.T) {
 448         const asrc = `package a; type I interface{ M() }; type T struct { F interface { I } }`
 449         const bsrc = `package b; import "a"; type T struct { F interface { a.I } }; var _ = a.T(T{})`
 450
 451         a := mustTypecheck(asrc, nil, nil)
 452
 453         conf := Config{Importer: importHelper{pkg: a}}
 454         mustTypecheck(bsrc, &conf, nil)
 455 }
 456
 457 type importHelper struct {
 458         pkg      *Package
 459         fallback Importer
 460 }
 461
 462 func (h importHelper) Import(path string) (*Package, error) {
 463         if path == h.pkg.Path() {
 464                 return h.pkg, nil
 465         }
 466         if h.fallback == nil {
 467                 return nil, fmt.Errorf("got package path %q; want %q", path, h.pkg.Path())
 468         }
 469         return h.fallback.Import(path)
 470 }
 471
 472 // TestIssue34921 verifies that we don't update an imported type's underlying
 473 // type when resolving an underlying type. Specifically, when determining the
 474 // underlying type of b.T (which is the underlying type of a.T, which is int)
 475 // we must not set the underlying type of a.T again since that would lead to
 476 // a race condition if package b is imported elsewhere, in a package that is
 477 // concurrently type-checked.
 478 func TestIssue34921(t *testing.T) {
 479         defer func() {
 480                 if r := recover(); r != nil {
 481                         t.Error(r)
 482                 }
 483         }()
 484
 485         var sources = []string{
 486                 `package a; type T int`,
 487                 `package b; import "a"; type T a.T`,
 488         }
 489
 490         var pkg *Package
 491         for _, src := range sources {
 492                 conf := Config{Importer: importHelper{pkg: pkg}}
 493                 pkg = mustTypecheck(src, &conf, nil) // pkg imported by the next package in this test
 494         }
 495 }
 496
 497 func TestIssue43088(t *testing.T) {
 498         // type T1 struct {
 499         //         _ T2
 500         // }
 501         //
 502         // type T2 struct {
 503         //         _ struct {
 504         //                 _ T2
 505         //         }
 506         // }
 507         n1 := NewTypeName(nopos, nil, "T1", nil)
 508         T1 := NewNamed(n1, nil, nil)
 509         n2 := NewTypeName(nopos, nil, "T2", nil)
 510         T2 := NewNamed(n2, nil, nil)
 511         s1 := NewStruct([]*Var{NewField(nopos, nil, "_", T2, false)}, nil)
 512         T1.SetUnderlying(s1)
 513         s2 := NewStruct([]*Var{NewField(nopos, nil, "_", T2, false)}, nil)
 514         s3 := NewStruct([]*Var{NewField(nopos, nil, "_", s2, false)}, nil)
 515         T2.SetUnderlying(s3)
 516
 517         // These calls must terminate (no endless recursion).
 518         Comparable(T1)
 519         Comparable(T2)
 520 }
 521
 522 func TestIssue44515(t *testing.T) {
 523         typ := Unsafe.Scope().Lookup("Pointer").Type()
 524
 525         got := TypeString(typ, nil)
 526         want := "unsafe.Pointer"
 527         if got != want {
 528                 t.Errorf("got %q; want %q", got, want)
 529         }
 530
 531         qf := func(pkg *Package) string {
 532                 if pkg == Unsafe {
 533                         return "foo"
 534                 }
 535                 return ""
 536         }
 537         got = TypeString(typ, qf)
 538         want = "foo.Pointer"
 539         if got != want {
 540                 t.Errorf("got %q; want %q", got, want)
 541         }
 542 }
 543
 544 func TestIssue43124(t *testing.T) {
 545         // TODO(rFindley) move this to testdata by enhancing support for importing.
 546
 547         testenv.MustHaveGoBuild(t) // The go command is needed for the importer to determine the locations of stdlib .a files.
 548
 549         // All involved packages have the same name (template). Error messages should
 550         // disambiguate between text/template and html/template by printing the full
 551         // path.
 552         const (
 553                 asrc = `package a; import "text/template"; func F(template.Template) {}; func G(int) {}`
 554                 bsrc = `
 555 package b
 556
 557 import (
 558         "a"
 559         "html/template"
 560 )
 561
 562 func _() {
 563         // Packages should be fully qualified when there is ambiguity within the
 564         // error string itself.
 565         a.F(template /* ERRORx "cannot use.*html/template.* as .*text/template" */ .Template{})
 566 }
 567 `
 568                 csrc = `
 569 package c
 570
 571 import (
 572         "a"
 573         "fmt"
 574         "html/template"
 575 )
 576
 577 // go.dev/issue/46905: make sure template is not the first package qualified.
 578 var _ fmt.Stringer = 1 // ERRORx "cannot use 1.*as fmt\\.Stringer"
 579
 580 // Packages should be fully qualified when there is ambiguity in reachable
 581 // packages. In this case both a (and for that matter html/template) import
 582 // text/template.
 583 func _() { a.G(template /* ERRORx "cannot use .*html/template.*Template" */ .Template{}) }
 584 `
 585
 586                 tsrc = `
 587 package template
 588
 589 import "text/template"
 590
 591 type T int
 592
 593 // Verify that the current package name also causes disambiguation.
 594 var _ T = template /* ERRORx "cannot use.*text/template.* as T value" */.Template{}
 595 `
 596         )
 597
 598         a := mustTypecheck(asrc, nil, nil)
 599         imp := importHelper{pkg: a, fallback: importer.Default()}
 600
 601         withImporter := func(cfg *Config) {
 602                 cfg.Importer = imp
 603         }
 604
 605         testFiles(t, []string{"b.go"}, [][]byte{[]byte(bsrc)}, false, withImporter)
 606         testFiles(t, []string{"c.go"}, [][]byte{[]byte(csrc)}, false, withImporter)
 607         testFiles(t, []string{"t.go"}, [][]byte{[]byte(tsrc)}, false, withImporter)
 608 }
 609
 610 func TestIssue50646(t *testing.T) {
 611         anyType := Universe.Lookup("any").Type()
 612         comparableType := Universe.Lookup("comparable").Type()
 613
 614         if !Comparable(anyType) {
 615                 t.Error("any is not a comparable type")
 616         }
 617         if !Comparable(comparableType) {
 618                 t.Error("comparable is not a comparable type")
 619         }
 620
 621         if Implements(anyType, comparableType.Underlying().(*Interface)) {
 622                 t.Error("any implements comparable")
 623         }
 624         if !Implements(comparableType, anyType.(*Interface)) {
 625                 t.Error("comparable does not implement any")
 626         }
 627
 628         if AssignableTo(anyType, comparableType) {
 629                 t.Error("any assignable to comparable")
 630         }
 631         if !AssignableTo(comparableType, anyType) {
 632                 t.Error("comparable not assignable to any")
 633         }
 634 }
 635
 636 func TestIssue55030(t *testing.T) {
 637         // makeSig makes the signature func(typ...)
 638         makeSig := func(typ Type) {
 639                 par := NewVar(nopos, nil, "", typ)
 640                 params := NewTuple(par)
 641                 NewSignatureType(nil, nil, nil, params, nil, true)
 642         }
 643
 644         // makeSig must not panic for the following (example) types:
 645         // []int
 646         makeSig(NewSlice(Typ[Int]))
 647
 648         // string
 649         makeSig(Typ[String])
 650
 651         // P where P's core type is string
 652         {
 653                 P := NewTypeName(nopos, nil, "P", nil) // [P string]
 654                 makeSig(NewTypeParam(P, NewInterfaceType(nil, []Type{Typ[String]})))
 655         }
 656
 657         // P where P's core type is an (unnamed) slice
 658         {
 659                 P := NewTypeName(nopos, nil, "P", nil) // [P []int]
 660                 makeSig(NewTypeParam(P, NewInterfaceType(nil, []Type{NewSlice(Typ[Int])})))
 661         }
 662
 663         // P where P's core type is bytestring (i.e., string or []byte)
 664         {
 665                 t1 := NewTerm(true, Typ[String])          // ~string
 666                 t2 := NewTerm(false, NewSlice(Typ[Byte])) // []byte
 667                 u := NewUnion([]*Term{t1, t2})            // ~string | []byte
 668                 P := NewTypeName(nopos, nil, "P", nil)    // [P ~string | []byte]
 669                 makeSig(NewTypeParam(P, NewInterfaceType(nil, []Type{u})))
 670         }
 671 }
 672
 673 func TestIssue51093(t *testing.T) {
 674         // Each test stands for a conversion of the form P(val)
 675         // where P is a type parameter with typ as constraint.
 676         // The test ensures that P(val) has the correct type P
 677         // and is not a constant.
 678         var tests = []struct {
 679                 typ string
 680                 val string
 681         }{
 682                 {"bool", "false"},
 683                 {"int", "-1"},
 684                 {"uint", "1.0"},
 685                 {"rune", "'a'"},
 686                 {"float64", "3.5"},
 687                 {"complex64", "1.25"},
 688                 {"string", "\"foo\""},
 689
 690                 // some more complex constraints
 691                 {"~byte", "1"},
 692                 {"~int | ~float64 | complex128", "1"},
 693                 {"~uint64 | ~rune", "'X'"},
 694         }
 695
 696         for _, test := range tests {
 697                 src := fmt.Sprintf("package p; func _[P %s]() { _ = P(%s) }", test.typ, test.val)
 698                 types := make(map[ast.Expr]TypeAndValue)
 699                 mustTypecheck(src, nil, &Info{Types: types})
 700
 701                 var n int
 702                 for x, tv := range types {
 703                         if x, _ := x.(*ast.CallExpr); x != nil {
 704                                 // there must be exactly one CallExpr which is the P(val) conversion
 705                                 n++
 706                                 tpar, _ := tv.Type.(*TypeParam)
 707                                 if tpar == nil {
 708                                         t.Fatalf("%s: got type %s, want type parameter", ExprString(x), tv.Type)
 709                                 }
 710                                 if name := tpar.Obj().Name(); name != "P" {
 711                                         t.Fatalf("%s: got type parameter name %s, want P", ExprString(x), name)
 712                                 }
 713                                 // P(val) must not be constant
 714                                 if tv.Value != nil {
 715                                         t.Errorf("%s: got constant value %s (%s), want no constant", ExprString(x), tv.Value, tv.Value.String())
 716                                 }
 717                         }
 718                 }
 719
 720                 if n != 1 {
 721                         t.Fatalf("%s: got %d CallExpr nodes; want 1", src, 1)
 722                 }
 723         }
 724 }
 725
 726 func TestIssue54258(t *testing.T) {
 727
 728         tests := []struct{ main, b, want string }{
 729                 { //---------------------------------------------------------------
 730                         `package main
 731 import "b"
 732 type I0 interface {
 733         M0(w struct{ f string })
 734 }
 735 var _ I0 = b.S{}
 736 `,
 737                         `package b
 738 type S struct{}
 739 func (S) M0(struct{ f string }) {}
 740 `,
 741                         `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I0 value in variable declaration: b[.]S does not implement I0 [(]wrong type for method M0[)]
 742 .*have M0[(]struct{f string /[*] package b [*]/ }[)]
 743 .*want M0[(]struct{f string /[*] package main [*]/ }[)]`},
 744
 745                 { //---------------------------------------------------------------
 746                         `package main
 747 import "b"
 748 type I1 interface {
 749         M1(struct{ string })
 750 }
 751 var _ I1 = b.S{}
 752 `,
 753                         `package b
 754 type S struct{}
 755 func (S) M1(struct{ string }) {}
 756 `,
 757                         `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I1 value in variable declaration: b[.]S does not implement I1 [(]wrong type for method M1[)]
 758 .*have M1[(]struct{string /[*] package b [*]/ }[)]
 759 .*want M1[(]struct{string /[*] package main [*]/ }[)]`},
 760
 761                 { //---------------------------------------------------------------
 762                         `package main
 763 import "b"
 764 type I2 interface {
 765         M2(y struct{ f struct{ f string } })
 766 }
 767 var _ I2 = b.S{}
 768 `,
 769                         `package b
 770 type S struct{}
 771 func (S) M2(struct{ f struct{ f string } }) {}
 772 `,
 773                         `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I2 value in variable declaration: b[.]S does not implement I2 [(]wrong type for method M2[)]
 774 .*have M2[(]struct{f struct{f string} /[*] package b [*]/ }[)]
 775 .*want M2[(]struct{f struct{f string} /[*] package main [*]/ }[)]`},
 776
 777                 { //---------------------------------------------------------------
 778                         `package main
 779 import "b"
 780 type I3 interface {
 781         M3(z struct{ F struct{ f string } })
 782 }
 783 var _ I3 = b.S{}
 784 `,
 785                         `package b
 786 type S struct{}
 787 func (S) M3(struct{ F struct{ f string } }) {}
 788 `,
 789                         `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I3 value in variable declaration: b[.]S does not implement I3 [(]wrong type for method M3[)]
 790 .*have M3[(]struct{F struct{f string /[*] package b [*]/ }}[)]
 791 .*want M3[(]struct{F struct{f string /[*] package main [*]/ }}[)]`},
 792
 793                 { //---------------------------------------------------------------
 794                         `package main
 795 import "b"
 796 type I4 interface {
 797         M4(_ struct { *string })
 798 }
 799 var _ I4 = b.S{}
 800 `,
 801                         `package b
 802 type S struct{}
 803 func (S) M4(struct { *string }) {}
 804 `,
 805                         `6:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I4 value in variable declaration: b[.]S does not implement I4 [(]wrong type for method M4[)]
 806 .*have M4[(]struct{[*]string /[*] package b [*]/ }[)]
 807 .*want M4[(]struct{[*]string /[*] package main [*]/ }[)]`},
 808
 809                 { //---------------------------------------------------------------
 810                         `package main
 811 import "b"
 812 type t struct{ A int }
 813 type I5 interface {
 814         M5(_ struct {b.S;t})
 815 }
 816 var _ I5 = b.S{}
 817 `,
 818                         `package b
 819 type S struct{}
 820 type t struct{ A int }
 821 func (S) M5(struct {S;t}) {}
 822 `,
 823                         `7:12: cannot use b[.]S{} [(]value of type b[.]S[)] as I5 value in variable declaration: b[.]S does not implement I5 [(]wrong type for method M5[)]
 824 .*have M5[(]struct{b[.]S; b[.]t}[)]
 825 .*want M5[(]struct{b[.]S; t}[)]`},
 826         }
 827
 828         fset := token.NewFileSet()
 829         test := func(main, b, want string) {
 830                 re := regexp.MustCompile(want)
 831                 bpkg := mustTypecheck(b, nil, nil)
 832                 mast := mustParse(fset, main)
 833                 conf := Config{Importer: importHelper{pkg: bpkg}}
 834                 _, err := conf.Check(mast.Name.Name, fset, []*ast.File{mast}, nil)
 835                 if err == nil {
 836                         t.Error("Expected failure, but it did not")
 837                 } else if got := err.Error(); !re.MatchString(got) {
 838                         t.Errorf("Wanted match for\n\t%s\n but got\n\t%s", want, got)
 839                 } else if testing.Verbose() {
 840                         t.Logf("Saw expected\n\t%s", err.Error())
 841                 }
 842         }
 843         for _, t := range tests {
 844                 test(t.main, t.b, t.want)
 845         }
 846 }
 847
 848 func TestIssue59944(t *testing.T) {
 849         testenv.MustHaveCGO(t)
 850
 851         // The typechecker should resolve methods declared on aliases of cgo types.
 852         const src = `
 853 package p
 854
 855 /*
 856 struct layout {
 857         int field;
 858 };
 859 */
 860 import "C"
 861
 862 type Layout = C.struct_layout
 863
 864 func (l *Layout) Binding() {}
 865
 866 func _() {
 867         _ = (*Layout).Binding
 868 }
 869 `
 870
 871         // code generated by cmd/cgo for the above source.
 872         const cgoTypes = `
 873 // Code generated by cmd/cgo; DO NOT EDIT.
 874
 875 package p
 876
 877 import "unsafe"
 878
 879 import "syscall"
 880
 881 import _cgopackage "runtime/cgo"
 882
 883 type _ _cgopackage.Incomplete
 884 var _ syscall.Errno
 885 func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
 886
 887 //go:linkname _Cgo_always_false runtime.cgoAlwaysFalse
 888 var _Cgo_always_false bool
 889 //go:linkname _Cgo_use runtime.cgoUse
 890 func _Cgo_use(interface{})
 891 type _Ctype_int int32
 892
 893 type _Ctype_struct_layout struct {
 894         field _Ctype_int
 895 }
 896
 897 type _Ctype_void [0]byte
 898
 899 //go:linkname _cgo_runtime_cgocall runtime.cgocall
 900 func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
 901
 902 //go:linkname _cgoCheckPointer runtime.cgoCheckPointer
 903 func _cgoCheckPointer(interface{}, interface{})
 904
 905 //go:linkname _cgoCheckResult runtime.cgoCheckResult
 906 func _cgoCheckResult(interface{})
 907 `
 908         testFiles(t, []string{"p.go", "_cgo_gotypes.go"}, [][]byte{[]byte(src), []byte(cgoTypes)}, false, func(cfg *Config) {
 909                 *boolFieldAddr(cfg, "go115UsesCgo") = true
 910         })
 911 }
 912
 913 func TestIssue61931(t *testing.T) {
 914         const src = `
 915 package p
 916
 917 func A(func(any), ...any) {}
 918 func B[T any](T)          {}
 919
 920 func _() {
 921         A(B, nil // syntax error: missing ',' before newline in argument list
 922 }
 923 `
 924         fset := token.NewFileSet()
 925         f, err := parser.ParseFile(fset, pkgName(src), src, 0)
 926         if err == nil {
 927                 t.Fatal("expected syntax error")
 928         }
 929
 930         var conf Config
 931         conf.Check(f.Name.Name, fset, []*ast.File{f}, nil) // must not panic
 932 }
 933
 934 func TestIssue61938(t *testing.T) {
 935         const src = `
 936 package p
 937
 938 func f[T any]() {}
 939 func _()        { f() }
 940 `
 941         // no error handler provided (this issue)
 942         var conf Config
 943         typecheck(src, &conf, nil) // must not panic
 944
 945         // with error handler (sanity check)
 946         conf.Error = func(error) {}
 947         typecheck(src, &conf, nil) // must not panic
 948 }
 949
 950 func TestIssue63260(t *testing.T) {
 951         const src = `
 952 package p
 953
 954 func _() {
 955         use(f[*string])
 956 }
 957
 958 func use(func()) {}
 959
 960 func f[I *T, T any]() {
 961         var v T
 962         _ = v
 963 }`
 964
 965         info := Info{
 966                 Defs: make(map[*ast.Ident]Object),
 967         }
 968         pkg := mustTypecheck(src, nil, &info)
 969
 970         // get type parameter T in signature of f
 971         T := pkg.Scope().Lookup("f").Type().(*Signature).TypeParams().At(1)
 972         if T.Obj().Name() != "T" {
 973                 t.Fatalf("got type parameter %s, want T", T)
 974         }
 975
 976         // get type of variable v in body of f
 977         var v Object
 978         for name, obj := range info.Defs {
 979                 if name.Name == "v" {
 980                         v = obj
 981                         break
 982                 }
 983         }
 984         if v == nil {
 985                 t.Fatal("variable v not found")
 986         }
 987
 988         // type of v and T must be pointer-identical
 989         if v.Type() != T {
 990                 t.Fatalf("types of v and T are not pointer-identical: %p != %p", v.Type().(*TypeParam), T)
 991         }
 992 }
 993
 994 func TestIssue44410(t *testing.T) {
 995         const src = `
 996 package p
 997
 998 type A = []int
 999 type S struct{ A }
1000 `
1001
1002         var conf Config
1003         *boolFieldAddr(&conf, "_EnableAlias") = true
1004         pkg := mustTypecheck(src, &conf, nil)
1005
1006         S := pkg.Scope().Lookup("S")
1007         if S == nil {
1008                 t.Fatal("object S not found")
1009         }
1010
1011         got := S.String()
1012         const want = "type p.S struct{p.A /* = []int */}"
1013         if got != want {
1014                 t.Fatalf("got %q; want %q", got, want)
1015         }
1016 }