rethinking for anons, about to try cache 5

Author: grantnelson-wf

compiler/declCache.go

@@ -43,8 +43,12 @@ func (dc *DeclCache) GetDecl(fullname string) *Decl {
 	if decl, ok := dc.decls[fullname]; ok {
 		dc.stats.usedCount++
 		declCacheGlobalStats.usedCount++
+
+		fmt.Printf(">>> GetDecl(%q): Found\n", fullname) // TODO(grantnelson-wf): REMOVE
 		return decl
 	}
+
+	fmt.Printf(">>> GetDecl(%q): Miss\n", fullname) // TODO(grantnelson-wf): REMOVE
 	return nil
 }
 
@@ -73,20 +77,23 @@ func (dc *DeclCache) PutDecl(decl *Decl) {
 		// since those don't invalidate dependent packages' caches.
 		dc.stats.skippedCount++
 		declCacheGlobalStats.skippedCount++
+		fmt.Printf(">>> PutDecl(%q): Generic\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
 		return
 	}
 
 	if !isUniqueDeclFullName(decl.FullName) {
 		// Only cache declarations with unique names.
 		dc.stats.skippedCount++
 		declCacheGlobalStats.skippedCount++
+		fmt.Printf(">>> PutDecl(%q): Not Unique\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
 		return
 	}
 
 	if existing, ok := dc.decls[decl.FullName]; ok {
 		if existing != decl {
 			panic(fmt.Errorf(`decl cache conflict: different decls with same name: %q`, decl.FullName))
 		}
+		fmt.Printf(">>> PutDecl(%q): Dup\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
 		return
 	}
 
@@ -97,6 +104,8 @@ func (dc *DeclCache) PutDecl(decl *Decl) {
 	dc.changed = true
 	dc.stats.addedCount++
 	declCacheGlobalStats.addedCount++
+
+	fmt.Printf(">>> PutDecl(%q): Added\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
 }
 
 func (dc *DeclCache) Read(decode func(any) error) error {

compiler/decls.go

@@ -313,15 +313,15 @@ func (fc *funcContext) newVarDecl(init *types.Initializer) *Decl {
 	return d
 }
 
-// funcDecls translates all package-level function and methods.
-//
-// `functions` must contain all package-level function and method declarations
-// found in the AST. The function returns Decls that define corresponding JS
-// functions at runtime. For special functions like init() and main() decls will
-// also contain code necessary to invoke them.
-func (fc *funcContext) funcDecls(functions []*ast.FuncDecl) ([]*Decl, error) {
-	var funcDecls []*Decl
-	var mainFunc *types.Func
+type funcGroup struct {
+	fun       *ast.FuncDecl
+	o         *types.Func
+	instances []typeparams.Instance
+}
+
+// groupFuncDecls groups all the package-level function and methods
+// into generic or non-generic groups.
+func (fc *funcContext) groupFuncDecls(functions []*ast.FuncDecl) (mainFunc *funcGroup, fns, expGenFns []*funcGroup) {
 	for _, fun := range functions {
 		o := fc.pkgCtx.Defs[fun.Name].(*types.Func)
 		instances := fc.knownInstances(o)
@@ -330,29 +330,50 @@ func (fc *funcContext) funcDecls(functions []*ast.FuncDecl) ([]*Decl, error) {
 			continue
 		}
 
-		if fun.Recv == nil {
-			// 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.
-			funcDecls = append(funcDecls, fc.newFuncVarDecl(fun, o, instances))
+		fg := &funcGroup{
+			fun:       fun,
+			o:         o,
+			instances: instances,
 		}
 
-		for _, inst := range instances {
-			funcDecls = append(funcDecls, fc.newFuncDecl(fun, inst))
+		generic := len(instances) > 1 || !instances[0].IsTrivial()
+		if generic && fun.Name.IsExported() {
+			// function is an exported generic function so it must be processed later
+			// since it may have instances with type arguments from packages depending
+			// on the current package.
+			expGenFns = append(expGenFns, fg)
+			continue
 		}
 
-		if o.Name() == "main" {
-			mainFunc = o // main() function candidate.
+		fns = append(fns, fg)
+
+		if fg.o.Name() == "main" {
+			mainFunc = fg // main() function candidate.
 		}
 	}
-	if fc.pkgCtx.isMain() {
-		if mainFunc == nil {
-			return nil, fmt.Errorf("missing main function")
+
+	return mainFunc, fns, expGenFns
+}
+
+// funcDecls translates all package-level function and methods.
+//
+// `functions` must contain all package-level function and method declarations
+// found in the AST. The function returns Decls that define corresponding JS
+// functions at runtime. For special functions like init() and main() decls will
+// also contain code necessary to invoke them.
+func (fc *funcContext) funcDecls(functions []*funcGroup) ([]*Decl, error) {
+	var funcDecls []*Decl
+	for _, fg := range functions {
+		if fg.fun.Recv == nil {
+			// 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.
+			funcDecls = append(funcDecls, fc.newFuncVarDecl(fg.fun, fg.o, fg.instances))
+		}
+
+		for _, inst := range fg.instances {
+			funcDecls = append(funcDecls, fc.newFuncDecl(fg.fun, inst))
 		}
-		// 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, fc.newCallMainFuncDecl(mainFunc))
 	}
 	return funcDecls, nil
 }
@@ -479,6 +500,36 @@ func (fc *funcContext) callMainFunc(main *types.Func) ast.Stmt {
 	return ifStmt
 }
 
+func (fc *funcContext) groupNamedTypeDecls(typeNames typesutil.TypeNames) (typs, expGenTyps typesutil.TypeNames) {
+	if !fc.isRoot() {
+		panic(bailout(fmt.Errorf("functionContext.groupNamedTypeDecls() must be only called on the package-level context")))
+	}
+
+	for _, o := range typeNames.Slice() {
+		if o.IsAlias() {
+			continue
+		}
+
+		instances := fc.knownInstances(o)
+		if len(instances) == 0 {
+			// No instances of the type, skip it.
+			continue
+		}
+
+		generic := len(instances) > 1 || !instances[0].IsTrivial()
+		if generic && o.Exported() {
+			// type is an exported generic type so it must be processed later
+			// since it may have instances with type arguments from packages depending
+			// on the current package.
+			expGenTyps.Add(o)
+			continue
+		}
+
+		typs.Add(o)
+	}
+	return typs, expGenTyps
+}
+
 // namedTypeDecls returns Decls that define all names Go types.
 //
 // `typeNames` must contain all named types defined in the package, including

compiler/package.go

@@ -177,19 +177,38 @@ func Compile(srcs *sources.Sources, declCache *DeclCache, tContext *types.Contex
 
 	importedPaths, importDecls := rootCtx.importDecls()
 
+	// Collect top-level objects and group them by if they are exported generics or not.
 	vars, functions, typeNames := rootCtx.topLevelObjects(srcs)
+	mainFunc, fns, expGenFns := rootCtx.groupFuncDecls(functions)
+	typs, expGenTyps := rootCtx.groupNamedTypeDecls(typeNames)
+
+	// TODO(grantnelson-wf): Check cache
+	//return fc.pkgCtx.declCache.GetDecl(fullname)
+
 	// More named types may be added to the list when function bodies are processed.
-	rootCtx.pkgCtx.typeNames = typeNames
+	rootCtx.pkgCtx.typeNames.AddAll(typs)
 
-	// Translate functions and variables.
+	// Translate variables.
 	varDecls := rootCtx.varDecls(vars)
-	funcDecls, err := rootCtx.funcDecls(functions)
+
+	// Translate concrete functions.
+	funcDecls, err := rootCtx.funcDecls(fns)
 	if err != nil {
 		return nil, err
 	}
 
-	// It is important that we translate types *after* we've processed all
-	// functions to make sure we've discovered all types declared inside function
+	if rootCtx.pkgCtx.isMain() {
+		if mainFunc == nil {
+			return nil, fmt.Errorf("missing main function")
+		}
+		// 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, rootCtx.newCallMainFuncDecl(mainFunc.o))
+	}
+
+	// It is important that we translate current types *after* we've processed all
+	// current functions to make sure we've discovered all types declared inside function
 	// bodies.
 	typeDecls, err := rootCtx.namedTypeDecls(rootCtx.pkgCtx.typeNames)
 	if err != nil {
@@ -201,6 +220,35 @@ func Compile(srcs *sources.Sources, declCache *DeclCache, tContext *types.Contex
 	// declarations.
 	typeDecls = append(typeDecls, rootCtx.anonTypeDecls(rootCtx.pkgCtx.anonTypes)...)
 
+	// TODO(grantnelson-wf): Save cache
+	//return fc.pkgCtx.declCache.PutDecl(d)
+
+	// Reset before processing exported generic types.
+	rootCtx.pkgCtx.typeNames.Clear()
+	rootCtx.pkgCtx.typeNames.AddAll(expGenTyps)
+	rootCtx.pkgCtx.anonTypes = nil
+
+	// Translate exported generic functions.
+	expGenfuncDecls, err := rootCtx.funcDecls(expGenFns)
+	if err != nil {
+		return nil, err
+	}
+	funcDecls = append(funcDecls, expGenfuncDecls...)
+
+	// It is important that we translate remaining types *after* we've processed all
+	// remaining functions to make sure we've discovered all types declared inside function
+	// bodies.
+	expGenTypeDecls, err := rootCtx.namedTypeDecls(rootCtx.pkgCtx.typeNames)
+	if err != nil {
+		return nil, err
+	}
+	typeDecls = append(typeDecls, expGenTypeDecls...)
+
+	// Finally, anonymous types are translated the last, to make sure we've
+	// discovered all of them referenced in functions, variable and type
+	// declarations.
+	typeDecls = append(typeDecls, rootCtx.anonTypeDecls(rootCtx.pkgCtx.anonTypes)...)
+
 	// Combine all decls in a single list in the order they must appear in the
 	// final program.
 	allDecls := append(append(append(importDecls, typeDecls...), varDecls...), funcDecls...)

compiler/typesutil/typenames.go

@@ -24,7 +24,19 @@ func (tn *TypeNames) Add(name *types.TypeName) {
 	tn.known[name] = struct{}{}
 }
 
+func (tn *TypeNames) AddAll(other TypeNames) {
+	for _, name := range other.Slice() {
+		tn.Add(name)
+	}
+}
+
 // Slice returns set elements in the order they were first added to the set.
 func (tn *TypeNames) Slice() []*types.TypeName {
 	return tn.order
 }
+
+// Clear will remove the types without clearing if the types have been seen
+// before so that types seem before will not be added but new types will be.
+func (tn *TypeNames) Clear() {
+	tn.order = nil
+}