object_test.go

     1  // Copyright 2016 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  package types_test
     6  
     7  import (
     8  	"fmt"
     9  	"internal/testenv"
    10  	"strings"
    11  	"testing"
    12  
    13  	. "go/types"
    14  )
    15  
    16  func TestIsAlias(t *testing.T) {
    17  	check := func(obj *TypeName, want bool) {
    18  		if got := obj.IsAlias(); got != want {
    19  			t.Errorf("%v: got IsAlias = %v; want %v", obj, got, want)
    20  		}
    21  	}
    22  
    23  	// predeclared types
    24  	check(Unsafe.Scope().Lookup("Pointer").(*TypeName), false)
    25  	for _, name := range Universe.Names() {
    26  		if obj, _ := Universe.Lookup(name).(*TypeName); obj != nil {
    27  			check(obj, name == "any" || name == "byte" || name == "rune")
    28  		}
    29  	}
    30  
    31  	// various other types
    32  	pkg := NewPackage("p", "p")
    33  	t1 := NewTypeName(nopos, pkg, "t1", nil)
    34  	n1 := NewNamed(t1, new(Struct), nil)
    35  	t5 := NewTypeName(nopos, pkg, "t5", nil)
    36  	NewTypeParam(t5, nil)
    37  	for _, test := range []struct {
    38  		name  *TypeName
    39  		alias bool
    40  	}{
    41  		{NewTypeName(nopos, nil, "t0", nil), false}, // no type yet
    42  		{NewTypeName(nopos, pkg, "t0", nil), false}, // no type yet
    43  		{t1, false}, // type name refers to named type and vice versa
    44  		{NewTypeName(nopos, nil, "t2", NewInterfaceType(nil, nil)), true}, // type name refers to unnamed type
    45  		{NewTypeName(nopos, pkg, "t3", n1), true},                         // type name refers to named type with different type name
    46  		{NewTypeName(nopos, nil, "t4", Typ[Int32]), true},                 // type name refers to basic type with different name
    47  		{NewTypeName(nopos, nil, "int32", Typ[Int32]), false},             // type name refers to basic type with same name
    48  		{NewTypeName(nopos, pkg, "int32", Typ[Int32]), true},              // type name is declared in user-defined package (outside Universe)
    49  		{NewTypeName(nopos, nil, "rune", Typ[Rune]), true},                // type name refers to basic type rune which is an alias already
    50  		{t5, false}, // type name refers to type parameter and vice versa
    51  	} {
    52  		check(test.name, test.alias)
    53  	}
    54  }
    55  
    56  // TestEmbeddedMethod checks that an embedded method is represented by
    57  // the same Func Object as the original method. See also go.dev/issue/34421.
    58  func TestEmbeddedMethod(t *testing.T) {
    59  	const src = `package p; type I interface { error }`
    60  	pkg := mustTypecheck(src, nil, nil)
    61  
    62  	// get original error.Error method
    63  	eface := Universe.Lookup("error")
    64  	orig, _, _ := LookupFieldOrMethod(eface.Type(), false, nil, "Error")
    65  	if orig == nil {
    66  		t.Fatalf("original error.Error not found")
    67  	}
    68  
    69  	// get embedded error.Error method
    70  	iface := pkg.Scope().Lookup("I")
    71  	embed, _, _ := LookupFieldOrMethod(iface.Type(), false, nil, "Error")
    72  	if embed == nil {
    73  		t.Fatalf("embedded error.Error not found")
    74  	}
    75  
    76  	// original and embedded Error object should be identical
    77  	if orig != embed {
    78  		t.Fatalf("%s (%p) != %s (%p)", orig, orig, embed, embed)
    79  	}
    80  }
    81  
    82  var testObjects = []struct {
    83  	src   string
    84  	obj   string
    85  	want  string
    86  	alias bool // needs materialized (and possibly generic) aliases
    87  }{
    88  	{"import \"io\"; var r io.Reader", "r", "var p.r io.Reader", false},
    89  
    90  	{"const c = 1.2", "c", "const p.c untyped float", false},
    91  	{"const c float64 = 3.14", "c", "const p.c float64", false},
    92  
    93  	{"type t struct{f int}", "t", "type p.t struct{f int}", false},
    94  	{"type t func(int)", "t", "type p.t func(int)", false},
    95  	{"type t[P any] struct{f P}", "t", "type p.t[P any] struct{f P}", false},
    96  	{"type t[P any] struct{f P}", "t.P", "type parameter P any", false},
    97  	{"type C interface{m()}; type t[P C] struct{}", "t.P", "type parameter P p.C", false},
    98  
    99  	{"type t = struct{f int}", "t", "type p.t = struct{f int}", false},
   100  	{"type t = func(int)", "t", "type p.t = func(int)", false},
   101  	{"type A = B; type B = int", "A", "type p.A = p.B", true},
   102  	{"type A[P ~int] = struct{}", "A", "type p.A[P ~int] = struct{}", true}, // requires GOEXPERIMENT=aliastypeparams
   103  
   104  	{"var v int", "v", "var p.v int", false},
   105  
   106  	{"func f(int) string", "f", "func p.f(int) string", false},
   107  	{"func g[P any](x P){}", "g", "func p.g[P any](x P)", false},
   108  	{"func g[P interface{~int}](x P){}", "g.P", "type parameter P interface{~int}", false},
   109  	{"", "any", "type any = interface{}", false},
   110  }
   111  
   112  func TestObjectString(t *testing.T) {
   113  	testenv.MustHaveGoBuild(t)
   114  
   115  	for i, test := range testObjects {
   116  		t.Run(fmt.Sprint(i), func(t *testing.T) {
   117  			if test.alias {
   118  				revert := setGOEXPERIMENT("aliastypeparams")
   119  				defer revert()
   120  				t.Setenv("GODEBUG", "gotypesalias=1")
   121  			}
   122  
   123  			src := "package p; " + test.src
   124  			pkg, err := typecheck(src, nil, nil)
   125  			if err != nil {
   126  				t.Fatalf("%s: %s", src, err)
   127  			}
   128  
   129  			names := strings.Split(test.obj, ".")
   130  			if len(names) != 1 && len(names) != 2 {
   131  				t.Fatalf("%s: invalid object path %s", test.src, test.obj)
   132  			}
   133  
   134  			var obj Object
   135  			for s := pkg.Scope(); s != nil && obj == nil; s = s.Parent() {
   136  				obj = s.Lookup(names[0])
   137  			}
   138  			if obj == nil {
   139  				t.Fatalf("%s: %s not found", test.src, names[0])
   140  			}
   141  
   142  			if len(names) == 2 {
   143  				if typ, ok := obj.Type().(interface{ TypeParams() *TypeParamList }); ok {
   144  					obj = lookupTypeParamObj(typ.TypeParams(), names[1])
   145  					if obj == nil {
   146  						t.Fatalf("%s: %s not found", test.src, test.obj)
   147  					}
   148  				} else {
   149  					t.Fatalf("%s: %s has no type parameters", test.src, names[0])
   150  				}
   151  			}
   152  
   153  			if got := obj.String(); got != test.want {
   154  				t.Errorf("%s: got %s, want %s", test.src, got, test.want)
   155  			}
   156  		})
   157  	}
   158  }
   159  
   160  func lookupTypeParamObj(list *TypeParamList, name string) Object {
   161  	for i := 0; i < list.Len(); i++ {
   162  		tpar := list.At(i)
   163  		if tpar.Obj().Name() == name {
   164  			return tpar.Obj()
   165  		}
   166  	}
   167  	return nil
   168  }
   169
View as plain text