resolver_test.go

Documentation: go/parser

		 1  // Copyright 2021 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 parser
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"go/ast"
		10  	"go/internal/typeparams"
		11  	"go/scanner"
		12  	"go/token"
		13  	"os"
		14  	"path/filepath"
		15  	"strings"
		16  	"testing"
		17  )
		18  
		19  // TestResolution checks that identifiers are resolved to the declarations
		20  // annotated in the source, by comparing the positions of the resulting
		21  // Ident.Obj.Decl to positions marked in the source via special comments.
		22  //
		23  // In the test source, any comment prefixed with '=' or '@' (or both) marks the
		24  // previous token position as the declaration ('=') or a use ('@') of an
		25  // identifier. The text following '=' and '@' in the comment string is the
		26  // label to use for the location.	Declaration labels must be unique within the
		27  // file, and use labels must refer to an existing declaration label. It's OK
		28  // for a comment to denote both the declaration and use of a label (e.g.
		29  // '=@foo'). Leading and trailing whitespace is ignored. Any comment not
		30  // beginning with '=' or '@' is ignored.
		31  func TestResolution(t *testing.T) {
		32  	dir := filepath.Join("testdata", "resolution")
		33  	fis, err := os.ReadDir(dir)
		34  	if err != nil {
		35  		t.Fatal(err)
		36  	}
		37  
		38  	for _, fi := range fis {
		39  		t.Run(fi.Name(), func(t *testing.T) {
		40  			fset := token.NewFileSet()
		41  			path := filepath.Join(dir, fi.Name())
		42  			src := readFile(path) // panics on failure
		43  			var mode Mode
		44  			if strings.HasSuffix(path, ".go2") {
		45  				if !typeparams.Enabled {
		46  					t.Skip("type params are not enabled")
		47  				}
		48  			} else {
		49  				mode |= typeparams.DisallowParsing
		50  			}
		51  			file, err := ParseFile(fset, path, src, mode)
		52  			if err != nil {
		53  				t.Fatal(err)
		54  			}
		55  
		56  			// Compare the positions of objects resolved during parsing (fromParser)
		57  			// to those annotated in source comments (fromComments).
		58  
		59  			handle := fset.File(file.Package)
		60  			fromParser := declsFromParser(file)
		61  			fromComments := declsFromComments(handle, src)
		62  
		63  			pos := func(pos token.Pos) token.Position {
		64  				p := handle.Position(pos)
		65  				// The file name is implied by the subtest, so remove it to avoid
		66  				// clutter in error messages.
		67  				p.Filename = ""
		68  				return p
		69  			}
		70  			for k, want := range fromComments {
		71  				if got := fromParser[k]; got != want {
		72  					t.Errorf("%s resolved to %s, want %s", pos(k), pos(got), pos(want))
		73  				}
		74  				delete(fromParser, k)
		75  			}
		76  			// What remains in fromParser are unexpected resolutions.
		77  			for k, got := range fromParser {
		78  				t.Errorf("%s resolved to %s, want no object", pos(k), pos(got))
		79  			}
		80  		})
		81  	}
		82  }
		83  
		84  // declsFromParser walks the file and collects the map associating an
		85  // identifier position with its declaration position.
		86  func declsFromParser(file *ast.File) map[token.Pos]token.Pos {
		87  	objmap := map[token.Pos]token.Pos{}
		88  	ast.Inspect(file, func(node ast.Node) bool {
		89  		// Ignore blank identifiers to reduce noise.
		90  		if ident, _ := node.(*ast.Ident); ident != nil && ident.Obj != nil && ident.Name != "_" {
		91  			objmap[ident.Pos()] = ident.Obj.Pos()
		92  		}
		93  		return true
		94  	})
		95  	return objmap
		96  }
		97  
		98  // declsFromComments looks at comments annotating uses and declarations, and
		99  // maps each identifier use to its corresponding declaration. See the
	 100  // description of these annotations in the documentation for TestResolution.
	 101  func declsFromComments(handle *token.File, src []byte) map[token.Pos]token.Pos {
	 102  	decls, uses := positionMarkers(handle, src)
	 103  
	 104  	objmap := make(map[token.Pos]token.Pos)
	 105  	// Join decls and uses on name, to build the map of use->decl.
	 106  	for name, posns := range uses {
	 107  		declpos, ok := decls[name]
	 108  		if !ok {
	 109  			panic(fmt.Sprintf("missing declaration for %s", name))
	 110  		}
	 111  		for _, pos := range posns {
	 112  			objmap[pos] = declpos
	 113  		}
	 114  	}
	 115  	return objmap
	 116  }
	 117  
	 118  // positionMarkers extracts named positions from the source denoted by comments
	 119  // prefixed with '=' (declarations) and '@' (uses): for example '@foo' or
	 120  // '=@bar'. It returns a map of name->position for declarations, and
	 121  // name->position(s) for uses.
	 122  func positionMarkers(handle *token.File, src []byte) (decls map[string]token.Pos, uses map[string][]token.Pos) {
	 123  	var s scanner.Scanner
	 124  	s.Init(handle, src, nil, scanner.ScanComments)
	 125  	decls = make(map[string]token.Pos)
	 126  	uses = make(map[string][]token.Pos)
	 127  	var prev token.Pos // position of last non-comment, non-semicolon token
	 128  
	 129  scanFile:
	 130  	for {
	 131  		pos, tok, lit := s.Scan()
	 132  		switch tok {
	 133  		case token.EOF:
	 134  			break scanFile
	 135  		case token.COMMENT:
	 136  			name, decl, use := annotatedObj(lit)
	 137  			if len(name) > 0 {
	 138  				if decl {
	 139  					if _, ok := decls[name]; ok {
	 140  						panic(fmt.Sprintf("duplicate declaration markers for %s", name))
	 141  					}
	 142  					decls[name] = prev
	 143  				}
	 144  				if use {
	 145  					uses[name] = append(uses[name], prev)
	 146  				}
	 147  			}
	 148  		case token.SEMICOLON:
	 149  			// ignore automatically inserted semicolon
	 150  			if lit == "\n" {
	 151  				continue scanFile
	 152  			}
	 153  			fallthrough
	 154  		default:
	 155  			prev = pos
	 156  		}
	 157  	}
	 158  	return decls, uses
	 159  }
	 160  
	 161  func annotatedObj(lit string) (name string, decl, use bool) {
	 162  	if lit[1] == '*' {
	 163  		lit = lit[:len(lit)-2] // strip trailing */
	 164  	}
	 165  	lit = strings.TrimSpace(lit[2:])
	 166  
	 167  scanLit:
	 168  	for idx, r := range lit {
	 169  		switch r {
	 170  		case '=':
	 171  			decl = true
	 172  		case '@':
	 173  			use = true
	 174  		default:
	 175  			name = lit[idx:]
	 176  			break scanLit
	 177  		}
	 178  	}
	 179  	return
	 180  }
	 181
View as plain text