Source file src/go/types/issues_test.go

Documentation: go/types

     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  	checkFiles(t, nil, "", []string{"b.go"}, [][]byte{[]byte(bsrc)}, false, imp)
   638  	checkFiles(t, nil, "", []string{"c.go"}, [][]byte{[]byte(csrc)}, false, imp)
   639  	checkFiles(t, nil, "", []string{"t.go"}, [][]byte{[]byte(tsrc)}, false, imp)
   640  }
   641  

View as plain text