Copying out per decl attempt to new branch

Author: grantnelson-wf

build/build.go

@@ -791,12 +791,7 @@ func NewSession(options *Options) (*Session, error) {
 
 	// If the cache is enabled, initialize the build cache.
 	// Disable caching by leaving buildCache set to nil.
-	//
-	// TODO(grantnelson-wf): Currently the build cache is slower than
-	// parsing and augmenting the files, so we disable it for now.
-	// Re-enable it once the cache performance is improved.
-	const disableDefaultCache = true
-	if !s.options.NoCache && !disableDefaultCache {
+	if !s.options.NoCache {
 		s.buildCache = &cache.BuildCache{
 			GOOS:          env.GOOS,
 			GOARCH:        env.GOARCH,
@@ -941,7 +936,7 @@ func (s *Session) BuildProject(pkg *PackageData) (*compiler.Archive, error) {
 	}
 
 	// Compile the project into Archives containing the generated JS.
-	return s.prepareAndCompilePackages(rootSrcs)
+	return s.PrepareAndCompilePackages(rootSrcs)
 }
 
 // GetSortedSources returns the sources sorted by import path.
@@ -1088,7 +1083,9 @@ func (s *Session) LoadPackages(pkg *PackageData) (*sources.Sources, error) {
 	// Try to load the package from the build cache.
 	var srcs *sources.Sources
 	if s.buildCache != nil {
-		cachedSrcs := &sources.Sources{}
+		cachedSrcs := &sources.Sources{
+			CacheData: compiler.NewDeclCache(true),
+		}
 		if s.buildCache.Load(cachedSrcs, pkg.ImportPath, pkg.SrcModTime) {
 			srcs = cachedSrcs
 		}
@@ -1116,11 +1113,7 @@ func (s *Session) LoadPackages(pkg *PackageData) (*sources.Sources, error) {
 			Files:      files,
 			FileSet:    fileSet,
 			JSFiles:    append(pkg.JSFiles, overlayJsFiles...),
-		}
-
-		// Store the built package in the cache for future use.
-		if s.buildCache != nil {
-			s.buildCache.Store(srcs, srcs.ImportPath, time.Now())
+			CacheData:  compiler.NewDeclCache(s.buildCache != nil),
 		}
 	}
 
@@ -1139,7 +1132,10 @@ func (s *Session) LoadPackages(pkg *PackageData) (*sources.Sources, error) {
 	return srcs, nil
 }
 
-func (s *Session) prepareAndCompilePackages(rootSrcs *sources.Sources) (*compiler.Archive, error) {
+// PrepareAndCompilePackages prepares and compiles all packages in the session.
+// Thia assumes that all packages including dependencies have already been loaded already.
+// This will return the compiled archive for the rootSrcs package.
+func (s *Session) PrepareAndCompilePackages(rootSrcs *sources.Sources) (*compiler.Archive, error) {
 	tContext := types.NewContext()
 	allSources := s.GetSortedSources()
 
@@ -1151,7 +1147,7 @@ func (s *Session) prepareAndCompilePackages(rootSrcs *sources.Sources) (*compile
 
 	// Compile all the sources into archives.
 	for _, srcs := range allSources {
-		if _, err := s.compilePackage(srcs, tContext); err != nil {
+		if _, err := s.CompilePackage(srcs, tContext); err != nil {
 			return nil, err
 		}
 	}
@@ -1164,7 +1160,9 @@ func (s *Session) prepareAndCompilePackages(rootSrcs *sources.Sources) (*compile
 	return rootArchive, nil
 }
 
-func (s *Session) compilePackage(srcs *sources.Sources, tContext *types.Context) (*compiler.Archive, error) {
+// CompilePackage compiles the given package sources into an archive.
+// This assumes that the sources have already been prepared.
+func (s *Session) CompilePackage(srcs *sources.Sources, tContext *types.Context) (*compiler.Archive, error) {
 	if archive, ok := s.UpToDateArchives[srcs.ImportPath]; ok {
 		return archive, nil
 	}
@@ -1178,6 +1176,12 @@ func (s *Session) compilePackage(srcs *sources.Sources, tContext *types.Context)
 		fmt.Println(srcs.ImportPath)
 	}
 
+	// Store the built package sources in the cache for future use.
+	// The sources should contain all cachable declarations at this point.
+	if s.buildCache != nil {
+		s.buildCache.Store(srcs, srcs.ImportPath, time.Now())
+	}
+
 	s.UpToDateArchives[srcs.ImportPath] = archive
 
 	return archive, nil

compiler/declCache.go

@@ -0,0 +1,31 @@
+package compiler
+
+type DeclCache struct {
+	enabled bool
+	// TODO: Implement decl cache.
+}
+
+func NewDeclCache(enable bool) *DeclCache {
+	return &DeclCache{
+		enabled: enable,
+	}
+}
+
+// TODO: May need a more unique key since some decls may not have unique names.
+func (dc *DeclCache) GetDecl(fullname string) *Decl {
+	return nil
+}
+
+func (dc *DeclCache) PutDecl(decl *Decl) {
+
+}
+
+func (dc *DeclCache) Read(decode func(any) error) error {
+	// TODO: Implement decl cache serialization.
+	return nil
+}
+
+func (dc *DeclCache) Write(encode func(any) error) error {
+	// TODO: Implement decl cache serialization.
+	return nil
+}

compiler/decls.go

@@ -79,6 +79,8 @@ type Decl struct {
 	// that it can be resumed after a blocking operation completes without
 	// blocking the main thread in the meantime.
 	Blocking bool
+	// ForGeneric inidicates this decl is for a generic function or type.
+	ForGeneric bool
 }
 
 // minify returns a copy of Decl with unnecessary whitespace removed from the
@@ -101,6 +103,14 @@ func (d *Decl) Dce() *dce.Info {
 	return &d.DCEInfo
 }
 
+func (fc *funcContext) getCachedDecl(fullname string) *Decl {
+	return fc.pkgCtx.declCache.GetDecl(fullname)
+}
+
+func (fc *funcContext) putCachedDecl(d *Decl) {
+	fc.pkgCtx.declCache.PutDecl(d)
+}
+
 // topLevelObjects extracts package-level variables, functions and named types
 // from the package AST.
 func (fc *funcContext) topLevelObjects(srcs *sources.Sources) (vars []*types.Var, functions []*ast.FuncDecl, typeNames typesutil.TypeNames) {
@@ -183,14 +193,20 @@ func (fc *funcContext) importDecls() (importedPaths []string, importDecls []*Dec
 
 // newImportDecl registers the imported package and returns a Decl instance for it.
 func (fc *funcContext) newImportDecl(importedPkg *types.Package) *Decl {
+	fullName := importDeclFullName(importedPkg)
+	if d := fc.getCachedDecl(fullName); d != nil {
+		return d
+	}
+
 	pkgVar := fc.importedPkgVar(importedPkg)
 	d := &Decl{
-		FullName:   importDeclFullName(importedPkg),
+		FullName:   fullName,
 		Vars:       []string{pkgVar},
 		ImportCode: []byte(fmt.Sprintf("\t%s = $packages[\"%s\"];\n", pkgVar, importedPkg.Path())),
 		InitCode:   fc.CatchOutput(1, func() { fc.translateStmt(fc.importInitializer(importedPkg.Path()), nil) }),
 	}
 	d.Dce().SetAsAlive()
+	fc.putCachedDecl(d)
 	return d
 }
 
@@ -250,10 +266,12 @@ 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 {
-	d := &Decl{
-		FullName: varDeclFullName(init),
+	fullName := varDeclFullName(init)
+	if d := fc.getCachedDecl(fullName); d != nil {
+		return d
 	}
 
+	d := &Decl{FullName: fullName}
 	assignLHS := []ast.Expr{}
 	for _, o := range init.Lhs {
 		assignLHS = append(assignLHS, fc.newIdentFor(o))
@@ -289,6 +307,7 @@ func (fc *funcContext) newVarDecl(init *types.Initializer) *Decl {
 	if len(init.Lhs) != 1 || analysis.HasSideEffect(init.Rhs, fc.pkgCtx.Info.Info) {
 		d.Dce().SetAsAlive()
 	}
+	fc.putCachedDecl(d)
 	return d
 }
 
@@ -313,31 +332,15 @@ func (fc *funcContext) funcDecls(functions []*ast.FuncDecl) ([]*Decl, error) {
 			// Auxiliary decl shared by all instances of the function that defines
 			// package-level variable by which they all are referenced,
 			// e.g. init functions and instances of generic functions.
-			objName := fc.objectName(o)
-			generic := len(instances) > 1 || !instances[0].IsTrivial()
-			varName := objName
-			if generic {
-				varName += ` = []`
-			}
-			varDecl := &Decl{
-				FullName: funcVarDeclFullName(o),
-				Vars:     []string{varName},
-			}
-			varDecl.Dce().SetName(o, nil, nil)
-			if generic && o.Exported() {
-				varDecl.ExportFuncCode = fc.CatchOutput(1, func() {
-					fc.Printf("$pkg.%s = %s;", encodeIdent(fun.Name.Name), objName)
-				})
-			}
-			funcDecls = append(funcDecls, varDecl)
+			funcDecls = append(funcDecls, fc.newFuncVarDecl(fun, o, instances))
 		}
 
 		for _, inst := range instances {
 			funcDecls = append(funcDecls, fc.newFuncDecl(fun, inst))
+		}
 
-			if o.Name() == "main" {
-				mainFunc = o // main() function candidate.
-			}
+		if o.Name() == "main" {
+			mainFunc = o // main() function candidate.
 		}
 	}
 	if fc.pkgCtx.isMain() {
@@ -347,21 +350,69 @@ func (fc *funcContext) funcDecls(functions []*ast.FuncDecl) ([]*Decl, error) {
 		// Add a special Decl for invoking main() function after the program has
 		// been initialized. It must come after all other functions, especially all
 		// init() functions, otherwise main() will be invoked too early.
-		funcDecls = append(funcDecls, &Decl{
-			FullName: mainFuncDeclFullName(),
-			InitCode: fc.CatchOutput(1, func() { fc.translateStmt(fc.callMainFunc(mainFunc), nil) }),
-		})
+		funcDecls = append(funcDecls, fc.newCallMainFuncDecl(mainFunc))
 	}
 	return funcDecls, nil
 }
 
+func (fc *funcContext) newFuncVarDecl(fun *ast.FuncDecl, o *types.Func, instances []typeparams.Instance) *Decl {
+	fullName := funcVarDeclFullName(o)
+	if varDecl := fc.getCachedDecl(fullName); varDecl != nil {
+		return varDecl
+	}
+
+	objName := fc.objectName(o)
+	generic := len(instances) > 1 || !instances[0].IsTrivial()
+
+	varName := objName
+	if generic {
+		varName += ` = []`
+	}
+
+	varDecl := &Decl{
+		FullName:   fullName,
+		Vars:       []string{varName},
+		ForGeneric: generic,
+	}
+	varDecl.Dce().SetName(o, nil, nil)
+
+	if generic && o.Exported() {
+		varDecl.ExportFuncCode = fc.CatchOutput(1, func() {
+			fc.Printf("$pkg.%s = %s;", encodeIdent(fun.Name.Name), objName)
+		})
+	}
+
+	fc.putCachedDecl(varDecl)
+	return varDecl
+}
+
+func (fc *funcContext) newCallMainFuncDecl(mainFunc *types.Func) *Decl {
+	fullName := mainFuncDeclFullName()
+	if d := fc.getCachedDecl(fullName); d != nil {
+		return d
+	}
+
+	d := &Decl{
+		FullName: fullName,
+		InitCode: fc.CatchOutput(1, func() { fc.translateStmt(fc.callMainFunc(mainFunc), nil) }),
+	}
+	fc.putCachedDecl(d)
+	return d
+}
+
 // 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)
+	if d := fc.getCachedDecl(fullName); d != nil {
+		return d
+	}
+
 	o := fc.pkgCtx.Defs[fun.Name].(*types.Func)
 	d := &Decl{
-		FullName:    funcDeclFullName(inst),
+		FullName:    fullName,
 		Blocking:    fc.pkgCtx.IsBlocking(inst),
 		LinkingName: symbol.New(o),
+		ForGeneric:  !inst.IsTrivial(),
 	}
 	d.Dce().SetName(o, inst.TNest, inst.TArgs)
 
@@ -384,6 +435,8 @@ func (fc *funcContext) newFuncDecl(fun *ast.FuncDecl, inst typeparams.Instance)
 	fc.pkgCtx.CollectDCEDeps(d, func() {
 		d.FuncDeclCode = fc.namedFuncContext(inst).translateTopLevelFunction(fun)
 	})
+
+	fc.putCachedDecl(d)
 	return d
 }
 
@@ -460,28 +513,41 @@ func (fc *funcContext) namedTypeDecls(typeNames typesutil.TypeNames) ([]*Decl, e
 // of the type, keyed by the type argument combination. Otherwise it contains
 // the type definition directly.
 func (fc *funcContext) newNamedTypeVarDecl(obj *types.TypeName) *Decl {
+	fullName := typeVarDeclFullName(obj)
+	if varDecl := fc.getCachedDecl(fullName); varDecl != nil {
+		return varDecl
+	}
+
 	name := fc.objectName(obj)
 	generic := fc.pkgCtx.instanceSet.Pkg(obj.Pkg()).ObjHasInstances(obj)
 	varName := name
 	if generic {
 		varName += ` = []`
 	}
 	varDecl := &Decl{
-		FullName: typeVarDeclFullName(obj),
-		Vars:     []string{varName},
+		FullName:   fullName,
+		Vars:       []string{varName},
+		ForGeneric: generic,
 	}
 	varDecl.Dce().SetName(obj, nil, nil)
 	if isPkgLevel(obj) {
 		varDecl.ExportTypeCode = fc.CatchOutput(0, func() {
 			fc.Printf("$pkg.%s = %s;", encodeIdent(obj.Name()), name)
 		})
 	}
+
+	fc.putCachedDecl(varDecl)
 	return varDecl
 }
 
 // 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)
+	if d := fc.getCachedDecl(fullName); d != nil {
+		return d, nil
+	}
+
 	originType := inst.Object.Type().(*types.Named)
 
 	fc.typeResolver = typeparams.NewResolver(fc.pkgCtx.typesCtx, inst)
@@ -501,7 +567,8 @@ func (fc *funcContext) newNamedTypeInstDecl(inst typeparams.Instance) (*Decl, er
 
 	underlying := instanceType.Underlying()
 	d := &Decl{
-		FullName: typeDeclFullName(inst),
+		FullName:   fullName,
+		ForGeneric: !inst.IsTrivial(),
 	}
 	d.Dce().SetName(inst.Object, inst.TNest, inst.TArgs)
 	fc.pkgCtx.CollectDCEDeps(d, func() {
@@ -559,6 +626,8 @@ func (fc *funcContext) newNamedTypeInstDecl(inst typeparams.Instance) (*Decl, er
 			})
 		}
 	})
+
+	fc.putCachedDecl(d)
 	return d, nil
 }
 
@@ -625,14 +694,21 @@ func (fc *funcContext) anonTypeDecls(anonTypes []*types.TypeName) []*Decl {
 	}
 	decls := []*Decl{}
 	for _, t := range anonTypes {
+		fullName := anonTypeDeclFullName(t)
+		if d := fc.getCachedDecl(fullName); d != nil {
+			decls = append(decls, d)
+			continue
+		}
+
 		d := &Decl{
-			FullName: anonTypeDeclFullName(t),
+			FullName: fullName,
 			Vars:     []string{t.Name()},
 		}
 		d.Dce().SetName(t, nil, nil)
 		fc.pkgCtx.CollectDCEDeps(d, func() {
 			d.AnonTypeDeclCode = []byte(fmt.Sprintf("\t\t%s = $%sType(%s);\n", t.Name(), strings.ToLower(typeKind(t.Type())[5:]), fc.initArgs(t.Type())))
 		})
+		fc.putCachedDecl(d)
 		decls = append(decls, d)
 	}
 	return decls