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

View as plain text