Black Lives Matter. Support the Equal Justice Initiative.

Source file src/go/types/typestring_test.go

Documentation: go/types

     1  // Copyright 2012 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  	"go/ast"
     9  	"go/importer"
    10  	"go/parser"
    11  	"go/token"
    12  	"internal/testenv"
    13  	"testing"
    14  
    15  	. "go/types"
    16  )
    17  
    18  const filename = "<src>"
    19  
    20  func makePkg(src string) (*Package, error) {
    21  	fset := token.NewFileSet()
    22  	file, err := parser.ParseFile(fset, filename, src, parser.DeclarationErrors)
    23  	if err != nil {
    24  		return nil, err
    25  	}
    26  	// use the package name as package path
    27  	conf := Config{Importer: importer.Default()}
    28  	return conf.Check(file.Name.Name, fset, []*ast.File{file}, nil)
    29  }
    30  
    31  type testEntry struct {
    32  	src, str string
    33  }
    34  
    35  // dup returns a testEntry where both src and str are the same.
    36  func dup(s string) testEntry {
    37  	return testEntry{s, s}
    38  }
    39  
    40  // types that don't depend on any other type declarations
    41  var independentTestTypes = []testEntry{
    42  	// basic types
    43  	dup("int"),
    44  	dup("float32"),
    45  	dup("string"),
    46  
    47  	// arrays
    48  	dup("[10]int"),
    49  
    50  	// slices
    51  	dup("[]int"),
    52  	dup("[][]int"),
    53  
    54  	// structs
    55  	dup("struct{}"),
    56  	dup("struct{x int}"),
    57  	{`struct {
    58  		x, y int
    59  		z float32 "foo"
    60  	}`, `struct{x int; y int; z float32 "foo"}`},
    61  	{`struct {
    62  		string
    63  		elems []complex128
    64  	}`, `struct{string; elems []complex128}`},
    65  
    66  	// pointers
    67  	dup("*int"),
    68  	dup("***struct{}"),
    69  	dup("*struct{a int; b float32}"),
    70  
    71  	// functions
    72  	dup("func()"),
    73  	dup("func(x int)"),
    74  	{"func(x, y int)", "func(x int, y int)"},
    75  	{"func(x, y int, z string)", "func(x int, y int, z string)"},
    76  	dup("func(int)"),
    77  	{"func(int, string, byte)", "func(int, string, byte)"},
    78  
    79  	dup("func() int"),
    80  	{"func() (string)", "func() string"},
    81  	dup("func() (u int)"),
    82  	{"func() (u, v int, w string)", "func() (u int, v int, w string)"},
    83  
    84  	dup("func(int) string"),
    85  	dup("func(x int) string"),
    86  	dup("func(x int) (u string)"),
    87  	{"func(x, y int) (u string)", "func(x int, y int) (u string)"},
    88  
    89  	dup("func(...int) string"),
    90  	dup("func(x ...int) string"),
    91  	dup("func(x ...int) (u string)"),
    92  	{"func(x int, y ...int) (u string)", "func(x int, y ...int) (u string)"},
    93  
    94  	// interfaces
    95  	dup("interface{}"),
    96  	dup("interface{m()}"),
    97  	dup(`interface{String() string; m(int) float32}`),
    98  
    99  	// TODO(rFindley) uncomment this once this AST is accepted, and add more test
   100  	// cases.
   101  	// dup(`interface{type int, float32, complex128}`),
   102  
   103  	// maps
   104  	dup("map[string]int"),
   105  	{"map[struct{x, y int}][]byte", "map[struct{x int; y int}][]byte"},
   106  
   107  	// channels
   108  	dup("chan<- chan int"),
   109  	dup("chan<- <-chan int"),
   110  	dup("<-chan <-chan int"),
   111  	dup("chan (<-chan int)"),
   112  	dup("chan<- func()"),
   113  	dup("<-chan []func() int"),
   114  }
   115  
   116  // types that depend on other type declarations (src in TestTypes)
   117  var dependentTestTypes = []testEntry{
   118  	// interfaces
   119  	dup(`interface{io.Reader; io.Writer}`),
   120  	dup(`interface{m() int; io.Writer}`),
   121  	{`interface{m() interface{T}}`, `interface{m() interface{p.T}}`},
   122  }
   123  
   124  func TestTypeString(t *testing.T) {
   125  	testenv.MustHaveGoBuild(t)
   126  
   127  	var tests []testEntry
   128  	tests = append(tests, independentTestTypes...)
   129  	tests = append(tests, dependentTestTypes...)
   130  
   131  	for _, test := range tests {
   132  		src := `package p; import "io"; type _ io.Writer; type T ` + test.src
   133  		pkg, err := makePkg(src)
   134  		if err != nil {
   135  			t.Errorf("%s: %s", src, err)
   136  			continue
   137  		}
   138  		typ := pkg.Scope().Lookup("T").Type().Underlying()
   139  		if got := typ.String(); got != test.str {
   140  			t.Errorf("%s: got %s, want %s", test.src, got, test.str)
   141  		}
   142  	}
   143  }
   144  
   145  func TestIncompleteInterfaces(t *testing.T) {
   146  	sig := NewSignature(nil, nil, nil, false)
   147  	m := NewFunc(token.NoPos, nil, "m", sig)
   148  	for _, test := range []struct {
   149  		typ  *Interface
   150  		want string
   151  	}{
   152  		{new(Interface), "interface{/* incomplete */}"},
   153  		{new(Interface).Complete(), "interface{}"},
   154  
   155  		{NewInterface(nil, nil), "interface{}"},
   156  		{NewInterface(nil, nil).Complete(), "interface{}"},
   157  		{NewInterface([]*Func{}, nil), "interface{}"},
   158  		{NewInterface([]*Func{}, nil).Complete(), "interface{}"},
   159  		{NewInterface(nil, []*Named{}), "interface{}"},
   160  		{NewInterface(nil, []*Named{}).Complete(), "interface{}"},
   161  		{NewInterface([]*Func{m}, nil), "interface{m() /* incomplete */}"},
   162  		{NewInterface([]*Func{m}, nil).Complete(), "interface{m()}"},
   163  		{NewInterface(nil, []*Named{newDefined(new(Interface).Complete())}), "interface{T /* incomplete */}"},
   164  		{NewInterface(nil, []*Named{newDefined(new(Interface).Complete())}).Complete(), "interface{T}"},
   165  		{NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil))}), "interface{T /* incomplete */}"},
   166  		{NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil).Complete())}), "interface{T /* incomplete */}"},
   167  		{NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil).Complete())}).Complete(), "interface{T}"},
   168  
   169  		{NewInterfaceType(nil, nil), "interface{}"},
   170  		{NewInterfaceType(nil, nil).Complete(), "interface{}"},
   171  		{NewInterfaceType([]*Func{}, nil), "interface{}"},
   172  		{NewInterfaceType([]*Func{}, nil).Complete(), "interface{}"},
   173  		{NewInterfaceType(nil, []Type{}), "interface{}"},
   174  		{NewInterfaceType(nil, []Type{}).Complete(), "interface{}"},
   175  		{NewInterfaceType([]*Func{m}, nil), "interface{m() /* incomplete */}"},
   176  		{NewInterfaceType([]*Func{m}, nil).Complete(), "interface{m()}"},
   177  		{NewInterfaceType(nil, []Type{new(Interface).Complete()}), "interface{interface{} /* incomplete */}"},
   178  		{NewInterfaceType(nil, []Type{new(Interface).Complete()}).Complete(), "interface{interface{}}"},
   179  		{NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil)}), "interface{interface{m() /* incomplete */} /* incomplete */}"},
   180  		{NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil).Complete()}), "interface{interface{m()} /* incomplete */}"},
   181  		{NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil).Complete()}).Complete(), "interface{interface{m()}}"},
   182  	} {
   183  		got := test.typ.String()
   184  		if got != test.want {
   185  			t.Errorf("got: %s, want: %s", got, test.want)
   186  		}
   187  	}
   188  }
   189  
   190  // newDefined creates a new defined type named T with the given underlying type.
   191  // Helper function for use with TestIncompleteInterfaces only.
   192  func newDefined(underlying Type) *Named {
   193  	tname := NewTypeName(token.NoPos, nil, "T", nil)
   194  	return NewNamed(tname, underlying, nil)
   195  }
   196  
   197  func TestQualifiedTypeString(t *testing.T) {
   198  	p, _ := pkgFor("p.go", "package p; type T int", nil)
   199  	q, _ := pkgFor("q.go", "package q", nil)
   200  
   201  	pT := p.Scope().Lookup("T").Type()
   202  	for _, test := range []struct {
   203  		typ  Type
   204  		this *Package
   205  		want string
   206  	}{
   207  		{nil, nil, "<nil>"},
   208  		{pT, nil, "p.T"},
   209  		{pT, p, "T"},
   210  		{pT, q, "p.T"},
   211  		{NewPointer(pT), p, "*T"},
   212  		{NewPointer(pT), q, "*p.T"},
   213  	} {
   214  		qualifier := func(pkg *Package) string {
   215  			if pkg != test.this {
   216  				return pkg.Name()
   217  			}
   218  			return ""
   219  		}
   220  		if got := TypeString(test.typ, qualifier); got != test.want {
   221  			t.Errorf("TypeString(%s, %s) = %s, want %s",
   222  				test.this, test.typ, got, test.want)
   223  		}
   224  	}
   225  }
   226  

View as plain text