removing unneeded changes from cache 4

Author: grantnelson-wf

compiler/declNames.go

@@ -1,24 +1,12 @@
 package compiler
 
 import (
-	"fmt"
-	"go/token"
 	"go/types"
-	"path/filepath"
-	"strings"
 
 	"github.com/gopherjs/gopherjs/compiler/internal/symbol"
 	"github.com/gopherjs/gopherjs/compiler/internal/typeparams"
 )
 
-const (
-	varDeclNotUniqueFullName      = `var:blank`
-	funcVarDeclNotUniqueFullName  = `funcVar:init`
-	mainFuncDeclNotUniqueFullName = `init:main`
-	funcDeclNotUniqueFullName     = `func:init`
-	typeDeclNestedPrefix          = `type:nested:`
-)
-
 // importDeclFullName returns a unique name for an import declaration.
 // This import name may be duplicated in different packages if they both
 // import the same package, they are only unique per package.
@@ -28,65 +16,36 @@ func importDeclFullName(importedPkg *types.Package) string {
 
 // varDeclFullName returns a name for a package-level variable declaration.
 // This var name only references the first named variable in an assignment.
-//
-// If no variables are named, this will attempt to create a unique name
-// using the integer value of the first valid position of the blank variables.
-// Otherwise the name is not unique (i.e. varDeclNotUniqueFullName).
-func varDeclFullName(init *types.Initializer, fSet *token.FileSet) string {
+// If no variables are named, the name is `var:blank` and not unique.
+func varDeclFullName(init *types.Initializer) string {
 	for _, lhs := range init.Lhs {
 		if lhs.Name() != `_` {
 			return `var:` + symbol.New(lhs).String()
 		}
 	}
-
-	for _, lhs := range init.Lhs {
-		if pos := lhs.Pos(); pos.IsValid() {
-			return `var:blank` + declFullNameDiscriminator(pos, fSet)
-		}
-	}
-
-	return varDeclNotUniqueFullName
+	return `var:blank`
 }
 
 // funcVarDeclFullName returns a name for a package-level variable
 // that is used for a function (without a receiver) declaration.
-// If the function is generic, this declaration name is for the list
-// of instantiations of the function.
-//
 // The name is unique unless the function is an `init` function.
-// If the name is for an `init` function, the position of the function
-// is used to create a unique name if it is valid,
-// otherwise the name is not unique (i.e. funcVarDeclNotUniqueFullName).
-func funcVarDeclFullName(o *types.Func, fSet *token.FileSet) string {
-	name := `funcVar:` + symbol.New(o).String()
-	if o.Name() == `init` {
-		name += declFullNameDiscriminator(o.Pos(), fSet)
-	}
-	// In the case of an `init` function with an invalid position,
-	// the name is not unique and will be equal to funcVarDeclNotUnqueName.
-	return name
+// If the function is generic, this declaration name is also for the list
+// of instantiations of the function.
+func funcVarDeclFullName(o *types.Func) string {
+	return `funcVar:` + symbol.New(o).String()
 }
 
 // mainFuncDeclFullName returns the name for the declaration used to invoke the
 // main function of the program. There should only be one decl with this name.
-// This will always return mainFuncDeclNotUniqueFullName.
 func mainFuncDeclFullName() string {
-	return mainFuncDeclNotUniqueFullName
+	return `init:main`
 }
 
 // funcDeclFullName returns a name for a package-level function
 // declaration for the given instance of a function.
-// The name is unique unless the function is an `init` function
-// then it tries to use the position of the function to create a unique name.
-// Otherwise the name is not unique (i.e. funcDeclNotUniqueFullName).
-func funcDeclFullName(inst typeparams.Instance, fSet *token.FileSet) string {
-	name := `func:` + inst.String()
-	if inst.IsTrivial() && inst.Object.Name() == `init` {
-		name += declFullNameDiscriminator(inst.Object.Pos(), fSet)
-	}
-	// In the case of an `init` function with an invalid position,
-	// the name is not unique and will be equal to funcDeclNotUniqueFullName.
-	return name
+// The name is unique unless the function is an `init` function.
+func funcDeclFullName(inst typeparams.Instance) string {
+	return `func:` + inst.String()
 }
 
 // typeVarDeclFullName returns a unique name for a package-level variable
@@ -98,17 +57,10 @@ func typeVarDeclFullName(o *types.TypeName) string {
 }
 
 // typeDeclFullName returns a unique name for a package-level type declaration
-// for the given instance of a type. Names are only unique per package
+// for the given instance of a type. Names are only unique per scope package
 // unless the type is a nested type then the name is only unique per the
-// function or method it is declared in. In that case, the position of the
-// declaration is used to try to create a unique name.
-// If the position is invalid, the nested name may be unique or not,
-// we cannot guarantee uniqueness in that case.
-func typeDeclFullName(inst typeparams.Instance, fSet *token.FileSet) string {
-	if typeparams.FindNestingFunc(inst.Object) != nil {
-		return typeDeclNestedPrefix + inst.String() +
-			declFullNameDiscriminator(inst.Object.Pos(), fSet)
-	}
+// function or method it is declared in.
+func typeDeclFullName(inst typeparams.Instance) string {
 	return `type:` + inst.String()
 }
 
@@ -118,31 +70,3 @@ func typeDeclFullName(inst typeparams.Instance, fSet *token.FileSet) string {
 func anonTypeDeclFullName(o types.Object) string {
 	return `anonType:` + symbol.New(o).String()
 }
-
-// declFullNameDiscriminator returns a string representing the position of a
-// declaration that is used to differentiate declarations with the same name.
-// Since the package path will already be part of the full name, only the file,
-// line, and column are used.
-// If position is invalid, an empty string is returned.
-func declFullNameDiscriminator(pos token.Pos, fSet *token.FileSet) string {
-	if !pos.IsValid() {
-		return ``
-	}
-	p := fSet.Position(pos)
-	fileName := filepath.Base(filepath.ToSlash(p.Filename))
-	return fmt.Sprintf("@%s:%d:%d", fileName, p.Line, p.Column)
-}
-
-// isUniqueDeclFullName reports whether the given declaration full name is unique.
-// A unique declaration name can be safely cached and reused.
-func isUniqueDeclFullName(name string) bool {
-	switch name {
-	case ``, varDeclNotUniqueFullName, funcVarDeclNotUniqueFullName,
-		mainFuncDeclNotUniqueFullName, funcDeclNotUniqueFullName:
-		return false // not unique since it equals one of the known non-unique names
-	}
-
-	// If the name is for a nested type declaration without a position discriminator,
-	// then it is not unique, otherwise it should be unique.
-	return !strings.HasPrefix(name, typeDeclNestedPrefix) || strings.Contains(name, `@`)
-}

compiler/decls.go

@@ -253,7 +253,7 @@ func (fc *funcContext) varDecls(vars []*types.Var) []*Decl {
 // newVarDecl creates a new Decl describing a variable, given an explicit
 // initializer.
 func (fc *funcContext) newVarDecl(init *types.Initializer) *Decl {
-	fullName := varDeclFullName(init, fc.pkgCtx.fileSet)
+	fullName := varDeclFullName(init)
 	d := &Decl{
 		FullName: fullName,
 	}
@@ -361,7 +361,7 @@ func (fc *funcContext) funcDecls(functions []*funcGroup) ([]*Decl, error) {
 }
 
 func (fc *funcContext) newFuncVarDecl(fun *ast.FuncDecl, o *types.Func, instances []typeparams.Instance) *Decl {
-	fullName := funcVarDeclFullName(o, fc.pkgCtx.fileSet)
+	fullName := funcVarDeclFullName(o)
 	objName := fc.objectName(o)
 	generic := len(instances) > 1 || !instances[0].IsTrivial()
 
@@ -396,7 +396,7 @@ func (fc *funcContext) newCallMainFuncDecl(mainFunc *types.Func) *Decl {
 
 // newFuncDecl returns a Decl that defines a package-level function or a method.
 func (fc *funcContext) newFuncDecl(fun *ast.FuncDecl, inst typeparams.Instance) *Decl {
-	fullName := funcDeclFullName(inst, fc.pkgCtx.fileSet)
+	fullName := funcDeclFullName(inst)
 	o := fc.pkgCtx.Defs[fun.Name].(*types.Func)
 	d := &Decl{
 		FullName:    fullName,
@@ -555,7 +555,7 @@ func (fc *funcContext) newNamedTypeVarDecl(obj *types.TypeName) *Decl {
 // newNamedTypeInstDecl returns a Decl that represents an instantiation of a
 // named Go type.
 func (fc *funcContext) newNamedTypeInstDecl(inst typeparams.Instance) (*Decl, error) {
-	fullName := typeDeclFullName(inst, fc.pkgCtx.fileSet)
+	fullName := typeDeclFullName(inst)
 	originType := inst.Object.Type().(*types.Named)
 
 	fc.typeResolver = typeparams.NewResolver(fc.pkgCtx.typesCtx, inst)

compiler/sources/serializer.go

@@ -70,10 +70,7 @@ func (s *Sources) Read(decode func(any) error) error {
 	for _, f := range s.Files {
 		unpackFile(f, s.FileSet)
 	}
-	if err := decode(&s.JSFiles); err != nil {
-		return err
-	}
-	return nil
+	return decode(&s.JSFiles)
 }
 
 // prepareFile is run when serializing a source to remove fields that can be