resolver_test.go

Documentation: go/types

		 1  // Copyright 2011 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  	"go/ast"
		10  	"go/importer"
		11  	"go/parser"
		12  	"go/token"
		13  	"internal/testenv"
		14  	"sort"
		15  	"testing"
		16  
		17  	. "go/types"
		18  )
		19  
		20  type resolveTestImporter struct {
		21  	importer ImporterFrom
		22  	imported map[string]bool
		23  }
		24  
		25  func (imp *resolveTestImporter) Import(string) (*Package, error) {
		26  	panic("should not be called")
		27  }
		28  
		29  func (imp *resolveTestImporter) ImportFrom(path, srcDir string, mode ImportMode) (*Package, error) {
		30  	if mode != 0 {
		31  		panic("mode must be 0")
		32  	}
		33  	if imp.importer == nil {
		34  		imp.importer = importer.Default().(ImporterFrom)
		35  		imp.imported = make(map[string]bool)
		36  	}
		37  	pkg, err := imp.importer.ImportFrom(path, srcDir, mode)
		38  	if err != nil {
		39  		return nil, err
		40  	}
		41  	imp.imported[path] = true
		42  	return pkg, nil
		43  }
		44  
		45  func TestResolveIdents(t *testing.T) {
		46  	testenv.MustHaveGoBuild(t)
		47  
		48  	sources := []string{
		49  		`
		50  		package p
		51  		import "fmt"
		52  		import "math"
		53  		const pi = math.Pi
		54  		func sin(x float64) float64 {
		55  			return math.Sin(x)
		56  		}
		57  		var Println = fmt.Println
		58  		`,
		59  		`
		60  		package p
		61  		import "fmt"
		62  		type errorStringer struct { fmt.Stringer; error }
		63  		func f() string {
		64  			_ = "foo"
		65  			return fmt.Sprintf("%d", g())
		66  		}
		67  		func g() (x int) { return }
		68  		`,
		69  		`
		70  		package p
		71  		import . "go/parser"
		72  		import "sync"
		73  		func h() Mode { return ImportsOnly }
		74  		var _, x int = 1, 2
		75  		func init() {}
		76  		type T struct{ *sync.Mutex; a, b, c int}
		77  		type I interface{ m() }
		78  		var _ = T{a: 1, b: 2, c: 3}
		79  		func (_ T) m() {}
		80  		func (T) _() {}
		81  		var i I
		82  		var _ = i.m
		83  		func _(s []int) { for i, x := range s { _, _ = i, x } }
		84  		func _(x interface{}) {
		85  			switch x := x.(type) {
		86  			case int:
		87  				_ = x
		88  			}
		89  			switch {} // implicit 'true' tag
		90  		}
		91  		`,
		92  		`
		93  		package p
		94  		type S struct{}
		95  		func (T) _() {}
		96  		func (T) _() {}
		97  		`,
		98  		`
		99  		package p
	 100  		func _() {
	 101  		L0:
	 102  		L1:
	 103  			goto L0
	 104  			for {
	 105  				goto L1
	 106  			}
	 107  			if true {
	 108  				goto L2
	 109  			}
	 110  		L2:
	 111  		}
	 112  		`,
	 113  	}
	 114  
	 115  	pkgnames := []string{
	 116  		"fmt",
	 117  		"math",
	 118  	}
	 119  
	 120  	// parse package files
	 121  	fset := token.NewFileSet()
	 122  	var files []*ast.File
	 123  	for i, src := range sources {
	 124  		f, err := parser.ParseFile(fset, fmt.Sprintf("sources[%d]", i), src, parser.DeclarationErrors)
	 125  		if err != nil {
	 126  			t.Fatal(err)
	 127  		}
	 128  		files = append(files, f)
	 129  	}
	 130  
	 131  	// resolve and type-check package AST
	 132  	importer := new(resolveTestImporter)
	 133  	conf := Config{Importer: importer}
	 134  	uses := make(map[*ast.Ident]Object)
	 135  	defs := make(map[*ast.Ident]Object)
	 136  	_, err := conf.Check("testResolveIdents", fset, files, &Info{Defs: defs, Uses: uses})
	 137  	if err != nil {
	 138  		t.Fatal(err)
	 139  	}
	 140  
	 141  	// check that all packages were imported
	 142  	for _, name := range pkgnames {
	 143  		if !importer.imported[name] {
	 144  			t.Errorf("package %s not imported", name)
	 145  		}
	 146  	}
	 147  
	 148  	// check that qualified identifiers are resolved
	 149  	for _, f := range files {
	 150  		ast.Inspect(f, func(n ast.Node) bool {
	 151  			if s, ok := n.(*ast.SelectorExpr); ok {
	 152  				if x, ok := s.X.(*ast.Ident); ok {
	 153  					obj := uses[x]
	 154  					if obj == nil {
	 155  						t.Errorf("%s: unresolved qualified identifier %s", fset.Position(x.Pos()), x.Name)
	 156  						return false
	 157  					}
	 158  					if _, ok := obj.(*PkgName); ok && uses[s.Sel] == nil {
	 159  						t.Errorf("%s: unresolved selector %s", fset.Position(s.Sel.Pos()), s.Sel.Name)
	 160  						return false
	 161  					}
	 162  					return false
	 163  				}
	 164  				return false
	 165  			}
	 166  			return true
	 167  		})
	 168  	}
	 169  
	 170  	for id, obj := range uses {
	 171  		if obj == nil {
	 172  			t.Errorf("%s: Uses[%s] == nil", fset.Position(id.Pos()), id.Name)
	 173  		}
	 174  	}
	 175  
	 176  	// check that each identifier in the source is found in uses or defs or both
	 177  	var both []string
	 178  	for _, f := range files {
	 179  		ast.Inspect(f, func(n ast.Node) bool {
	 180  			if x, ok := n.(*ast.Ident); ok {
	 181  				var objects int
	 182  				if _, found := uses[x]; found {
	 183  					objects |= 1
	 184  					delete(uses, x)
	 185  				}
	 186  				if _, found := defs[x]; found {
	 187  					objects |= 2
	 188  					delete(defs, x)
	 189  				}
	 190  				if objects == 0 {
	 191  					t.Errorf("%s: unresolved identifier %s", fset.Position(x.Pos()), x.Name)
	 192  				} else if objects == 3 {
	 193  					both = append(both, x.Name)
	 194  				}
	 195  				return false
	 196  			}
	 197  			return true
	 198  		})
	 199  	}
	 200  
	 201  	// check the expected set of idents that are simultaneously uses and defs
	 202  	sort.Strings(both)
	 203  	if got, want := fmt.Sprint(both), "[Mutex Stringer error]"; got != want {
	 204  		t.Errorf("simultaneous uses/defs = %s, want %s", got, want)
	 205  	}
	 206  
	 207  	// any left-over identifiers didn't exist in the source
	 208  	for x := range uses {
	 209  		t.Errorf("%s: identifier %s not present in source", fset.Position(x.Pos()), x.Name)
	 210  	}
	 211  	for x := range defs {
	 212  		t.Errorf("%s: identifier %s not present in source", fset.Position(x.Pos()), x.Name)
	 213  	}
	 214  
	 215  	// TODO(gri) add tests to check ImplicitObj callbacks
	 216  }
	 217
View as plain text