object_test.go

Documentation: go/types

		 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
		 6  
		 7  import (
		 8  	"go/ast"
		 9  	"go/parser"
		10  	"go/token"
		11  	"testing"
		12  )
		13  
		14  func TestIsAlias(t *testing.T) {
		15  	check := func(obj *TypeName, want bool) {
		16  		if got := obj.IsAlias(); got != want {
		17  			t.Errorf("%v: got IsAlias = %v; want %v", obj, got, want)
		18  		}
		19  	}
		20  
		21  	// predeclared types
		22  	check(Unsafe.Scope().Lookup("Pointer").(*TypeName), false)
		23  	for _, name := range Universe.Names() {
		24  		if obj, _ := Universe.Lookup(name).(*TypeName); obj != nil {
		25  			check(obj, name == "byte" || name == "rune")
		26  		}
		27  	}
		28  
		29  	// various other types
		30  	pkg := NewPackage("p", "p")
		31  	t1 := NewTypeName(0, pkg, "t1", nil)
		32  	n1 := NewNamed(t1, new(Struct), nil)
		33  	for _, test := range []struct {
		34  		name	*TypeName
		35  		alias bool
		36  	}{
		37  		{NewTypeName(0, nil, "t0", nil), false},						// no type yet
		38  		{NewTypeName(0, pkg, "t0", nil), false},						// no type yet
		39  		{t1, false},																				// type name refers to named type and vice versa
		40  		{NewTypeName(0, nil, "t2", &emptyInterface), true}, // type name refers to unnamed type
		41  		{NewTypeName(0, pkg, "t3", n1), true},							// type name refers to named type with different type name
		42  		{NewTypeName(0, nil, "t4", Typ[Int32]), true},			// type name refers to basic type with different name
		43  		{NewTypeName(0, nil, "int32", Typ[Int32]), false},	// type name refers to basic type with same name
		44  		{NewTypeName(0, pkg, "int32", Typ[Int32]), true},	 // type name is declared in user-defined package (outside Universe)
		45  		{NewTypeName(0, nil, "rune", Typ[Rune]), true},		 // type name refers to basic type rune which is an alias already
		46  	} {
		47  		check(test.name, test.alias)
		48  	}
		49  }
		50  
		51  // TestEmbeddedMethod checks that an embedded method is represented by
		52  // the same Func Object as the original method. See also issue #34421.
		53  func TestEmbeddedMethod(t *testing.T) {
		54  	const src = `package p; type I interface { error }`
		55  
		56  	// type-check src
		57  	fset := token.NewFileSet()
		58  	f, err := parser.ParseFile(fset, "", src, 0)
		59  	if err != nil {
		60  		t.Fatalf("parse failed: %s", err)
		61  	}
		62  	var conf Config
		63  	pkg, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, nil)
		64  	if err != nil {
		65  		t.Fatalf("typecheck failed: %s", err)
		66  	}
		67  
		68  	// get original error.Error method
		69  	eface := Universe.Lookup("error")
		70  	orig, _, _ := LookupFieldOrMethod(eface.Type(), false, nil, "Error")
		71  	if orig == nil {
		72  		t.Fatalf("original error.Error not found")
		73  	}
		74  
		75  	// get embedded error.Error method
		76  	iface := pkg.Scope().Lookup("I")
		77  	embed, _, _ := LookupFieldOrMethod(iface.Type(), false, nil, "Error")
		78  	if embed == nil {
		79  		t.Fatalf("embedded error.Error not found")
		80  	}
		81  
		82  	// original and embedded Error object should be identical
		83  	if orig != embed {
		84  		t.Fatalf("%s (%p) != %s (%p)", orig, orig, embed, embed)
		85  	}
		86  }
		87
View as plain text