all: use SkipObjectResolution mode in parser.ParseFile calls where possible

Object resolution during parsing has always been problematic because there
is incomplete type information, and the mechanism has beeen deprecated several
years ago. Because of backward-compatibility, the mechanism - which was always
enabled originally - must be explicitly disabled via the SkipObjectResolution
mode. Almost none of the code in the std library requires it.

Pass the SkipObjectResolution mode to parser.ParseFile where possible.
This eliminates a typically unnecessary phase and may speed up the
ParseFile call.

Change-Id: Id74a4e8ca0cee781bc90b7d585f332a5220843b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/779982
LUCI-TryBot-Result: golang-scoped@luci-project-accounts.iam.gserviceaccount.com <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
Auto-Submit: Robert Griesemer <gri@google.com>

src/cmd/api/main_test.go

@@ -389,7 +389,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 		return f, nil
 	}
 
-	f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
+	f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		return nil, err
 	}

src/cmd/cgo/internal/testerrors/argposition_test.go

@@ -96,7 +96,7 @@ func TestArgumentsPositions(t *testing.T) {
 		t.Fatal(err)
 	}
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", mainProcessed, parser.AllErrors)
+	f, err := parser.ParseFile(fset, "", mainProcessed, parser.AllErrors|parser.SkipObjectResolution)
 	if err != nil {
 		fmt.Println(err)
 		return

src/cmd/compile/internal/ssa/_gen/rulegen.go

@@ -289,7 +289,7 @@ func genRulesSuffix(arch arch, suff string) {
 	buf := new(bytes.Buffer)
 	fprint(buf, genFile)
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "", buf, parser.ParseComments)
+	file, err := parser.ParseFile(fset, "", buf, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		filename := fmt.Sprintf("%s_broken.go", arch.name)
 		if err := os.WriteFile(filename, buf.Bytes(), 0644); err != nil {
@@ -841,7 +841,7 @@ func exprf(format string, a ...interface{}) ast.Expr {
 func stmtf(format string, a ...interface{}) Statement {
 	src := fmt.Sprintf(format, a...)
 	fsrc := "package p\nfunc _() {\n" + src + "\n}\n"
-	file, err := parser.ParseFile(token.NewFileSet(), "", fsrc, 0)
+	file, err := parser.ParseFile(token.NewFileSet(), "", fsrc, parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatalf("stmt parse error on %q: %v", src, err)
 	}

src/cmd/compile/internal/test/ssa_test.go

@@ -95,7 +95,7 @@ func TestCode(t *testing.T) {
 			t.Fatalf("can't read testdata/%s: %v", f.Name(), err)
 		}
 		fset := token.NewFileSet()
-		code, err := parser.ParseFile(fset, f.Name(), text, 0)
+		code, err := parser.ParseFile(fset, f.Name(), text, parser.SkipObjectResolution)
 		if err != nil {
 			t.Fatalf("can't parse testdata/%s: %v", f.Name(), err)
 		}

src/cmd/compile/internal/typecheck/mkbuiltin.go

@@ -79,7 +79,7 @@ func params(tlist ...*types.Type) []*types.Field {
 
 func mkbuiltin(w io.Writer, name string) {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, filepath.Join("_builtin", name+".go"), nil, 0)
+	f, err := parser.ParseFile(fset, filepath.Join("_builtin", name+".go"), nil, parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatal(err)
 	}

src/cmd/cover/cover.go

@@ -773,7 +773,7 @@ func (p *Package) annotateFile(name string, fd io.Writer) {
 	if err != nil {
 		log.Fatalf("cover: %s: %s", name, err)
 	}
-	parsedFile, err := parser.ParseFile(fset, name, content, parser.ParseComments)
+	parsedFile, err := parser.ParseFile(fset, name, content, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatalf("cover: %s: %s", name, err)
 	}

src/cmd/cover/cover_test.go

@@ -259,7 +259,7 @@ func TestDirectives(t *testing.T) {
 	// come before the beginning of the named declaration and after the end
 	// of the previous declaration.
 	fset := token.NewFileSet()
-	astFile, err := parser.ParseFile(fset, testDirectives, output, 0)
+	astFile, err := parser.ParseFile(fset, testDirectives, output, parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/cmd/cover/func.go

@@ -93,7 +93,7 @@ func funcOutput(profile, outputFile string) error {
 // findFuncs parses the file and returns a slice of FuncExtent descriptors.
 func findFuncs(name string) ([]*FuncExtent, error) {
 	fset := token.NewFileSet()
-	parsedFile, err := parser.ParseFile(fset, name, nil, 0)
+	parsedFile, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution)
 	if err != nil {
 		return nil, err
 	}

src/cmd/go/internal/generate/generate.go

@@ -244,7 +244,7 @@ func generate(absFile string) bool {
 	}
 
 	// Parse package clause
-	filePkg, err := parser.ParseFile(token.NewFileSet(), "", src, parser.PackageClauseOnly)
+	filePkg, err := parser.ParseFile(token.NewFileSet(), "", src, parser.PackageClauseOnly|parser.SkipObjectResolution)
 	if err != nil {
 		// Invalid package clause - ignore file.
 		return true

src/cmd/go/internal/modindex/build_read.go

@@ -304,7 +304,7 @@ func readGoInfo(f io.Reader, info *fileInfo) error {
 	}
 
 	// Parse file header & record imports.
-	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments)
+	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments|parser.SkipObjectResolution)
 	if info.parseErr != nil {
 		return nil
 	}

src/cmd/gofmt/gofmt.go

@@ -79,7 +79,7 @@ func usage() {
 }
 
 func initParserMode() {
-	parserMode = parser.ParseComments
+	parserMode = parser.ParseComments | parser.SkipObjectResolution
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}

src/cmd/internal/dwarf/putvarabbrevgen_test.go

@@ -80,7 +80,7 @@ func TestPutVarAbbrevGenerator(t *testing.T) {
 
 func pvagenerate(t *testing.T) string {
 	var fset token.FileSet
-	f, err := parser.ParseFile(&fset, "./dwarf.go", nil, parser.ParseComments)
+	f, err := parser.ParseFile(&fset, "./dwarf.go", nil, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/cmd/internal/goobj/mkbuiltin.go

@@ -53,7 +53,7 @@ func mkbuiltin(w io.Writer) {
 	const pkg = "runtime"
 	fset := token.NewFileSet()
 	path := filepath.Join("..", "..", "compile", "internal", "typecheck", "_builtin", "runtime.go")
-	f, err := parser.ParseFile(fset, path, nil, 0)
+	f, err := parser.ParseFile(fset, path, nil, parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatal(err)
 	}

src/go/ast/ast.go

@@ -1113,7 +1113,7 @@ func (p *Package) End() token.Pos { return token.NoPos }
 // The syntax tree must have been parsed with the [go/parser.ParseComments] flag.
 // Example:
 //
-//	f, err := parser.ParseFile(fset, filename, src, parser.ParseComments|parser.PackageClauseOnly)
+//	f, err := parser.ParseFile(fset, filename, src, parser.ParseComments|parser.PackageClauseOnly|parser.SkipObjectResolution)
 //	if err != nil { ... }
 //	gen := ast.IsGenerated(f)
 func IsGenerated(file *File) bool {

src/go/ast/commentmap_test.go

@@ -103,7 +103,7 @@ func ctext(list []*CommentGroup) string {
 
 func TestCommentMap(t *testing.T) {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -141,7 +141,7 @@ func TestCommentMap(t *testing.T) {
 
 func TestFilter(t *testing.T) {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/go/ast/example_test.go

@@ -24,7 +24,7 @@ var X = f(3.14)*2 + c
 
 	// Create the AST by parsing src.
 	fset := token.NewFileSet() // positions are relative to fset
-	f, err := parser.ParseFile(fset, "src.go", src, 0)
+	f, err := parser.ParseFile(fset, "src.go", src, parser.SkipObjectResolution)
 	if err != nil {
 		panic(err)
 	}
@@ -66,8 +66,8 @@ func main() {
 `
 
 	// Create the AST by parsing src.
-	fset := token.NewFileSet() // positions are relative to fset
-	f, err := parser.ParseFile(fset, "", src, 0)
+	fset := token.NewFileSet()                   // positions are relative to fset
+	f, err := parser.ParseFile(fset, "", src, 0) // requires object resolution
 	if err != nil {
 		panic(err)
 	}
@@ -151,7 +151,7 @@ func f(x, y int) {
 `
 
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", src, 0)
+	f, err := parser.ParseFile(fset, "", src, parser.SkipObjectResolution)
 	if err != nil {
 		panic(err)
 	}
@@ -200,7 +200,7 @@ func main() {
 
 	// Create the AST by parsing src.
 	fset := token.NewFileSet() // positions are relative to fset
-	f, err := parser.ParseFile(fset, "src.go", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "src.go", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		panic(err)
 	}

src/go/ast/filter_test.go

@@ -57,7 +57,7 @@ func (x *t2) f2() {}
 func TestFilterDuplicates(t *testing.T) {
 	// parse input
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "", input, 0)
+	file, err := parser.ParseFile(fset, "", input, 0) // requires object resolution
 	if err != nil {
 		t.Fatal(err)
 	}

src/go/ast/issues_test.go

@@ -19,7 +19,7 @@ func TestIssue33649(t *testing.T) {
 		`package p; func _() { _ = 0 }`,
 	} {
 		fset := token.NewFileSet()
-		f, _ := parser.ParseFile(fset, "", src, parser.AllErrors)
+		f, _ := parser.ParseFile(fset, "", src, parser.AllErrors|parser.SkipObjectResolution)
 		if f == nil {
 			panic("invalid test setup: parser didn't return an AST")
 		}
@@ -125,7 +125,7 @@ package p
 `, true},
 	} {
 		fset := token.NewFileSet()
-		f, err := parser.ParseFile(fset, "", test.src, parser.PackageClauseOnly|parser.ParseComments)
+		f, err := parser.ParseFile(fset, "", test.src, parser.PackageClauseOnly|parser.ParseComments|parser.SkipObjectResolution)
 		if f == nil {
 			t.Fatalf("parse %d failed to return AST: %v", i, err)
 		}

src/go/ast/walk_test.go

@@ -46,7 +46,7 @@ func g() {
 }
 `
 	fset := token.NewFileSet()
-	f, _ := parser.ParseFile(fset, "a.go", src, 0)
+	f, _ := parser.ParseFile(fset, "a.go", src, parser.SkipObjectResolution)
 
 	str := func(n ast.Node) string {
 		return strings.TrimPrefix(reflect.TypeOf(n).String(), "*ast.")

src/go/build/read.go

@@ -311,7 +311,7 @@ func readGoInfo(f io.Reader, info *fileInfo) error {
 	}
 
 	// Parse file header & record imports.
-	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments)
+	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments|parser.SkipObjectResolution)
 	if info.parseErr != nil {
 		return nil
 	}

src/go/doc/doc_test.go

@@ -154,7 +154,7 @@ func Test(t *testing.T) {
 
 func TestFuncs(t *testing.T) {
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "funcs.go", strings.NewReader(funcsTestFile), parser.ParseComments)
+	file, err := parser.ParseFile(fset, "funcs.go", strings.NewReader(funcsTestFile), parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/go/doc/example_internal_test.go

@@ -100,7 +100,7 @@ import (
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			fset := token.NewFileSet()
-			file, err := parser.ParseFile(fset, "test.go", strings.NewReader(test.in), parser.ParseComments)
+			file, err := parser.ParseFile(fset, "test.go", strings.NewReader(test.in), parser.ParseComments|parser.SkipObjectResolution)
 			if err != nil {
 				t.Fatal(err)
 			}

src/go/doc/example_test.go

@@ -29,7 +29,7 @@ func TestExamples(t *testing.T) {
 	for _, filename := range filenames {
 		t.Run(strings.TrimSuffix(filepath.Base(filename), ".go"), func(t *testing.T) {
 			fset := token.NewFileSet()
-			astFile, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
+			astFile, err := parser.ParseFile(fset, filename, nil, parser.ParseComments) // requires object resolution
 			if err != nil {
 				t.Fatal(err)
 			}

src/go/format/format_test.go

@@ -44,7 +44,7 @@ func TestNode(t *testing.T) {
 	}
 
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, testfile, src, parser.ParseComments)
+	file, err := parser.ParseFile(fset, testfile, src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -67,7 +67,7 @@ func TestNodeNoModify(t *testing.T) {
 	)
 
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	file, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/go/internal/gcimporter/gcimporter_test.go

@@ -231,7 +231,7 @@ func sanitizeObjectString(s string) string {
 
 func checkFile(t *testing.T, filename string, src []byte) *types.Package {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, filename, src, 0)
+	f, err := parser.ParseFile(fset, filename, src, parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -792,7 +792,7 @@ func TestIssue69912(t *testing.T) {
 	}
 
 	check := func(pkgname, src string, imports importMap) (*types.Package, error) {
-		f, err := parser.ParseFile(fset, "a.go", src, 0)
+		f, err := parser.ParseFile(fset, "a.go", src, parser.SkipObjectResolution)
 		if err != nil {
 			return nil, err
 		}

src/go/internal/gcimporter/genmeth_test.go

@@ -45,7 +45,7 @@ func TestGenMeth(t *testing.T) {
 	}
 
 	check := func(pkgname, src string, imports importMap) (*types.Package, error) {
-		f, err := parser.ParseFile(fset, "genmeth.go", src, 0)
+		f, err := parser.ParseFile(fset, "genmeth.go", src, parser.SkipObjectResolution)
 		if err != nil {
 			return nil, err
 		}

src/go/parser/example_test.go

@@ -25,7 +25,7 @@ func bar() {
 }`
 
 	// Parse src but stop after processing the imports.
-	f, err := parser.ParseFile(fset, "", src, parser.ImportsOnly)
+	f, err := parser.ParseFile(fset, "", src, parser.ImportsOnly|parser.SkipObjectResolution)
 	if err != nil {
 		fmt.Println(err)
 		return

src/go/printer/example_test.go

@@ -16,7 +16,7 @@ import (
 
 func parseFunc(filename, functionname string) (fun *ast.FuncDecl, fset *token.FileSet) {
 	fset = token.NewFileSet()
-	if file, err := parser.ParseFile(fset, filename, nil, 0); err == nil {
+	if file, err := parser.ParseFile(fset, filename, nil, parser.SkipObjectResolution); err == nil {
 		for _, d := range file.Decls {
 			if f, ok := d.(*ast.FuncDecl); ok && f.Name.Name == functionname {
 				fun = f

src/go/printer/performance_test.go

@@ -41,7 +41,7 @@ func initialize() {
 		log.Fatalf("%s", err)
 	}
 
-	file, err := parser.ParseFile(fset, filename, src, parser.ParseComments)
+	file, err := parser.ParseFile(fset, filename, src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatalf("%s", err)
 	}

src/go/printer/printer_test.go

@@ -44,7 +44,7 @@ const (
 // if any.
 func format(src []byte, mode checkMode) ([]byte, error) {
 	// parse src
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		return nil, fmt.Errorf("parse: %s\n%s", err, src)
 	}
@@ -72,7 +72,7 @@ func format(src []byte, mode checkMode) ([]byte, error) {
 
 	// make sure formatted output is syntactically correct
 	res := buf.Bytes()
-	if _, err := parser.ParseFile(fset, "", res, parser.ParseComments); err != nil {
+	if _, err := parser.ParseFile(fset, "", res, parser.ParseComments|parser.SkipObjectResolution); err != nil {
 		return nil, fmt.Errorf("re-parse: %s\n%s", err, buf.Bytes())
 	}
 
@@ -220,7 +220,7 @@ func TestLineComments(t *testing.T) {
 	`
 
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		panic(err) // error in test
 	}
@@ -261,7 +261,7 @@ func init() {
 func TestBadNodes(t *testing.T) {
 	const src = "package p\n("
 	const res = "package p\nBadDecl\n"
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err == nil {
 		t.Error("expected illegal program") // error in test
 	}
@@ -284,7 +284,7 @@ func testComment(t *testing.T, f *ast.File, srclen int, comment *ast.Comment) {
 		if err := Fprint(&buf, fset, f); err != nil {
 			t.Error(err)
 		}
-		if _, err := parser.ParseFile(fset, "", buf.Bytes(), 0); err != nil {
+		if _, err := parser.ParseFile(fset, "", buf.Bytes(), parser.SkipObjectResolution); err != nil {
 			t.Fatalf("incorrect program for pos = %d:\n%s", comment.Slash, buf.String())
 		}
 		// Position information is just an offset.
@@ -315,7 +315,7 @@ func fibo(n int) {
 }
 `
 
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Error(err) // error in test
 	}
@@ -378,7 +378,7 @@ func (t *t) foo(a, b, c int) int {
 `
 
 	// parse original
-	f1, err := parser.ParseFile(fset, "src", src, parser.ParseComments)
+	f1, err := parser.ParseFile(fset, "src", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -392,7 +392,7 @@ func (t *t) foo(a, b, c int) int {
 
 	// parse pretty printed original
 	// (//line directives must be interpreted even w/o parser.ParseComments set)
-	f2, err := parser.ParseFile(fset, "", buf.Bytes(), 0)
+	f2, err := parser.ParseFile(fset, "", buf.Bytes(), parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatalf("%s\n%s", err, buf.Bytes())
 	}
@@ -460,7 +460,7 @@ func g() {
 `
 
 	// parse original
-	f1, err := parser.ParseFile(fset, "src.go", orig, 0)
+	f1, err := parser.ParseFile(fset, "src.go", orig, parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -502,7 +502,7 @@ type T struct {
 }
 `
 
-	f, err := parser.ParseFile(fset, "src.go", orig, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "src.go", orig, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -527,7 +527,7 @@ var decls = []string{
 
 func TestDeclLists(t *testing.T) {
 	for _, src := range decls {
-		file, err := parser.ParseFile(fset, "", "package p;"+src, parser.ParseComments)
+		file, err := parser.ParseFile(fset, "", "package p;"+src, parser.ParseComments|parser.SkipObjectResolution)
 		if err != nil {
 			panic(err) // error in test
 		}
@@ -553,7 +553,7 @@ var stmts = []string{
 
 func TestStmtLists(t *testing.T) {
 	for _, src := range stmts {
-		file, err := parser.ParseFile(fset, "", "package p; func _() {"+src+"}", parser.ParseComments)
+		file, err := parser.ParseFile(fset, "", "package p; func _() {"+src+"}", parser.ParseComments|parser.SkipObjectResolution)
 		if err != nil {
 			panic(err) // error in test
 		}
@@ -582,7 +582,7 @@ func TestBaseIndent(t *testing.T) {
 		panic(err) // error in test
 	}
 
-	file, err := parser.ParseFile(fset, filename, src, 0)
+	file, err := parser.ParseFile(fset, filename, src, parser.SkipObjectResolution)
 	if err != nil {
 		panic(err) // error in test
 	}
@@ -690,7 +690,7 @@ func TestWriteErrors(t *testing.T) {
 	if err != nil {
 		panic(err) // error in test
 	}
-	file, err := parser.ParseFile(fset, filename, src, 0)
+	file, err := parser.ParseFile(fset, filename, src, parser.SkipObjectResolution)
 	if err != nil {
 		panic(err) // error in test
 	}
@@ -743,7 +743,7 @@ type bar int	// comment2
 	)
 
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "input.go", input, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "input.go", input, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -774,7 +774,7 @@ type bar int	// comment2
 func TestIssue11151(t *testing.T) {
 	const src = "package p\t/*\r/1\r*\r/2*\r\r\r\r/3*\r\r+\r\r/4*/\n"
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -788,7 +788,7 @@ func TestIssue11151(t *testing.T) {
 	}
 
 	// the resulting program must be valid
-	_, err = parser.ParseFile(fset, "", got, 0)
+	_, err = parser.ParseFile(fset, "", got, parser.SkipObjectResolution)
 	if err != nil {
 		t.Errorf("%v\norig: %q\ngot : %q", err, src, got)
 	}
@@ -800,7 +800,7 @@ func TestParenthesizedDecl(t *testing.T) {
 	// a package with multiple specs in a single declaration
 	const src = "package p; var ( a float64; b int )"
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", src, 0)
+	f, err := parser.ParseFile(fset, "", src, parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -840,7 +840,7 @@ func f() {
         }
 }`
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "", src, 0)
+	file, err := parser.ParseFile(fset, "", src, parser.SkipObjectResolution)
 	if err != nil {
 		panic(err)
 	}

src/go/token/example_test.go

@@ -35,7 +35,7 @@ func ok(pos p) bool {
 }
 `
 
-	f, err := parser.ParseFile(fset, "main.go", src, 0)
+	f, err := parser.ParseFile(fset, "main.go", src, parser.SkipObjectResolution)
 	if err != nil {
 		fmt.Println(err)
 		return

src/go/types/alias_test.go

@@ -59,7 +59,7 @@ func TestPartialTypeCheckUndeclaredAliasPanic(t *testing.T) {
 type A = B // undeclared`
 
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "p.go", src, parser.ParseComments)
+	file, err := parser.ParseFile(fset, "p.go", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatalf("could not parse: %v", err)
 	}

src/go/types/api_test.go

@@ -31,7 +31,7 @@ func defaultImporter(fset *token.FileSet) Importer {
 }
 
 func mustParse(fset *token.FileSet, src string) *ast.File {
-	f, err := parser.ParseFile(fset, pkgName(src), src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, pkgName(src), src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		panic(err) // so we don't need to pass *testing.T
 	}
@@ -3055,7 +3055,7 @@ type C = int
 // to compute which file it is "in" based on syntax position.
 func TestVersionIssue69477(t *testing.T) {
 	fset := token.NewFileSet()
-	f, _ := parser.ParseFile(fset, "a.go", "package p; const k = 123", 0)
+	f, _ := parser.ParseFile(fset, "a.go", "package p; const k = 123", parser.SkipObjectResolution)
 
 	// Set an invalid Pos on the BasicLit.
 	ast.Inspect(f, func(n ast.Node) bool {
@@ -3085,10 +3085,10 @@ func TestVersionIssue69477(t *testing.T) {
 // The Checker now holds the effective version in a state variable.
 func TestVersionWithoutPos(t *testing.T) {
 	fset := token.NewFileSet()
-	f, _ := parser.ParseFile(fset, "a.go", "//go:build go1.22\n\npackage p; var _ int", 0)
+	f, _ := parser.ParseFile(fset, "a.go", "//go:build go1.22\n\npackage p; var _ int", parser.SkipObjectResolution)
 
 	// Splice in a decl from another file. Its pos will be wrong.
-	f2, _ := parser.ParseFile(fset, "a.go", "package q; func _(s func(func() bool)) { for range s {} }", 0)
+	f2, _ := parser.ParseFile(fset, "a.go", "package q; func _(s func(func() bool)) { for range s {} }", parser.SkipObjectResolution)
 	f.Decls[0] = f2.Decls[0]
 
 	// Type check. The checker will consult the effective
@@ -3122,7 +3122,7 @@ func (recv T) f(param int) (result int) {
 	}
 	return local2
 }
-`, 0)
+`, parser.SkipObjectResolution)
 
 	pkg := NewPackage("p", "p")
 	info := &Info{Defs: make(map[*ast.Ident]Object)}
@@ -3160,7 +3160,7 @@ type B []byte
 var _ = f[B]
 `
 	fset := token.NewFileSet()
-	f, _ := parser.ParseFile(fset, "p.go", src, 0)
+	f, _ := parser.ParseFile(fset, "p.go", src, parser.SkipObjectResolution)
 
 	pkg := NewPackage("p", "p")
 	info := &Info{Types: make(map[ast.Expr]TypeAndValue)}

src/go/types/check_test.go

@@ -139,7 +139,7 @@ func testFiles(t *testing.T, filenames []string, srcs [][]byte, manual bool, opt
 	}
 
 	// parse files
-	files, errlist := parseFiles(t, filenames, srcs, parser.AllErrors)
+	files, errlist := parseFiles(t, filenames, srcs, parser.AllErrors|parser.SkipObjectResolution)
 	pkgName := "<no package>"
 	if len(files) > 0 {
 		pkgName = files[0].Name.Name

src/go/types/eval_test.go

@@ -168,7 +168,7 @@ func TestEvalPos(t *testing.T) {
 	fset := token.NewFileSet()
 	var files []*ast.File
 	for i, src := range sources {
-		file, err := parser.ParseFile(fset, "p", src, parser.ParseComments)
+		file, err := parser.ParseFile(fset, "p", src, parser.ParseComments|parser.SkipObjectResolution)
 		if err != nil {
 			t.Fatalf("could not parse file %d: %s", i, err)
 		}
@@ -241,7 +241,7 @@ func f(a int, s string) S {
 }`
 
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "p", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "p", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/go/types/example_test.go

@@ -117,7 +117,7 @@ type S struct { I; m int }
 type I interface { m() byte }
 `
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "celsius.go", input, 0)
+	f, err := parser.ParseFile(fset, "celsius.go", input, parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatal(err)
 	}

src/go/types/generate_test.go

@@ -54,7 +54,7 @@ func TestGenerate(t *testing.T) {
 func generate(t *testing.T, filename string, write bool) {
 	// parse src (cmd/compile/internal/types2)
 	srcFilename := filepath.FromSlash(runtime.GOROOT() + srcDir + filename)
-	file, err := parser.ParseFile(fset, srcFilename, nil, parser.ParseComments)
+	file, err := parser.ParseFile(fset, srcFilename, nil, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/go/types/gotype.go

@@ -120,6 +120,7 @@ var (
 )
 
 func initParserMode() {
+	parserMode = parser.SkipObjectResolution
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}

src/go/types/hash_test.go

@@ -95,7 +95,7 @@ type Tagged2 struct { F int "tag2" }
 `
 
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "p.go", src, 0)
+	file, err := parser.ParseFile(fset, "p.go", src, parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/go/types/issues_test.go

@@ -950,7 +950,7 @@ func _() {
 }
 `
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, pkgName(src), src, 0)
+	f, err := parser.ParseFile(fset, pkgName(src), src, parser.SkipObjectResolution)
 	if err == nil {
 		t.Fatal("expected syntax error")
 	}

src/go/types/methodset_test.go

@@ -144,7 +144,7 @@ type Instance = *Tree[int]
 `
 
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "foo.go", src, 0)
+	f, err := parser.ParseFile(fset, "foo.go", src, parser.SkipObjectResolution)
 	if err != nil {
 		panic(err)
 	}
@@ -165,7 +165,7 @@ func (T) m() {} // expected error: invalid receiver type
 `
 
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "p.go", src, 0)
+	f, err := parser.ParseFile(fset, "p.go", src, parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/go/types/self_test.go

@@ -110,7 +110,7 @@ func pkgFiles(fset *token.FileSet, path string) ([]*ast.File, error) {
 
 	var files []*ast.File
 	for _, filename := range filenames {
-		file, err := parser.ParseFile(fset, filename, nil, 0)
+		file, err := parser.ParseFile(fset, filename, nil, parser.SkipObjectResolution)
 		if err != nil {
 			return nil, err
 		}

src/go/types/stdlib_test.go

@@ -263,7 +263,7 @@ func testTestDir(t *testing.T, path string, ignore ...string) {
 		}
 
 		// parse and type-check file
-		file, err := parser.ParseFile(fset, filename, nil, 0)
+		file, err := parser.ParseFile(fset, filename, nil, parser.SkipObjectResolution)
 		if err == nil {
 			conf := Config{
 				GoVersion: goVersion,
@@ -377,7 +377,7 @@ func typecheckFiles(path string, filenames []string, importer Importer) (*Packag
 	// Parse package files.
 	var files []*ast.File
 	for _, filename := range filenames {
-		file, err := parser.ParseFile(fset, filename, nil, parser.AllErrors)
+		file, err := parser.ParseFile(fset, filename, nil, parser.AllErrors|parser.SkipObjectResolution)
 		if err != nil {
 			return nil, err
 		}

src/go/types/typeset_test.go

@@ -48,7 +48,7 @@ func TestTypeSetString(t *testing.T) {
 		// parse
 		src := "package p; type T interface" + body
 		fset := token.NewFileSet()
-		file, err := parser.ParseFile(fset, "p.go", src, parser.AllErrors)
+		file, err := parser.ParseFile(fset, "p.go", src, parser.AllErrors|parser.SkipObjectResolution)
 		if file == nil {
 			t.Fatalf("%s: %v (invalid test case)", body, err)
 		}

src/internal/types/errors/codes_test.go

@@ -47,7 +47,7 @@ func TestErrorCodeExamples(t *testing.T) {
 func walkCodes(t *testing.T, f func(string, int, *ast.ValueSpec)) {
 	t.Helper()
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "codes.go", nil, parser.ParseComments)
+	file, err := parser.ParseFile(fset, "codes.go", nil, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -95,7 +95,7 @@ func checkExample(t *testing.T, example string) error {
 	if !strings.HasPrefix(example, "package") {
 		example = "package p\n\n" + example
 	}
-	file, err := parser.ParseFile(fset, "example.go", example, 0)
+	file, err := parser.ParseFile(fset, "example.go", example, parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/internal/types/errors/generrordocs.go

@@ -67,7 +67,7 @@ func main() {
 
 func walkCodes(f func(string, *ast.ValueSpec)) {
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "codes.go", nil, parser.ParseComments)
+	file, err := parser.ParseFile(fset, "codes.go", nil, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatalf("ParseFile failed: %s", err)
 	}

src/runtime/_mkmalloc/mkmalloc.go

@@ -298,7 +298,7 @@ func inline(config generatorConfig) []byte {
 
 	// Read the template file in.
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, config.file, nil, 0)
+	f, err := parser.ParseFile(fset, config.file, nil, parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatalf("parsing %s: %v", config.file, err)
 	}

src/runtime/metrics/description_test.go

@@ -94,7 +94,7 @@ func TestDocs(t *testing.T) {
 		t.Fatal(err)
 	}
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "doc.go", src, parser.ParseComments)
+	f, err := parser.ParseFile(fset, "doc.go", src, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}