goscript 0.1.2 → 0.1.4

package/compiler/lowering.go

@@ -187,9 +187,6 @@ func (o *LoweringOwner) lowerFile(
 			})
 		}
 	}
-	for importSourcePath := range relevantImportFiles {
-		o.addGeneratedTypeImports(model, semPkg, importSourcePath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport)
-	}
 	implicitImportPaths := make([]string, 0, len(localRefs.implicitImports))
 	for pkgPath := range localRefs.implicitImports {
 		if pkgPath != "" && pkgPath != semPkg.pkgPath {
@@ -198,7 +195,19 @@ func (o *LoweringOwner) lowerFile(
 	}
 	slices.Sort(implicitImportPaths)
 	for _, pkgPath := range implicitImportPaths {
-		o.addGeneratedImportPath(model, pkgPath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport)
+		o.addGeneratedImportPath(
+			model,
+			pkgPath,
+			loweredFile,
+			importAliases,
+			importPaths,
+			reservedImportAliases,
+			seenImport,
+			!localRefs.implicitRuntime[pkgPath],
+		)
+	}
+	for importSourcePath := range relevantImportFiles {
+		o.addGeneratedTypeImports(model, semPkg, importSourcePath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport)
 	}
 	localImports := make([]loweredImport, 0, len(localRefs.aliases))
 	seenLocalImport := make(map[string]bool)
@@ -208,7 +217,13 @@ func (o *LoweringOwner) lowerFile(
 		}
 		seenLocalImport[alias] = true
 		source := localRefs.aliasSources[alias]
-		localImports = append(localImports, loweredImport{alias: alias, source: source, sideEffect: true})
+		typeOnly := !localRefs.runtimeAliases[alias]
+		localImports = append(localImports, loweredImport{
+			alias:      alias,
+			source:     source,
+			sideEffect: !typeOnly,
+			typeOnly:   typeOnly,
+		})
 	}
 	slices.SortFunc(localImports, func(a, b loweredImport) int {
 		return cmp.Compare(a.alias, b.alias)
@@ -308,7 +323,7 @@ func (o *LoweringOwner) addGeneratedTypeImports(
 	}
 	slices.Sort(pkgPaths)
 	for _, pkgPath := range pkgPaths {
-		o.addGeneratedImportPath(model, pkgPath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport)
+		o.addGeneratedImportPath(model, pkgPath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport, true)
 	}
 }
 
@@ -320,6 +335,7 @@ func (o *LoweringOwner) addGeneratedImportPath(
 	importPaths map[string]string,
 	reservedImportAliases map[string]bool,
 	seenImport map[string]bool,
+	typeOnly bool,
 ) {
 	if !o.hasGeneratedImportPackage(model, pkgPath) {
 		return
@@ -340,7 +356,8 @@ func (o *LoweringOwner) addGeneratedImportPath(
 	loweredFile.imports = append(loweredFile.imports, loweredImport{
 		alias:      alias,
 		source:     source,
-		sideEffect: true,
+		sideEffect: !typeOnly,
+		typeOnly:   typeOnly,
 	})
 }
 
@@ -429,7 +446,9 @@ type localFileReferenceAnalysis struct {
 	reservedNames   map[string]bool
 	aliases         map[types.Object]string
 	aliasSources    map[string]string
+	runtimeAliases  map[string]bool
 	implicitImports map[string]bool
+	implicitRuntime map[string]bool
 }
 
 func (o *LoweringOwner) analyzeLocalFileReferences(
@@ -444,35 +463,68 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 		reservedNames:   make(map[string]bool),
 		aliases:         make(map[types.Object]string),
 		aliasSources:    make(map[string]string),
+		runtimeAliases:  make(map[string]bool),
 		implicitImports: make(map[string]bool),
+		implicitRuntime: make(map[string]bool),
 	}
 	seenObjects := make(map[types.Object]bool)
 	seenTypes := make(map[types.Type]bool)
 	var addTypeDeps func(typ types.Type)
-	var addObject func(obj types.Object)
-	addObject = func(obj types.Object) {
-		if obj == nil || obj.Pkg() == nil || obj.Pkg().Path() != semPkg.pkgPath {
+	var addRuntimeTypeDeps func(typ types.Type)
+	var addRuntimeTypeOwnerDeps func(typ types.Type)
+	var addObject func(obj types.Object, runtime bool)
+	addObject = func(obj types.Object, runtime bool) {
+		if obj == nil || obj.Pkg() == nil {
 			return
 		}
-		if seenObjects[obj] {
+		if obj.Pkg().Path() != semPkg.pkgPath {
+			if runtime {
+				analysis.implicitImports[obj.Pkg().Path()] = true
+				analysis.implicitRuntime[obj.Pkg().Path()] = true
+			}
 			return
 		}
-		seenObjects[obj] = true
 		declFile := declFiles[obj]
+		if declFile == "" {
+			if fn, ok := obj.(*types.Func); ok {
+				if decl := functionDeclForObject(semPkg, fn); decl != nil {
+					declFile = sourcePos(semPkg.source, decl.Pos()).file
+				}
+			}
+		}
 		if declFile != "" && declFile != sourcePath {
 			outputName := outputNames[declFile]
 			if outputName != "" {
 				alias := "__goscript_" + safeIdentifier(strings.TrimSuffix(outputName, ".gs.ts"))
 				analysis.aliases[obj] = alias
 				analysis.aliasSources[alias] = "./" + outputName
+				if runtime {
+					analysis.runtimeAliases[alias] = true
+				}
 			}
 		}
+		if runtime {
+			if alias := analysis.aliases[obj]; alias != "" {
+				analysis.runtimeAliases[alias] = true
+			}
+		}
+		if seenObjects[obj] {
+			return
+		}
+		seenObjects[obj] = true
 		switch typed := obj.(type) {
 		case *types.TypeName:
 			addTypeDeps(typed.Type())
+			if named, ok := types.Unalias(typed.Type()).(*types.Named); ok {
+				if structType := structUnderlyingType(named); structType != nil {
+					for field := range structType.Fields() {
+						addRuntimeTypeDeps(field.Type())
+					}
+				}
+			}
 			if named, ok := types.Unalias(typed.Type()).(*types.Named); ok {
 				for method := range named.Methods() {
-					addObject(method)
+					addObject(method, false)
 				}
 			}
 		case *types.Var:
@@ -515,7 +567,7 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 				addTypeDeps(alias.Rhs())
 				return
 			}
-			addObject(alias.Obj())
+			addObject(alias.Obj(), false)
 			if args := alias.TypeArgs(); args != nil {
 				for t := range args.Types() {
 					addTypeDeps(t)
@@ -534,7 +586,7 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 				}
 				return
 			}
-			addObject(named.Obj())
+			addObject(named.Obj(), false)
 			if args := named.TypeArgs(); args != nil {
 				for t := range args.Types() {
 					addTypeDeps(t)
@@ -580,8 +632,93 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 			}
 		}
 	}
+	addRuntimeTypeDeps = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		if alias, ok := typ.(*types.Alias); ok {
+			addObject(alias.Obj(), true)
+			if args := alias.TypeArgs(); args != nil {
+				for t := range args.Types() {
+					addRuntimeTypeDeps(t)
+				}
+			}
+			addRuntimeTypeDeps(alias.Rhs())
+			return
+		}
+		if named, ok := types.Unalias(typ).(*types.Named); ok {
+			addObject(named.Obj(), true)
+			for method := range named.Methods() {
+				addObject(method, true)
+			}
+			methodSet := types.NewMethodSet(types.NewPointer(named))
+			for method := range methodSet.Methods() {
+				addObject(method.Obj(), true)
+			}
+			if args := named.TypeArgs(); args != nil {
+				for t := range args.Types() {
+					addRuntimeTypeDeps(t)
+				}
+			}
+			return
+		}
+		switch typed := types.Unalias(typ).Underlying().(type) {
+		case *types.Pointer:
+			addRuntimeTypeDeps(typed.Elem())
+		case *types.Slice:
+			addRuntimeTypeDeps(typed.Elem())
+		case *types.Array:
+			addRuntimeTypeDeps(typed.Elem())
+		case *types.Map:
+			addRuntimeTypeDeps(typed.Key())
+			addRuntimeTypeDeps(typed.Elem())
+		case *types.Chan:
+			addRuntimeTypeDeps(typed.Elem())
+		}
+	}
+	addRuntimeTypeOwnerDeps = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		if alias, ok := typ.(*types.Alias); ok {
+			addObject(alias.Obj(), true)
+			if args := alias.TypeArgs(); args != nil {
+				for t := range args.Types() {
+					addRuntimeTypeOwnerDeps(t)
+				}
+			}
+			addRuntimeTypeOwnerDeps(alias.Rhs())
+			return
+		}
+		if named, ok := types.Unalias(typ).(*types.Named); ok {
+			addObject(named.Obj(), true)
+			if args := named.TypeArgs(); args != nil {
+				for t := range args.Types() {
+					addRuntimeTypeOwnerDeps(t)
+				}
+			}
+			return
+		}
+		switch typed := types.Unalias(typ).Underlying().(type) {
+		case *types.Pointer:
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		case *types.Slice:
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		case *types.Array:
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		case *types.Map:
+			addRuntimeTypeOwnerDeps(typed.Key())
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		case *types.Chan:
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		}
+	}
 	inspect := func(node ast.Node) bool {
 		switch typed := node.(type) {
+		case *ast.ValueSpec:
+			if len(typed.Values) == 0 && typed.Type != nil {
+				addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(typed.Type))
+			}
 		case *ast.Ident:
 			if obj := semPkg.source.TypesInfo.Defs[typed]; obj != nil {
 				if _, ok := obj.(*types.PkgName); !ok {
@@ -591,18 +728,46 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 					}
 				}
 			}
-			addObject(semPkg.source.TypesInfo.Uses[typed])
+			if tv, ok := semPkg.source.TypesInfo.Types[typed]; ok && tv.IsValue() {
+				addObject(semPkg.source.TypesInfo.Uses[typed], true)
+			}
 			addTypeDeps(semPkg.source.TypesInfo.TypeOf(typed))
 		case *ast.SelectorExpr:
 			if selection := semPkg.source.TypesInfo.Selections[typed]; selection != nil {
-				addObject(selection.Obj())
+				switch selection.Kind() {
+				case types.FieldVal, types.MethodVal, types.MethodExpr:
+					addObject(selection.Obj(), true)
+					if selection.Kind() != types.FieldVal {
+						addRuntimeTypeOwnerDeps(selection.Recv())
+					}
+				default:
+					addObject(selection.Obj(), false)
+				}
 				addTypeDeps(selection.Obj().Type())
 			} else if obj := semPkg.source.TypesInfo.Uses[typed.Sel]; obj != nil {
+				if tv, ok := semPkg.source.TypesInfo.Types[typed]; ok && tv.IsValue() {
+					addObject(obj, true)
+				}
 				addTypeDeps(obj.Type())
 			}
 			if pointer, ok := types.Unalias(semPkg.source.TypesInfo.TypeOf(typed.X)).Underlying().(*types.Pointer); ok {
 				addTypeDeps(pointer.Elem())
 			}
+		case *ast.CompositeLit:
+			addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(typed))
+			addCompositeInterfaceValueDeps(semPkg.source.TypesInfo, typed, addRuntimeTypeDeps)
+		case *ast.CallExpr:
+			if ident, ok := ast.Unparen(typed.Fun).(*ast.Ident); ok && ident.Name == "new" {
+				for _, arg := range typed.Args {
+					addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(arg))
+				}
+			}
+			if ident, ok := ast.Unparen(typed.Fun).(*ast.Ident); ok && ident.Name == "make" && len(typed.Args) != 0 {
+				addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(typed.Args[0]))
+			}
+			addReflectTypeForRuntimeDeps(semPkg.source.TypesInfo, typed, addRuntimeTypeDeps)
+			addInterfaceArgumentRuntimeDeps(semPkg.source.TypesInfo, typed, addRuntimeTypeDeps)
+			addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(typed.Fun))
 		}
 		return true
 	}
@@ -613,6 +778,162 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 	return analysis
 }
 
+func addInterfaceArgumentRuntimeDeps(
+	info *types.Info,
+	call *ast.CallExpr,
+	addRuntimeTypeDeps func(types.Type),
+) {
+	if info == nil || call == nil {
+		return
+	}
+	signature, _ := types.Unalias(info.TypeOf(call.Fun)).(*types.Signature)
+	if signature == nil || signature.Params() == nil {
+		return
+	}
+	params := signature.Params()
+	for idx, arg := range call.Args {
+		paramIdx := idx
+		if signature.Variadic() && paramIdx >= params.Len()-1 {
+			paramIdx = params.Len() - 1
+		}
+		if paramIdx < 0 || paramIdx >= params.Len() {
+			continue
+		}
+		paramType := params.At(paramIdx).Type()
+		if signature.Variadic() && idx >= params.Len()-1 {
+			if slice, ok := types.Unalias(paramType).Underlying().(*types.Slice); ok {
+				paramType = slice.Elem()
+			}
+		}
+		if typeIsInterface(paramType) {
+			addRuntimeTypeDeps(info.TypeOf(arg))
+		}
+	}
+}
+
+func addReflectTypeForRuntimeDeps(
+	info *types.Info,
+	call *ast.CallExpr,
+	addRuntimeTypeDeps func(types.Type),
+) {
+	if info == nil || call == nil || !isReflectTypeForExpr(info, call.Fun) {
+		return
+	}
+	switch typed := ast.Unparen(call.Fun).(type) {
+	case *ast.IndexExpr:
+		addRuntimeTypeDeps(info.TypeOf(typed.Index))
+	case *ast.IndexListExpr:
+		for _, index := range typed.Indices {
+			addRuntimeTypeDeps(info.TypeOf(index))
+		}
+	}
+}
+
+func isReflectTypeForExpr(info *types.Info, expr ast.Expr) bool {
+	var base ast.Expr
+	switch typed := ast.Unparen(expr).(type) {
+	case *ast.IndexExpr:
+		base = typed.X
+	case *ast.IndexListExpr:
+		base = typed.X
+	default:
+		return false
+	}
+	selector, ok := ast.Unparen(base).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "TypeFor" {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := info.Uses[ident].(*types.PkgName)
+	return pkgName != nil && pkgName.Imported() != nil && pkgName.Imported().Path() == "reflect"
+}
+
+func addCompositeInterfaceValueDeps(
+	info *types.Info,
+	lit *ast.CompositeLit,
+	addRuntimeTypeDeps func(types.Type),
+) {
+	if info == nil || lit == nil {
+		return
+	}
+	typ := types.Unalias(info.TypeOf(lit))
+	if pointer, ok := typ.Underlying().(*types.Pointer); ok {
+		typ = types.Unalias(pointer.Elem())
+	}
+	switch typed := typ.Underlying().(type) {
+	case *types.Array:
+		addCompositeElementsRuntimeDeps(info, lit.Elts, typed.Elem(), addRuntimeTypeDeps)
+	case *types.Slice:
+		addCompositeElementsRuntimeDeps(info, lit.Elts, typed.Elem(), addRuntimeTypeDeps)
+	case *types.Map:
+		for _, elt := range lit.Elts {
+			keyValue, ok := elt.(*ast.KeyValueExpr)
+			if !ok {
+				continue
+			}
+			if typeIsInterface(typed.Key()) {
+				addRuntimeTypeDeps(info.TypeOf(keyValue.Key))
+			}
+			if typeIsInterface(typed.Elem()) {
+				addRuntimeTypeDeps(info.TypeOf(keyValue.Value))
+			}
+		}
+	case *types.Struct:
+		nextField := 0
+		for _, elt := range lit.Elts {
+			fieldIdx := nextField
+			value := elt
+			if keyValue, ok := elt.(*ast.KeyValueExpr); ok {
+				value = keyValue.Value
+				if ident, ok := keyValue.Key.(*ast.Ident); ok {
+					for idx := range typed.NumFields() {
+						if typed.Field(idx).Name() == ident.Name {
+							fieldIdx = idx
+							break
+						}
+					}
+				}
+			} else {
+				nextField++
+			}
+			if fieldIdx < 0 || fieldIdx >= typed.NumFields() {
+				continue
+			}
+			if typeIsInterface(typed.Field(fieldIdx).Type()) {
+				addRuntimeTypeDeps(info.TypeOf(value))
+			}
+		}
+	}
+}
+
+func addCompositeElementsRuntimeDeps(
+	info *types.Info,
+	elements []ast.Expr,
+	elemType types.Type,
+	addRuntimeTypeDeps func(types.Type),
+) {
+	if !typeIsInterface(elemType) {
+		return
+	}
+	for _, elt := range elements {
+		if keyValue, ok := elt.(*ast.KeyValueExpr); ok {
+			elt = keyValue.Value
+		}
+		addRuntimeTypeDeps(info.TypeOf(elt))
+	}
+}
+
+func typeIsInterface(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
+	_, ok := types.Unalias(typ).Underlying().(*types.Interface)
+	return ok
+}
+
 func safeIdentifier(value string) string {
 	var b strings.Builder
 	for idx, r := range value {
@@ -803,7 +1124,7 @@ func isConstGenDecl(decl ast.Decl) bool {
 }
 
 func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([]loweredDecl, []Diagnostic) {
-	var decls []loweredDecl
+	decls := make([]loweredDecl, 0, len(decl.Specs))
 	var diagnostics []Diagnostic
 	for _, spec := range decl.Specs {
 		switch typed := spec.(type) {
@@ -868,8 +1189,8 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				lazy := ctx.topLevel && ctx.lazyPackageVars[obj]
 				code := keyword + " " + declName + ": " + variableType + " = " + value
 				if lazy {
-					keyword = "let"
-					code = "let " + declName + ": " + variableType + " = undefined as unknown as " + variableType
+					keyword = "var"
+					code = "var " + declName + ": " + variableType
 				}
 				indexExport := ""
 				if ctx.topLevel && name.Name != "_" {
@@ -881,19 +1202,27 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				decls = append(decls, loweredDecl{code: code, indexExport: indexExport})
 				if lazy {
 					getterName := packageVarGetterName(name.Name)
+					initName := packageVarInitName(name.Name)
+					initIndexExport := ""
+					if ast.IsExported(name.Name) {
+						initIndexExport = initName
+					}
 					getterCode := "export function " + getterName + "(): " + variableType + " {\n\t"
 					if strings.Contains(value, "await ") {
-						initName := packageVarInitName(name.Name)
-						initCode := "async function " + initName + "(): globalThis.Promise<void> {\n\t" +
+						initCode := "export async function " + initName + "(): globalThis.Promise<void> {\n\t" +
 							"if (((" + declName + ") as any) === undefined) {\n\t\t" +
 							declName + " = " + value + "\n\t}\n}"
-						decls = append(decls, loweredDecl{code: initCode})
+						decls = append(decls, loweredDecl{code: initCode, indexExport: initIndexExport})
 						decls = append(decls, loweredDecl{packageInitCall: initName + "()"})
 						getterCode += "if (((" + declName + ") as any) === undefined) {\n\t\t" +
 							"throw new Error(" + strconv.Quote("goscript package variable "+name.Name+" read before initialization") + ")\n\t}\n"
 					} else {
+						initCode := "export function " + initName + "(): void {\n\t" +
+							"if (((" + declName + ") as any) === undefined) {\n\t\t" +
+							declName + " = " + value + "\n\t}\n}"
+						decls = append(decls, loweredDecl{code: initCode, indexExport: initIndexExport})
 						getterCode += "if (((" + declName + ") as any) === undefined) {\n\t\t" +
-							declName + " = " + value + "\n\t}\n"
+							initName + "()\n\t}\n"
 					}
 					getterCode += "\treturn " + declName + "\n}"
 					getterIndexExport := ""
@@ -907,10 +1236,15 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 					setterType := o.tsPackageVarSetterValueTypeFor(ctx, obj.Type())
 					setterTarget := declName
 					if ctx.model.needsVarRef[obj] {
-						setterTarget += ".value"
+						if lazy {
+							setterTarget = packageVarGetterName(name.Name) + "().value"
+						} else {
+							setterTarget += ".value"
+						}
 					}
-					setterCode := "export function " + setterName + "(value: " + setterType + "): void {\n\t" +
-						setterTarget + " = value\n}"
+					setterValue := "__goscriptValue"
+					setterCode := "export function " + setterName + "(" + setterValue + ": " + setterType + "): void {\n\t" +
+						setterTarget + " = " + setterValue + "\n}"
 					setterIndexExport := ""
 					if ast.IsExported(name.Name) {
 						setterIndexExport = setterName
@@ -964,6 +1298,9 @@ func initializerMayHaveRuntimeEffects(ctx lowerFileContext, expr ast.Expr) bool
 		}
 		switch typed := node.(type) {
 		case *ast.CallExpr:
+			if isEffectFreePackageInitializerCall(ctx, typed) {
+				return true
+			}
 			if callTargetSignature(ctx, typed.Fun) != nil {
 				hasEffects = true
 				return false
@@ -979,11 +1316,93 @@ func initializerMayHaveRuntimeEffects(ctx lowerFileContext, expr ast.Expr) bool
 	return hasEffects
 }
 
+func isEffectFreePackageInitializerCall(ctx lowerFileContext, call *ast.CallExpr) bool {
+	if call == nil {
+		return false
+	}
+	if isEffectFreePackageInitializerBuiltin(ctx, call.Fun) {
+		return true
+	}
+	if isReflectTypeOfCall(ctx, call) {
+		return true
+	}
+	if isReflectTypeForCall(ctx, call) {
+		return true
+	}
+	if isMathBigNewIntCall(ctx, call) {
+		return true
+	}
+	selector, ok := ast.Unparen(call.Fun).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "Elem" {
+		return false
+	}
+	receiver, ok := ast.Unparen(selector.X).(*ast.CallExpr)
+	return ok && isReflectTypeOfCall(ctx, receiver)
+}
+
+func isEffectFreePackageInitializerBuiltin(ctx lowerFileContext, expr ast.Expr) bool {
+	ident, ok := expr.(*ast.Ident)
+	if !ok {
+		return false
+	}
+	if ident.Name != "make" && ident.Name != "new" {
+		return false
+	}
+	_, ok = objectForIdent(ctx, ident).(*types.Builtin)
+	return ok
+}
+
+func isReflectTypeOfCall(ctx lowerFileContext, call *ast.CallExpr) bool {
+	selector, ok := ast.Unparen(call.Fun).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "TypeOf" {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName)
+	return pkgName != nil && pkgName.Imported() != nil && pkgName.Imported().Path() == "reflect"
+}
+
+func isReflectTypeForCall(ctx lowerFileContext, call *ast.CallExpr) bool {
+	fun := ast.Unparen(call.Fun)
+	switch typed := fun.(type) {
+	case *ast.IndexExpr:
+		fun = ast.Unparen(typed.X)
+	case *ast.IndexListExpr:
+		fun = ast.Unparen(typed.X)
+	}
+	selector, ok := fun.(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "TypeFor" {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName)
+	return pkgName != nil && pkgName.Imported() != nil && pkgName.Imported().Path() == "reflect"
+}
+
+func isMathBigNewIntCall(ctx lowerFileContext, call *ast.CallExpr) bool {
+	selector, ok := ast.Unparen(call.Fun).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "NewInt" {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName)
+	return pkgName != nil && pkgName.Imported() != nil && pkgName.Imported().Path() == "math/big"
+}
+
 func packageDeclFiles(semPkg *semanticPackage) map[types.Object]string {
 	if semPkg == nil || semPkg.source == nil {
 		return nil
 	}
-	declFiles := make(map[types.Object]string)
+	declFiles := make(map[types.Object]string, len(semPkg.declarations))
 	for _, decl := range semPkg.declarations {
 		if decl.object != nil && decl.position.file != "" {
 			declFiles[decl.object] = decl.position.file
@@ -1012,6 +1431,7 @@ func (o *LoweringOwner) lazyPackageVars(semPkg *semanticPackage, declFiles map[t
 	for idx, obj := range semPkg.initOrder {
 		varOrder[obj] = idx
 	}
+	funcRefs := packageVarsReferencedFromOtherFileTopLevelCalls(semPkg, declFiles)
 	lazy := make(map[types.Object]bool)
 	for idx, file := range semPkg.source.Syntax {
 		sourcePath := sourceFilePath(semPkg, idx, file)
@@ -1048,6 +1468,12 @@ func (o *LoweringOwner) lazyPackageVars(semPkg *semanticPackage, declFiles map[t
 					if valueIdx >= len(valueSpec.Values) &&
 						zeroValueReferencesOtherFileObject(semPkg, declFiles, sourcePath, obj.Type()) {
 						lazy[obj] = true
+						continue
+					}
+					if funcRefs[obj] &&
+						(valueIdx >= len(valueSpec.Values) ||
+							!initializerMayHaveRuntimeEffects(lowerFileContext{semPkg: semPkg}, valueSpec.Values[valueIdx])) {
+						lazy[obj] = true
 					}
 				}
 			}
@@ -1056,6 +1482,178 @@ func (o *LoweringOwner) lazyPackageVars(semPkg *semanticPackage, declFiles map[t
 	return lazy
 }
 
+func packageVarsReferencedFromOtherFileTopLevelCalls(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+) map[*types.Var]bool {
+	refs := make(map[*types.Var]bool)
+	if semPkg == nil || semPkg.source == nil || semPkg.source.TypesInfo == nil {
+		return refs
+	}
+	var collectFuncRefs func(rootSource string, fn *types.Func, seen map[*types.Func]bool)
+	collectFuncRefs = func(rootSource string, fn *types.Func, seen map[*types.Func]bool) {
+		if fn == nil || seen[fn] {
+			return
+		}
+		seen[fn] = true
+		decl := functionDeclForObject(semPkg, fn)
+		if decl == nil || decl.Body == nil {
+			return
+		}
+		ast.Inspect(decl.Body, func(node ast.Node) bool {
+			switch typed := node.(type) {
+			case *ast.Ident:
+				obj, _ := semPkg.source.TypesInfo.Uses[typed].(*types.Var)
+				if obj == nil || obj.Pkg() == nil || obj.Pkg().Path() != semPkg.pkgPath {
+					return true
+				}
+				if declFiles[obj] != "" && declFiles[obj] != rootSource {
+					refs[obj] = true
+				}
+			case *ast.CallExpr:
+				called := calledFunction(semPkg.source, typed.Fun)
+				if called != nil && called.Pkg() != nil && called.Pkg().Path() == semPkg.pkgPath {
+					collectFuncRefs(rootSource, called, seen)
+				}
+			}
+			return true
+		})
+	}
+	for _, file := range semPkg.source.Syntax {
+		sourcePath := sourcePos(semPkg.source, file.Pos()).file
+		for _, decl := range file.Decls {
+			switch typed := decl.(type) {
+			case *ast.GenDecl:
+				if typed.Tok != token.VAR {
+					continue
+				}
+				for _, spec := range typed.Specs {
+					valueSpec, ok := spec.(*ast.ValueSpec)
+					if !ok {
+						continue
+					}
+					for _, value := range valueSpec.Values {
+						collectTopLevelRefs(semPkg, declFiles, refs, sourcePath, value, collectFuncRefs)
+					}
+				}
+			case *ast.FuncDecl:
+				if typed.Name.Name == "init" && typed.Body != nil {
+					collectTopLevelRefs(semPkg, declFiles, refs, sourcePath, typed.Body, collectFuncRefs)
+				}
+			}
+		}
+	}
+	return refs
+}
+
+func collectTopLevelRefs(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	refs map[*types.Var]bool,
+	sourcePath string,
+	node ast.Node,
+	collectFuncRefs func(string, *types.Func, map[*types.Func]bool),
+) {
+	ast.Inspect(node, func(node ast.Node) bool {
+		switch typed := node.(type) {
+		case *ast.Ident:
+			obj, _ := semPkg.source.TypesInfo.Uses[typed].(*types.Var)
+			if obj == nil || obj.Pkg() == nil || obj.Pkg().Path() != semPkg.pkgPath {
+				return true
+			}
+			if declFiles[obj] != "" && declFiles[obj] != sourcePath {
+				refs[obj] = true
+			}
+		case *ast.CallExpr:
+			called := calledFunction(semPkg.source, typed.Fun)
+			if called == nil || called.Pkg() == nil || called.Pkg().Path() != semPkg.pkgPath {
+				return true
+			}
+			collectFuncRefs(sourcePath, called, make(map[*types.Func]bool))
+		}
+		return true
+	})
+}
+
+func (o *LoweringOwner) packageVarIsLazy(ctx lowerFileContext, obj *types.Var) bool {
+	if obj == nil {
+		return false
+	}
+	if ctx.lazyPackageVars[obj] {
+		return true
+	}
+	if ctx.model == nil || obj.Pkg() == nil {
+		return false
+	}
+	semPkg := ctx.model.packages[obj.Pkg().Path()]
+	if semPkg == nil {
+		return false
+	}
+	for lazyObj := range o.lazyPackageVars(semPkg, packageDeclFiles(semPkg)) {
+		if lazyObj != nil && lazyObj.Name() == obj.Name() &&
+			lazyObj.Pkg() != nil && lazyObj.Pkg().Path() == obj.Pkg().Path() {
+			return true
+		}
+	}
+	return false
+}
+
+func (o *LoweringOwner) packageVarNameIsLazy(ctx lowerFileContext, pkgPath, name string) bool {
+	if ctx.model == nil || pkgPath == "" || name == "" {
+		return false
+	}
+	semPkg := ctx.model.packages[pkgPath]
+	if semPkg == nil {
+		return false
+	}
+	for lazyObj := range o.lazyPackageVars(semPkg, packageDeclFiles(semPkg)) {
+		if lazyObj != nil && lazyObj.Name() == name {
+			return true
+		}
+	}
+	return false
+}
+
+func (o *LoweringOwner) packageVarHasAsyncLazyInit(ctx lowerFileContext, obj types.Object) bool {
+	varObj, _ := obj.(*types.Var)
+	if varObj == nil || varObj.Pkg() == nil {
+		return false
+	}
+	return o.packageVarNameHasAsyncLazyInit(ctx, varObj.Pkg().Path(), varObj.Name())
+}
+
+func (o *LoweringOwner) packageVarNameHasAsyncLazyInit(ctx lowerFileContext, pkgPath, name string) bool {
+	if ctx.model == nil || pkgPath == "" || name == "" {
+		return false
+	}
+	semPkg := ctx.model.packages[pkgPath]
+	if semPkg == nil || semPkg.source == nil {
+		return false
+	}
+	initCtx := lowerFileContext{model: ctx.model, semPkg: semPkg, topLevel: true}
+	for _, file := range semPkg.source.Syntax {
+		for _, decl := range file.Decls {
+			genDecl, ok := decl.(*ast.GenDecl)
+			if !ok || genDecl.Tok != token.VAR {
+				continue
+			}
+			for _, spec := range genDecl.Specs {
+				valueSpec, ok := spec.(*ast.ValueSpec)
+				if !ok {
+					continue
+				}
+				for idx, ident := range valueSpec.Names {
+					if ident.Name != name || idx >= len(valueSpec.Values) {
+						continue
+					}
+					return o.topLevelInitializerNeedsAwait(initCtx, valueSpec.Values[idx])
+				}
+			}
+		}
+	}
+	return false
+}
+
 func initializerReferencesLaterPackageVar(
 	semPkg *semanticPackage,
 	varOrder map[types.Object]int,
@@ -1278,7 +1876,7 @@ func (o *LoweringOwner) lowerTupleValueSpec(
 	tupleExpr := tempName
 	if lazyTuple {
 		tupleGetterName := packageVarGetterName(tempName)
-		decls = append(decls, loweredDecl{code: "let " + tempName + ": any = undefined as any"})
+		decls = append(decls, loweredDecl{code: "var " + tempName + ": any = undefined as any"})
 		decls = append(decls, loweredDecl{code: "function " + tupleGetterName + "(): any {\n\t" +
 			"if (((" + tempName + ") as any) === undefined) {\n\t\t" +
 			tempName + " = " + right + "\n\t}\n\treturn " + tempName + "\n}"})
@@ -1303,8 +1901,8 @@ func (o *LoweringOwner) lowerTupleValueSpec(
 		code := keyword + " " + o.lowerIdent(ctx, name, true) + ": " + variableType + " = " + value
 		lazy := lazyTuple || ctx.topLevel && ctx.lazyPackageVars[obj]
 		if lazy {
-			keyword = "let"
-			code = "let " + o.lowerIdent(ctx, name, true) + ": " + variableType + " = undefined as unknown as " + variableType
+			keyword = "var"
+			code = "var " + o.lowerIdent(ctx, name, true) + ": " + variableType + " = undefined as unknown as " + variableType
 		}
 		indexExport := ""
 		if ctx.topLevel {
@@ -1364,6 +1962,13 @@ func lowerLargeIntegerConstantValue(value constant.Value) (string, bool) {
 	return value.ExactString(), true
 }
 
+func lowerWideIntegerConstantValue(value constant.Value) (string, bool) {
+	if value == nil || value.Kind() != constant.Int || constant.BitLen(value) <= 53 {
+		return "", false
+	}
+	return value.ExactString(), true
+}
+
 func lowerConstantStringByteSlice(ctx lowerFileContext, expr ast.Expr) (string, bool) {
 	value := ctx.semPkg.source.TypesInfo.Types[unwrapParenExpr(expr)].Value
 	if value == nil || value.Kind() != constant.String {
@@ -1397,46 +2002,229 @@ func goEmbedPatterns(groups ...*ast.CommentGroup) []string {
 			if !strings.HasPrefix(text, "go:embed") {
 				continue
 			}
-			patterns = append(patterns, strings.Fields(strings.TrimSpace(strings.TrimPrefix(text, "go:embed")))...)
+			patterns = append(patterns, strings.Fields(strings.TrimSpace(strings.TrimPrefix(text, "go:embed")))...)
+		}
+	}
+	return patterns
+}
+
+func (o *LoweringOwner) lowerGoEmbedValue(
+	ctx lowerFileContext,
+	typ types.Type,
+	patterns []string,
+) (string, []Diagnostic) {
+	if isEmbedFSType(typ) {
+		return o.lowerGoEmbedFSValue(ctx, patterns)
+	}
+	if len(patterns) != 1 {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern list")}
+	}
+	cleanPattern, diagnostics := cleanGoEmbedFilePattern(ctx, patterns[0])
+	if len(diagnostics) != 0 {
+		return "", diagnostics
+	}
+	data, diagnostics := readGoEmbedFile(ctx, cleanPattern)
+	if len(diagnostics) != 0 {
+		return "", diagnostics
+	}
+	if isStringType(typ) {
+		return strconv.Quote(string(data)), nil
+	}
+	if slice, ok := types.Unalias(typ).Underlying().(*types.Slice); ok && isByteType(slice.Elem()) {
+		return byteSliceLiteral(data), nil
+	}
+	diag := loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed target type")
+	diag.Detail = "target type: " + types.TypeString(typ, func(pkg *types.Package) string {
+		if pkg == nil {
+			return ""
+		}
+		return pkg.Path()
+	})
+	return "", []Diagnostic{diag}
+}
+
+func (o *LoweringOwner) lowerGoEmbedFSValue(ctx lowerFileContext, patterns []string) (string, []Diagnostic) {
+	embedAlias := ctx.importPaths["embed"]
+	if embedAlias == "" {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed FS import")}
+	}
+	if len(patterns) == 0 {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern list")}
+	}
+
+	filesByPath := make(map[string][]byte)
+	for _, pattern := range patterns {
+		files, diagnostics := expandGoEmbedPattern(ctx, pattern)
+		if len(diagnostics) != 0 {
+			return "", diagnostics
+		}
+		for _, file := range files {
+			filesByPath[file.path] = file.data
+		}
+	}
+	paths := make([]string, 0, len(filesByPath))
+	for path := range filesByPath {
+		paths = append(paths, path)
+	}
+	slices.Sort(paths)
+	entries := make([]string, 0, len(paths))
+	for _, path := range paths {
+		entries = append(entries, "["+strconv.Quote(path)+", "+byteSliceLiteral(filesByPath[path])+"]")
+	}
+	builtinAlias := o.runtimeOwner.BuiltinImport().Alias
+	return builtinAlias + ".markAsStructValue(new " + embedAlias + ".FS(new Map<string, Uint8Array>([" + strings.Join(entries, ", ") + "])))", nil
+}
+
+type goEmbedFile struct {
+	path string
+	data []byte
+}
+
+func cleanGoEmbedFilePattern(ctx lowerFileContext, pattern string) (string, []Diagnostic) {
+	cleanPattern, _, diagnostics := cleanGoEmbedPattern(ctx, pattern)
+	if len(diagnostics) != 0 {
+		return "", diagnostics
+	}
+	if strings.Contains(cleanPattern, "*") {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+	}
+	info, err := os.Stat(filepath.Join(filepath.Dir(ctx.sourcePath), filepath.FromSlash(cleanPattern)))
+	if err != nil {
+		return "", []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
+	}
+	if info.IsDir() {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed directory target")}
+	}
+	return cleanPattern, nil
+}
+
+func cleanGoEmbedPattern(ctx lowerFileContext, pattern string) (string, bool, []Diagnostic) {
+	pattern = strings.Trim(pattern, "`\"")
+	all := false
+	if strings.HasPrefix(pattern, "all:") {
+		all = true
+		pattern = strings.TrimPrefix(pattern, "all:")
+	}
+	cleanPattern := path.Clean(pattern)
+	if pattern == "" ||
+		path.IsAbs(pattern) ||
+		cleanPattern == "." ||
+		cleanPattern == ".." ||
+		strings.HasPrefix(cleanPattern, "../") {
+		return "", false, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+	}
+	return cleanPattern, all, nil
+}
+
+func expandGoEmbedPattern(ctx lowerFileContext, pattern string) ([]goEmbedFile, []Diagnostic) {
+	cleanPattern, all, diagnostics := cleanGoEmbedPattern(ctx, pattern)
+	if len(diagnostics) != 0 {
+		return nil, diagnostics
+	}
+	pkgDir := filepath.Dir(ctx.sourcePath)
+	paths := []string{filepath.Join(pkgDir, filepath.FromSlash(cleanPattern))}
+	if strings.Contains(cleanPattern, "*") {
+		matches, err := filepath.Glob(filepath.Join(pkgDir, filepath.FromSlash(cleanPattern)))
+		if err != nil {
+			return nil, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+		}
+		if len(matches) == 0 {
+			return nil, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "go:embed pattern matched no files")}
+		}
+		paths = matches
+	}
+
+	var files []goEmbedFile
+	for _, path := range paths {
+		collected, diagnostics := collectGoEmbedPath(ctx, pkgDir, path, all)
+		if len(diagnostics) != 0 {
+			return nil, diagnostics
+		}
+		files = append(files, collected...)
+	}
+	slices.SortFunc(files, func(a, b goEmbedFile) int {
+		return cmp.Compare(a.path, b.path)
+	})
+	return files, nil
+}
+
+func collectGoEmbedPath(ctx lowerFileContext, pkgDir, absPath string, all bool) ([]goEmbedFile, []Diagnostic) {
+	info, err := os.Stat(absPath)
+	if err != nil {
+		return nil, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
+	}
+	if !info.IsDir() {
+		file, diagnostics := readGoEmbedAbsFile(ctx, pkgDir, absPath)
+		if len(diagnostics) != 0 {
+			return nil, diagnostics
+		}
+		return []goEmbedFile{file}, nil
+	}
+
+	var files []goEmbedFile
+	if err := filepath.WalkDir(absPath, func(path string, entry os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if path != absPath && !all && (strings.HasPrefix(entry.Name(), ".") || strings.HasPrefix(entry.Name(), "_")) {
+			if entry.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if entry.IsDir() {
+			return nil
+		}
+		file, diagnostics := readGoEmbedAbsFile(ctx, pkgDir, path)
+		if len(diagnostics) != 0 {
+			return fmt.Errorf("%s", diagnostics[0].Detail)
 		}
+		files = append(files, file)
+		return nil
+	}); err != nil {
+		return nil, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
 	}
-	return patterns
+	if len(files) == 0 {
+		return nil, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "go:embed directory matched no files")}
+	}
+	return files, nil
 }
 
-func (o *LoweringOwner) lowerGoEmbedValue(
-	ctx lowerFileContext,
-	typ types.Type,
-	patterns []string,
-) (string, []Diagnostic) {
-	if len(patterns) != 1 {
-		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern list")}
+func readGoEmbedFile(ctx lowerFileContext, cleanPattern string) ([]byte, []Diagnostic) {
+	file, diagnostics := readGoEmbedAbsFile(ctx, filepath.Dir(ctx.sourcePath), filepath.Join(filepath.Dir(ctx.sourcePath), filepath.FromSlash(cleanPattern)))
+	if len(diagnostics) != 0 {
+		return nil, diagnostics
 	}
-	pattern := strings.Trim(patterns[0], "`\"")
-	cleanPattern := path.Clean(pattern)
-	if pattern == "" ||
-		strings.Contains(pattern, "*") ||
-		path.IsAbs(pattern) ||
-		cleanPattern == "." ||
-		cleanPattern == ".." ||
-		strings.HasPrefix(cleanPattern, "../") {
-		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+	return file.data, nil
+}
+
+func readGoEmbedAbsFile(ctx lowerFileContext, pkgDir, absPath string) (goEmbedFile, []Diagnostic) {
+	relPath, err := filepath.Rel(pkgDir, absPath)
+	if err != nil {
+		return goEmbedFile{}, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
 	}
-	data, err := os.ReadFile(filepath.Join(filepath.Dir(ctx.sourcePath), filepath.FromSlash(cleanPattern)))
+	data, err := os.ReadFile(absPath)
 	if err != nil {
-		return "", []Diagnostic{{
-			Severity: DiagnosticSeverityError,
-			Code:     "goscript/lowering:embed",
-			Message:  "failed to read go:embed file",
-			Detail:   ctx.semPkg.pkgPath + ": " + err.Error(),
-		}}
+		return goEmbedFile{}, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
 	}
-	if isStringType(typ) {
-		return strconv.Quote(string(data)), nil
+	return goEmbedFile{path: filepath.ToSlash(relPath), data: data}, nil
+}
+
+func goEmbedReadDiagnostic(ctx lowerFileContext, err error) Diagnostic {
+	return Diagnostic{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/lowering:embed",
+		Message:  "failed to read go:embed file",
+		Detail:   ctx.semPkg.pkgPath + ": " + err.Error(),
 	}
-	if slice, ok := types.Unalias(typ).Underlying().(*types.Slice); ok && isByteType(slice.Elem()) {
-		return byteSliceLiteral(data), nil
+}
+
+func isEmbedFSType(typ types.Type) bool {
+	named, _ := types.Unalias(typ).(*types.Named)
+	if named == nil || named.Obj() == nil || named.Obj().Pkg() == nil {
+		return false
 	}
-	return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed target type")}
+	return named.Obj().Pkg().Path() == "embed" && named.Obj().Name() == "FS"
 }
 
 func byteSliceLiteral(data []byte) string {
@@ -1493,12 +2281,13 @@ func (o *LoweringOwner) lowerTypeSpec(ctx lowerFileContext, spec *ast.TypeSpec)
 	if signature, ok := named.Underlying().(*types.Signature); ok {
 		loweredType = o.tsAsyncCompatibleFunctionTypeFor(ctx, signature)
 	}
-	code := "type " + semType.name + " = " + loweredType
+	typeName := safeIdentifier(semType.name)
+	code := "type " + typeName + " = " + loweredType
 	typeIndexExport := ""
 	if ctx.topLevel {
 		code = "export " + code
 		if ast.IsExported(semType.name) {
-			typeIndexExport = semType.name
+			typeIndexExport = typeName
 		}
 	}
 	return loweredDecl{code: code, typeIndexExport: typeIndexExport}, nil
@@ -1506,12 +2295,13 @@ func (o *LoweringOwner) lowerTypeSpec(ctx lowerFileContext, spec *ast.TypeSpec)
 
 func (o *LoweringOwner) lowerInterfaceType(ctx lowerFileContext, semType *semanticType, iface *types.Interface) loweredDecl {
 	iface.Complete()
-	code := "type " + semType.name + " = " + o.tsInterfaceType(ctx, iface)
+	typeName := safeIdentifier(semType.name)
+	code := "type " + typeName + " = " + o.tsInterfaceType(ctx, iface)
 	typeIndexExport := ""
 	if ctx.topLevel {
 		code = "export " + code
 		if ast.IsExported(semType.name) {
-			typeIndexExport = semType.name
+			typeIndexExport = typeName
 		}
 	}
 	code = code + "\n\n" + o.runtimeOwner.QualifiedHelper(RuntimeHelperRegisterInterfaceType) +
@@ -1599,9 +2389,10 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 	lowered := &loweredStruct{
 		exported:      ctx.topLevel,
 		indexExported: ctx.topLevel && ast.IsExported(semType.name),
-		name:          semType.name,
+		name:          safeIdentifier(semType.name),
 		typeName:      runtimeNamedTypeName(semType.named),
 		cloneMethod:   "clone",
+		fields:        make([]loweredStructField, 0, len(semType.fields)),
 	}
 	for idx, field := range semType.fields {
 		structValue := isStructValueType(field.typ)
@@ -1628,9 +2419,12 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 
 	methodDecls := o.methodDeclsForType(ctx, semType.named)
 	explicitMethods := make(map[string]bool, len(methodDecls))
-	for _, methodDecl := range methodDecls {
-		if methodDecl != nil {
-			explicitMethods[methodDecl.Name.Name] = true
+	if len(methodDecls) != 0 {
+		lowered.methods = make([]loweredFunction, 0, len(methodDecls))
+		for _, methodDecl := range methodDecls {
+			if methodDecl != nil {
+				explicitMethods[methodDecl.Name.Name] = true
+			}
 		}
 	}
 	var diagnostics []Diagnostic
@@ -2434,105 +3228,113 @@ func (o *LoweringOwner) lowerStmtListAfter(
 ) ([]loweredStmt, []Diagnostic) {
 	lowered := make([]loweredStmt, 0, len(stmts))
 	var diagnostics []Diagnostic
-	gotoSpans := backwardGotoLabelSpans(stmts)
-	gotoLabels := make(map[string]bool, len(gotoSpans))
-	for label := range gotoSpans {
-		gotoLabels[label] = true
-	}
-	forwardSpans := forwardGotoLabelSpans(stmts, gotoSpans)
-	forwardStarts := make(map[int]forwardGotoLabelSpan, len(forwardSpans))
-	for label, span := range forwardSpans {
-		span.label = label
-		group := forwardStarts[span.start]
-		if group.forwardLabels == nil {
-			group.forwardLabels = make(map[string]bool)
-		}
-		group.forwardLabels[label] = true
-		if group.label == "" || span.labelIdx > group.labelIdx {
-			group.label = span.label
-			group.start = span.start
-			group.labelIdx = span.labelIdx
-		}
-		forwardStarts[span.start] = group
+	hasGoto := stmtListHasGoto(stmts)
+	var gotoSpans map[string]int
+	var gotoLabels map[string]bool
+	var forwardStarts map[int]forwardGotoLabelSpan
+	if hasGoto {
+		gotoSpans = backwardGotoLabelSpans(stmts)
+		gotoLabels = make(map[string]bool, len(gotoSpans))
+		for label := range gotoSpans {
+			gotoLabels[label] = true
+		}
+		forwardSpans := forwardGotoLabelSpans(stmts, gotoSpans)
+		forwardStarts = make(map[int]forwardGotoLabelSpan, len(forwardSpans))
+		for label, span := range forwardSpans {
+			span.label = label
+			group := forwardStarts[span.start]
+			if group.forwardLabels == nil {
+				group.forwardLabels = make(map[string]bool)
+			}
+			group.forwardLabels[label] = true
+			if group.label == "" || span.labelIdx > group.labelIdx {
+				group.label = span.label
+				group.start = span.start
+				group.labelIdx = span.labelIdx
+			}
+			forwardStarts[span.start] = group
+		}
 	}
 	for idx := 0; idx < len(stmts); idx++ {
 		stmt := stmts[idx]
 		startLine := sourceLine(ctx, stmt.Pos())
 		leading := leadingStmtLines(ctx, prevEndLine, startLine)
-		if cluster, ok := gotoStateClusterAt(stmts, idx); ok {
-			clusterLowered, clusterDiagnostics := o.lowerGotoStateCluster(ctx, stmts, cluster, leading)
-			diagnostics = append(diagnostics, clusterDiagnostics...)
-			lowered = append(lowered, clusterLowered...)
-			if endLine := sourceLine(ctx, stmts[cluster.endIdx].End()); endLine != 0 {
-				prevEndLine = endLine
-			}
-			idx = cluster.endIdx
-			continue
-		}
-		if span, ok := leadingGotoBackwardLoopSpan(stmts, idx, gotoSpans); ok {
-			loop, loopDiagnostics := o.lowerBackwardGotoLoop(
-				ctx,
-				gotoLabels,
-				span.label,
-				span.labelIdx,
-				span.endIdx,
-				span.forwardLabel,
-				stmts,
-				leading,
-			)
-			diagnostics = append(diagnostics, loopDiagnostics...)
-			lowered = append(lowered, loop...)
-			if endLine := sourceLine(ctx, stmts[span.endIdx].End()); endLine != 0 {
-				prevEndLine = endLine
-			}
-			idx = span.endIdx
-			continue
-		}
-		if span, ok := forwardStarts[idx]; ok {
-			bodyStmts := stmts[idx:span.labelIdx]
-			body, bodyDiagnostics := o.lowerStmtListAfter(
-				ctx.withForwardGotos(span.forwardLabels),
-				bodyStmts,
-				prevEndLine,
-			)
-			diagnostics = append(diagnostics, bodyDiagnostics...)
-			block := loweredStmt{hasBlock: true, text: span.label + ":", children: body}
-			if len(leading) != 0 {
-				block.leading = append(leading, block.leading...)
-			}
-			lowered = append(lowered, block)
-			if labeled, ok := stmts[span.labelIdx].(*ast.LabeledStmt); ok {
-				labelLowered, labelDiagnostics := o.lowerStmt(ctx, labeled.Stmt)
-				diagnostics = append(diagnostics, labelDiagnostics...)
-				lowered = append(lowered, labelLowered...)
-				if endLine := sourceLine(ctx, labeled.End()); endLine != 0 {
+		if hasGoto {
+			if cluster, ok := gotoStateClusterAt(stmts, idx); ok {
+				clusterLowered, clusterDiagnostics := o.lowerGotoStateCluster(ctx, stmts, cluster, leading)
+				diagnostics = append(diagnostics, clusterDiagnostics...)
+				lowered = append(lowered, clusterLowered...)
+				if endLine := sourceLine(ctx, stmts[cluster.endIdx].End()); endLine != 0 {
 					prevEndLine = endLine
 				}
+				idx = cluster.endIdx
+				continue
 			}
-			idx = span.labelIdx
-			continue
-		}
-		if labeled, ok := stmt.(*ast.LabeledStmt); ok {
-			label := safeIdentifier(labeled.Label.Name)
-			if endIdx, ok := gotoSpans[label]; ok {
+			if span, ok := leadingGotoBackwardLoopSpan(stmts, idx, gotoSpans); ok {
 				loop, loopDiagnostics := o.lowerBackwardGotoLoop(
 					ctx,
 					gotoLabels,
-					label,
-					idx,
-					endIdx,
-					"",
+					span.label,
+					span.labelIdx,
+					span.endIdx,
+					span.forwardLabel,
 					stmts,
 					leading,
 				)
 				diagnostics = append(diagnostics, loopDiagnostics...)
 				lowered = append(lowered, loop...)
-				if endLine := sourceLine(ctx, stmts[endIdx].End()); endLine != 0 {
+				if endLine := sourceLine(ctx, stmts[span.endIdx].End()); endLine != 0 {
 					prevEndLine = endLine
 				}
-				idx = endIdx
+				idx = span.endIdx
+				continue
+			}
+			if span, ok := forwardStarts[idx]; ok {
+				bodyStmts := stmts[idx:span.labelIdx]
+				body, bodyDiagnostics := o.lowerStmtListAfter(
+					ctx.withForwardGotos(span.forwardLabels),
+					bodyStmts,
+					prevEndLine,
+				)
+				diagnostics = append(diagnostics, bodyDiagnostics...)
+				block := loweredStmt{hasBlock: true, text: span.label + ":", children: body}
+				if len(leading) != 0 {
+					block.leading = append(leading, block.leading...)
+				}
+				lowered = append(lowered, block)
+				if labeled, ok := stmts[span.labelIdx].(*ast.LabeledStmt); ok {
+					labelLowered, labelDiagnostics := o.lowerStmt(ctx, labeled.Stmt)
+					diagnostics = append(diagnostics, labelDiagnostics...)
+					lowered = append(lowered, labelLowered...)
+					if endLine := sourceLine(ctx, labeled.End()); endLine != 0 {
+						prevEndLine = endLine
+					}
+				}
+				idx = span.labelIdx
 				continue
 			}
+			if labeled, ok := stmt.(*ast.LabeledStmt); ok {
+				label := safeIdentifier(labeled.Label.Name)
+				if endIdx, ok := gotoSpans[label]; ok {
+					loop, loopDiagnostics := o.lowerBackwardGotoLoop(
+						ctx,
+						gotoLabels,
+						label,
+						idx,
+						endIdx,
+						"",
+						stmts,
+						leading,
+					)
+					diagnostics = append(diagnostics, loopDiagnostics...)
+					lowered = append(lowered, loop...)
+					if endLine := sourceLine(ctx, stmts[endIdx].End()); endLine != 0 {
+						prevEndLine = endLine
+					}
+					idx = endIdx
+					continue
+				}
+			}
 		}
 		if stmtCtx, nextCtx, ok := o.lowerDeclStatementContext(ctx, stmt); ok {
 			stmtLowered, stmtDiagnostics := o.lowerStmt(stmtCtx, stmt)
@@ -2604,7 +3406,7 @@ func (o *LoweringOwner) lowerDeclStatementContext(
 			if def == nil || aliases[def] != "" {
 				continue
 			}
-			if shortDeclDefShadowsOuterName(name.Name, def) {
+			if shortDeclDefShadowsOuterName(ctx, name.Name, def) || valueSpecUsesOuterName(ctx, valueSpec, name.Name, def) {
 				aliases[def] = ctx.tempName("Shadow")
 			}
 		}
@@ -2852,9 +3654,30 @@ type leadingGotoBackwardLoop struct {
 }
 
 func stmtListNeedsLoopBranchLabel(stmts []ast.Stmt) bool {
+	if !stmtListHasGoto(stmts) {
+		return false
+	}
 	return len(backwardGotoLabelSpans(stmts)) != 0
 }
 
+func stmtListHasGoto(stmts []ast.Stmt) bool {
+	for _, stmt := range stmts {
+		hasGoto := false
+		ast.Inspect(stmt, func(node ast.Node) bool {
+			branch, ok := node.(*ast.BranchStmt)
+			if ok && branch.Tok == token.GOTO && branch.Label != nil {
+				hasGoto = true
+				return false
+			}
+			return !hasGoto
+		})
+		if hasGoto {
+			return true
+		}
+	}
+	return false
+}
+
 func backwardGotoLabelSpans(stmts []ast.Stmt) map[string]int {
 	seenLabels := make(map[string]bool)
 	spans := make(map[string]int)
@@ -3134,15 +3957,11 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 		if starTarget && stmt.Tok != token.DEFINE {
 			pointer, pointerDiagnostics := o.lowerPointerStorageExpr(ctx, star.X)
 			diagnostics = append(diagnostics, pointerDiagnostics...)
-			if stmt.Tok == token.AND_NOT_ASSIGN {
-				stmts = append(stmts, loweredStmt{text: pointer + " = " + pointer + " & ~(" + right + ")"})
-				continue
-			}
 			if value, ok := integerQuotientAssignExpr(targetType, pointer, right, stmt.Tok); ok {
 				stmts = append(stmts, loweredStmt{text: value})
 				continue
 			}
-			stmts = append(stmts, loweredStmt{text: pointer + " " + stmt.Tok.String() + " " + right})
+			stmts = append(stmts, loweredStmt{text: pointer + " = " + lowerCompoundAssignValue(o.runtimeOwner, targetType, pointer, right, stmt.Tok)})
 			continue
 		}
 		if isShortDecl {
@@ -3152,10 +3971,6 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 			stmts = append(stmts, loweredStmt{text: "let " + left + o.shortDeclTypeAnnotation(ctx, lhs, stmt.Rhs[idx]) + " = " + right})
 			continue
 		}
-		if stmt.Tok == token.AND_NOT_ASSIGN {
-			stmts = append(stmts, loweredStmt{text: left + " = " + left + " & ~(" + right + ")"})
-			continue
-		}
 		if helper, ok := wideIntegerAssignHelper(targetType, stmt.Tok); ok {
 			stmts = append(stmts, loweredStmt{text: left + " = " + o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")"})
 			continue
@@ -3168,6 +3983,10 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 		if stmt.Tok == token.DEFINE {
 			op = "="
 		}
+		if stmt.Tok != token.ASSIGN && stmt.Tok != token.DEFINE {
+			stmts = append(stmts, loweredStmt{text: left + " = " + lowerCompoundAssignValue(o.runtimeOwner, targetType, left, right, stmt.Tok)})
+			continue
+		}
 		stmts = append(stmts, loweredStmt{text: left + " " + op + " " + right})
 	}
 	return stmts, diagnostics
@@ -3210,6 +4029,7 @@ func lowerCompoundAssignValue(
 	if value, ok := integerQuotientAssignValueExpr(targetType, left, right, tok); ok {
 		return value
 	}
+	right = "(" + right + ")"
 	switch tok {
 	case token.ADD_ASSIGN:
 		return left + " + " + right
@@ -3230,6 +4050,9 @@ func lowerCompoundAssignValue(
 	case token.SHL_ASSIGN:
 		return left + " << " + right
 	case token.SHR_ASSIGN:
+		if bits, ok := unsignedIntegerBits(targetType); ok && bits <= 32 {
+			return "(" + left + " >>> " + right + ") >>> 0"
+		}
 		return left + " >> " + right
 	case token.AND_NOT_ASSIGN:
 		return left + " & ~(" + right + ")"
@@ -3266,30 +4089,31 @@ func integerQuotientAssignValueExpr(targetType types.Type, left string, right st
 }
 
 func wideIntegerAssignHelper(targetType types.Type, tok token.Token) (RuntimeHelper, bool) {
-	if !isFixedWideIntegerType(targetType) {
+	if !isRuntimeWideIntegerType(targetType) {
 		return "", false
 	}
+	signed := isFixedSignedWideIntegerType(targetType)
 	switch tok {
 	case token.SHL_ASSIGN:
-		return RuntimeHelperUint64Shl, true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Shl, RuntimeHelperInt64Shl), true
 	case token.SHR_ASSIGN:
-		return RuntimeHelperUint64Shr, true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Shr, RuntimeHelperInt64Shr), true
 	case token.MUL_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Mul, RuntimeHelperInt64Mul), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Mul, RuntimeHelperInt64Mul), true
 	case token.QUO_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Div, RuntimeHelperInt64Div), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Div, RuntimeHelperInt64Div), true
 	case token.REM_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Mod, RuntimeHelperInt64Mod), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Mod, RuntimeHelperInt64Mod), true
 	case token.ADD_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Add, RuntimeHelperInt64Add), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Add, RuntimeHelperInt64Add), true
 	case token.SUB_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Sub, RuntimeHelperInt64Sub), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Sub, RuntimeHelperInt64Sub), true
 	case token.AND_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64And, RuntimeHelperInt64And), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64And, RuntimeHelperInt64And), true
 	case token.OR_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Or, RuntimeHelperInt64Or), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Or, RuntimeHelperInt64Or), true
 	case token.XOR_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Xor, RuntimeHelperInt64Xor), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Xor, RuntimeHelperInt64Xor), true
 	default:
 		return "", false
 	}
@@ -3366,12 +4190,20 @@ func (o *LoweringOwner) shortDeclTypeAnnotation(ctx lowerFileContext, lhs ast.Ex
 		}
 		return ": " + typ
 	}
+	if rhs != nil && isIdentLikeExpr(rhs) && isInterfaceType(obj.Type()) {
+		return ": " + o.tsVariableTypeFor(ctx, obj.Type(), ctx.model.needsVarRef[obj])
+	}
 	if !shortDeclNeedsTypeAnnotation(obj.Type()) {
 		return ""
 	}
 	return ": " + o.tsVariableTypeFor(ctx, obj.Type(), ctx.model.needsVarRef[obj])
 }
 
+func isIdentLikeExpr(expr ast.Expr) bool {
+	_, ok := ast.Unparen(expr).(*ast.Ident)
+	return ok
+}
+
 func shortDeclNeedsTypeAnnotation(typ types.Type) bool {
 	switch typed := types.Unalias(typ).Underlying().(type) {
 	case *types.Pointer:
@@ -3401,6 +4233,15 @@ func (o *LoweringOwner) lowerTupleTargetAssignmentStmt(
 	declare bool,
 ) (loweredStmt, []Diagnostic) {
 	if !declare {
+		if index, ok := unwrapParenExpr(lhs).(*ast.IndexExpr); ok && isMapType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)) {
+			targetType := assignmentTargetType(ctx, lhs)
+			value = o.lowerValueForTarget(ctx, lhs, targetType, value)
+			stmts, diagnostics := o.lowerMapIndexUpdateStmts(ctx, index, token.ASSIGN, value, targetType)
+			if len(stmts) != 0 {
+				return stmts[0], diagnostics
+			}
+			return loweredStmt{}, diagnostics
+		}
 		if stmt, diagnostics, ok := o.lowerStarTargetAssignmentStmt(ctx, lhs, value); ok {
 			return stmt, diagnostics
 		}
@@ -3555,7 +4396,7 @@ func (o *LoweringOwner) lowerShortDeclNewShadowAliases(
 		if entry.def == nil || aliases[entry.def] != "" {
 			continue
 		}
-		if shortDeclDefShadowsOuterName(entry.name, entry.def) {
+		if shortDeclDefShadowsOuterName(ctx, entry.name, entry.def) {
 			aliases[entry.def] = ctx.tempName("Shadow")
 		}
 	}
@@ -3584,12 +4425,24 @@ func shortDeclShadowNonValueIdents(ctx lowerFileContext, expr ast.Expr) map[*ast
 	return idents
 }
 
-func shortDeclDefShadowsOuterName(name string, def types.Object) bool {
+func shortDeclDefShadowsOuterName(ctx lowerFileContext, name string, def types.Object) bool {
 	for scope := def.Parent(); scope != nil; scope = scope.Parent() {
 		if scope == def.Parent() {
 			continue
 		}
 		obj := scope.Lookup(name)
+		if scope.Parent() == types.Universe {
+			if obj == nil {
+				return false
+			}
+			if _, isTypeName := obj.(*types.TypeName); isTypeName {
+				return true
+			}
+			if _, isFunc := obj.(*types.Func); isFunc {
+				return sameSourceFile(ctx, obj.Pos(), def.Pos()) && obj.Pos() < def.Pos()
+			}
+			return false
+		}
 		if obj != nil && obj.Pos().IsValid() && obj.Pos() < def.Pos() {
 			return true
 		}
@@ -3597,6 +4450,40 @@ func shortDeclDefShadowsOuterName(name string, def types.Object) bool {
 	return false
 }
 
+func sameSourceFile(ctx lowerFileContext, left token.Pos, right token.Pos) bool {
+	if !left.IsValid() || !right.IsValid() || ctx.semPkg == nil || ctx.semPkg.source == nil {
+		return false
+	}
+	leftPos := sourcePos(ctx.semPkg.source, left)
+	rightPos := sourcePos(ctx.semPkg.source, right)
+	return leftPos.file != "" && leftPos.file == rightPos.file
+}
+
+func valueSpecUsesOuterName(ctx lowerFileContext, spec *ast.ValueSpec, name string, def types.Object) bool {
+	if spec == nil || name == "" || def == nil {
+		return false
+	}
+	usesOuter := false
+	for _, value := range spec.Values {
+		ast.Inspect(value, func(node ast.Node) bool {
+			ident, ok := node.(*ast.Ident)
+			if !ok || ident.Name != name {
+				return true
+			}
+			obj := ctx.semPkg.source.TypesInfo.Uses[ident]
+			if obj != nil && obj != def {
+				usesOuter = true
+				return false
+			}
+			return true
+		})
+		if usesOuter {
+			return true
+		}
+	}
+	return false
+}
+
 func (o *LoweringOwner) mapIndexDefaultUsesShortDeclName(
 	ctx lowerFileContext,
 	rhs ast.Expr,
@@ -4656,7 +5543,7 @@ func (o *LoweringOwner) lowerRangeFuncStmt(
 		diagnostics = append(diagnostics, assignmentDiagnostics...)
 		body = append(assignments, body...)
 	}
-	async := ctx.asyncFunction
+	async := ctx.asyncFunction || stmtsContainAwait(body) || o.rangeFunctionValueNeedsAwait(ctx, stmt.X)
 
 	return loweredStmt{rangeFunc: &loweredRangeFunc{
 		value:        rangeValue,
@@ -5285,6 +6172,19 @@ func (o *LoweringOwner) lowerComplexEqualityExpr(ctx lowerFileContext, expr *ast
 	return value, true
 }
 
+func (o *LoweringOwner) lowerStructEqualityExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
+	leftType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
+	rightType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Y)
+	if !isStructComparableType(leftType) || !isStructComparableType(rightType) {
+		return "", false
+	}
+	value := o.runtimeOwner.QualifiedHelper(RuntimeHelperComparableEqual) + "(" + left + ", " + right + ")"
+	if expr.Op == token.NEQ {
+		value = "!" + value
+	}
+	return value, true
+}
+
 func (o *LoweringOwner) lowerStringEqualityExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
 	leftType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
 	rightType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Y)
@@ -5413,6 +6313,9 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 			if value, ok := o.lowerComplexEqualityExpr(ctx, typed, left, right); ok {
 				return value, append(leftDiagnostics, rightDiagnostics...)
 			}
+			if value, ok := o.lowerStructEqualityExpr(ctx, typed, left, right); ok {
+				return value, append(leftDiagnostics, rightDiagnostics...)
+			}
 			if value, ok := o.lowerStringEqualityExpr(ctx, typed, left, right); ok {
 				return value, append(leftDiagnostics, rightDiagnostics...)
 			}
@@ -5456,6 +6359,10 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 			return lowerPrefixUnaryExpr(typed.Op, value), diagnostics
 		}
 		if typed.Op == token.XOR {
+			if bits, ok := unsignedIntegerBits(ctx.semPkg.source.TypesInfo.TypeOf(typed)); ok && bits <= 32 {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
+					"(~" + value + ", " + strconv.Itoa(bits) + ")", diagnostics
+			}
 			return "~" + value, diagnostics
 		}
 		return value, append(diagnostics, loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported unary operator"))
@@ -5538,7 +6445,7 @@ func isLegacyOctalLiteral(value string) bool {
 func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (string, bool, []Diagnostic) {
 	signature, _ := ctx.semPkg.source.TypesInfo.TypeOf(lit).(*types.Signature)
 	deferState := &loweredDeferState{}
-	bodyCtx := ctx.withSignature(signature).withDeferState(deferState).withoutRangeBranch()
+	bodyCtx := ctx.withSignature(signature).withAsyncFunction(false).withDeferState(deferState).withoutRangeBranch()
 	asyncCompatibleParams := funcLiteralNeedsAsyncFunctionParamCalls(signature)
 	if asyncCompatibleParams || funcLiteralUsesFunctionIdentifierCall(ctx, lit) {
 		bodyCtx = bodyCtx.withAsyncFunction(true)
@@ -5659,7 +6566,7 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 		}
 		return alias
 	}
-	if constObj, ok := obj.(*types.Const); ok && ctx.localAliases[obj] != "" {
+	if constObj, ok := obj.(*types.Const); ok && !raw {
 		if constValue, ok := lowerConstantValue(constObj.Val()); ok {
 			return constValue
 		}
@@ -5667,6 +6574,9 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 	if alias := ctx.localAliases[obj]; alias != "" {
 		if ctx.lazyPackageVars[obj] {
 			lazyValue := alias + "." + packageVarGetterName(value) + "()"
+			if (ctx.asyncFunction || ctx.topLevel) && o.packageVarHasAsyncLazyInit(ctx, obj) {
+				lazyValue = "(await " + alias + "." + packageVarInitName(value) + "(), " + lazyValue + ")"
+			}
 			if raw {
 				return lazyValue
 			}
@@ -5682,6 +6592,9 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 	}
 	if ctx.lazyPackageVars[obj] {
 		lazyValue := packageVarGetterName(value) + "()"
+		if (ctx.asyncFunction || ctx.topLevel) && o.packageVarHasAsyncLazyInit(ctx, obj) {
+			lazyValue = "(await " + packageVarInitName(value) + "(), " + lazyValue + ")"
+		}
 		return o.lowerPackageVarReadValue(ctx, obj, lazyValue)
 	}
 	if obj != nil && ctx.model.needsVarRef[obj] {
@@ -6339,6 +7252,8 @@ func (o *LoweringOwner) lowerConversionExpr(
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperRunesToString) + "(" + value + ")", diagnostics
 		case isByteSliceType(sourceType):
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperBytesToString) + "(" + value + ")", diagnostics
+		case overrideNamedStringType(ctx, o, sourceType):
+			return "String(" + value + ")", diagnostics
 		case isStringType(sourceType):
 			return value, diagnostics
 		case isNumericType(sourceType):
@@ -6397,7 +7312,7 @@ func (o *LoweringOwner) lowerConversionExpr(
 		return renderNamedStructConversion(conversion), diagnostics
 	}
 	if isNumericType(targetType) {
-		if constantValue, ok := lowerRealNumericConstantExpr(ctx, expr.Args[0]); ok {
+		if constantValue, ok := o.lowerNumericConstantExprForTarget(ctx, expr.Args[0], targetType); ok {
 			return constantValue, diagnostics
 		}
 	}
@@ -6429,8 +7344,8 @@ func (o *LoweringOwner) lowerConversionExpr(
 }
 
 func (o *LoweringOwner) lowerWideIntegerBinaryExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
-	resultWide := isFixedWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr))
-	leftWide := isFixedWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr.X))
+	resultWide := isRuntimeWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr))
+	leftWide := isRuntimeWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr.X))
 	if !resultWide && !leftWide {
 		return "", false
 	}
@@ -6696,6 +7611,22 @@ func (o *LoweringOwner) lowerPointerReceiverMethodCall(
 		return "", nil, false
 	}
 	receiverExpr, diagnostics := o.lowerExpr(ctx, selector.X)
+	if o.receiverUsesOverridePackage(signature.Recv().Type()) {
+		receiverExpr = o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
+			"<" + o.tsTypeFor(ctx, signature.Recv().Type().(*types.Pointer).Elem()) + ">(" + receiverExpr + ")"
+	}
+	if receiverExpr == o.namedTypeExpr(ctx, receiver) {
+		call := o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
+			"<" + o.namedTypeExpr(ctx, receiver) + ">(" + receiverExpr + ")." +
+			methodMemberName(selector.Sel.Name) + "(" + strings.Join(args, ", ") + ")"
+		return call, diagnostics, true
+	}
+	if crossPackageUnexportedNamedType(ctx, receiver) {
+		call := o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
+			"<any>(" + receiverExpr + ")." + methodMemberName(selector.Sel.Name) +
+			"(" + strings.Join(args, ", ") + ")"
+		return call, diagnostics, true
+	}
 	callArgs := append([]string{receiverExpr}, args...)
 	call := o.namedTypeExpr(ctx, receiver) + ".prototype." + selector.Sel.Name + ".call(" + strings.Join(callArgs, ", ") + ")"
 	return call, diagnostics, true
@@ -6813,6 +7744,14 @@ func (o *LoweringOwner) lowerSelectorExpr(ctx lowerFileContext, expr *ast.Select
 			if alias := importAliasForPkgName(ctx, pkgName); alias != "" {
 				value := alias + "." + expr.Sel.Name
 				obj, _ := ctx.semPkg.source.TypesInfo.Uses[expr.Sel].(*types.Var)
+				if o.packageVarIsLazy(ctx, obj) ||
+					o.packageVarNameIsLazy(ctx, pkgName.Imported().Path(), expr.Sel.Name) {
+					value = alias + "." + packageVarGetterName(expr.Sel.Name) + "()"
+					if (ctx.asyncFunction || ctx.topLevel) &&
+						o.packageVarNameHasAsyncLazyInit(ctx, pkgName.Imported().Path(), expr.Sel.Name) {
+						value = "(await " + alias + "." + packageVarInitName(expr.Sel.Name) + "(), " + value + ")"
+					}
+				}
 				if obj != nil && packageVarReadNeedsPointerValue(obj.Type()) {
 					value = o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
 						"<" + o.tsNonNilTypeFor(ctx, obj.Type()) + ">(" + value + ")"
@@ -6887,10 +7826,13 @@ func (o *LoweringOwner) packageVarSetterForAssignment(ctx lowerFileContext, expr
 			return "", false
 		}
 		alias := ctx.localAliases[obj]
-		if alias == "" {
-			return "", false
+		if alias != "" {
+			return alias + "." + packageVarSetterName(ident.Name), true
 		}
-		return alias + "." + packageVarSetterName(ident.Name), true
+		if ctx.lazyPackageVars[obj] {
+			return packageVarSetterName(ident.Name), true
+		}
+		return "", false
 	}
 	selector, ok := unwrapParenExpr(expr).(*ast.SelectorExpr)
 	if !ok {
@@ -7848,12 +8790,40 @@ func (o *LoweringOwner) lowerStructCompositeLit(
 func compositeLiteralFieldNeedsPreEval(ctx lowerFileContext, expr ast.Expr) bool {
 	switch typed := unwrapParenExpr(expr).(type) {
 	case *ast.CallExpr:
+		for _, arg := range typed.Args {
+			if compositeLiteralFieldNeedsPreEval(ctx, arg) {
+				return true
+			}
+		}
 		if ident, ok := typed.Fun.(*ast.Ident); ok && isBuiltinCallTarget(ctx, ident) {
 			return false
 		}
 		return typeFromExpr(ctx, typed.Fun) == nil
 	case *ast.UnaryExpr:
-		return typed.Op == token.ARROW
+		return typed.Op == token.ARROW || compositeLiteralFieldNeedsPreEval(ctx, typed.X)
+	case *ast.BinaryExpr:
+		return compositeLiteralFieldNeedsPreEval(ctx, typed.X) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.Y)
+	case *ast.IndexExpr:
+		return compositeLiteralFieldNeedsPreEval(ctx, typed.X) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.Index)
+	case *ast.IndexListExpr:
+		if compositeLiteralFieldNeedsPreEval(ctx, typed.X) {
+			return true
+		}
+		for _, index := range typed.Indices {
+			if compositeLiteralFieldNeedsPreEval(ctx, index) {
+				return true
+			}
+		}
+		return false
+	case *ast.SliceExpr:
+		return compositeLiteralFieldNeedsPreEval(ctx, typed.X) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.Low) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.High) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.Max)
+	case *ast.StarExpr:
+		return compositeLiteralFieldNeedsPreEval(ctx, typed.X)
 	default:
 		return false
 	}
@@ -7918,6 +8888,9 @@ func (o *LoweringOwner) lowerArrayCompositeLit(
 	lit *ast.CompositeLit,
 	array *types.Array,
 ) (string, []Diagnostic) {
+	if len(lit.Elts) == 0 && isByteType(array.Elem()) {
+		return "new Uint8Array(" + strconv.FormatInt(array.Len(), 10) + ")", nil
+	}
 	values := make([]string, int(array.Len()))
 	for idx := range values {
 		values[idx] = o.lowerZeroValueExprFor(ctx, array.Elem())
@@ -8071,7 +9044,7 @@ func (o *LoweringOwner) lowerValueForTarget(
 		}
 	}
 	if isNumericType(targetType) {
-		if constantValue, ok := lowerRealNumericConstantExpr(ctx, expr); ok {
+		if constantValue, ok := o.lowerNumericConstantExprForTarget(ctx, expr, targetType); ok {
 			return constantValue
 		}
 	}
@@ -8100,6 +9073,28 @@ func lowerRealNumericConstantExpr(ctx lowerFileContext, expr ast.Expr) (string,
 	}
 }
 
+func (o *LoweringOwner) lowerNumericConstantExprForTarget(ctx lowerFileContext, expr ast.Expr, targetType types.Type) (string, bool) {
+	if ctx.semPkg == nil || ctx.semPkg.source == nil {
+		return "", false
+	}
+	tv, ok := ctx.semPkg.source.TypesInfo.Types[expr]
+	if ok && tv.Value != nil {
+		if bits, ok := unsignedIntegerBits(targetType); ok && bits >= 64 {
+			if value, ok := lowerWideIntegerConstantValue(tv.Value); ok {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) + "(" +
+					strconv.Quote(value) + ", 64)", true
+			}
+		}
+		if bits, ok := signedIntegerBits(targetType); ok && bits >= 64 {
+			if value, ok := lowerWideIntegerConstantValue(tv.Value); ok {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperInt) + "(" +
+					strconv.Quote(value) + ", 64)", true
+			}
+		}
+	}
+	return lowerRealNumericConstantExpr(ctx, expr)
+}
+
 func isRealNumericConstantExpr(ctx lowerFileContext, expr ast.Expr) bool {
 	if ctx.semPkg != nil && ctx.semPkg.source != nil {
 		if tv, ok := ctx.semPkg.source.TypesInfo.Types[expr]; ok && tv.Value != nil {
@@ -8145,6 +9140,9 @@ func (o *LoweringOwner) lowerValueForTargetTypes(
 			return wrapper
 		}
 	}
+	if wrapper := o.lowerNumericInterfaceWrapper(ctx, targetType, sourceType, value); wrapper != "" {
+		return wrapper
+	}
 	if isInterfaceType(targetType) && isStructValueType(sourceType) {
 		if cloneStructValue {
 			value = o.lowerStructClone(value)
@@ -8193,6 +9191,25 @@ func (o *LoweringOwner) lowerValueForTargetTypes(
 	return value
 }
 
+func (o *LoweringOwner) lowerNumericInterfaceWrapper(
+	ctx lowerFileContext,
+	targetType types.Type,
+	sourceType types.Type,
+	value string,
+) string {
+	if targetType == nil || sourceType == nil || !isInterfaceType(targetType) || isInterfaceType(sourceType) {
+		return ""
+	}
+	basic, ok := types.Unalias(sourceType).(*types.Basic)
+	if !ok || basic.Info()&types.IsNumeric == 0 || basic.Info()&types.IsUntyped != 0 {
+		return ""
+	}
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperNamedValueInterfaceValue) +
+		"<" + o.tsTypeFor(ctx, targetType) + ">(" + value + ", " +
+		strconv.Quote(goRuntimeTypeString(sourceType)) + ", {}, " +
+		o.runtimeTypeInfoExpr(sourceType) + ")"
+}
+
 func isBasicFixedWideIntegerType(typ types.Type) bool {
 	basic, ok := types.Unalias(typ).(*types.Basic)
 	if !ok {
@@ -8232,7 +9249,8 @@ func (o *LoweringOwner) lowerNamedValueInterfaceWrapper(
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperNamedValueInterfaceValue) +
 		"<" + o.tsTypeFor(ctx, targetType) + ">(" + value + ", " +
-		strconv.Quote(goRuntimeTypeString(sourceType)) + ", " + methods + ")"
+		strconv.Quote(goRuntimeTypeString(sourceType)) + ", " + methods + ", " +
+		o.runtimeTypeInfoExpr(sourceType) + ")"
 }
 
 func (o *LoweringOwner) lowerPrimitiveErrorWrapper(ctx lowerFileContext, sourceType types.Type, value string) string {
@@ -8254,7 +9272,8 @@ func (o *LoweringOwner) lowerPrimitiveErrorWrapper(ctx lowerFileContext, sourceT
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperNamedValueInterfaceValue) +
 		"<$.GoError>(" + value + ", " + strconv.Quote(goRuntimeTypeString(sourceType)) +
-		", {\"Error\": " + o.methodFunctionExpr(ctx, named, fn, "Error") + "})"
+		", {\"Error\": " + o.methodFunctionExpr(ctx, named, fn, "Error") + "}, " +
+		o.runtimeTypeInfoExpr(sourceType) + ")"
 }
 
 func (o *LoweringOwner) lowerStructClone(value string) string {
@@ -8264,7 +9283,7 @@ func (o *LoweringOwner) lowerStructClone(value string) string {
 
 func (o *LoweringOwner) lowerZeroValueExpr(typ types.Type) string {
 	if named := namedStructType(typ); named != nil && isStructValueType(typ) {
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue) + "(new " + named.Obj().Name() + "())"
+		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue) + "(new " + safeIdentifier(named.Obj().Name()) + "())"
 	}
 	return zeroValueExpr(typ)
 }
@@ -8311,7 +9330,7 @@ func (o *LoweringOwner) lowerZeroValueExprFor(ctx lowerFileContext, typ types.Ty
 
 func (o *LoweringOwner) lowerDeclarationZeroValueExpr(ctx lowerFileContext, typ types.Type) string {
 	if isFunctionType(typ) {
-		return "null as " + o.tsTypeFor(ctx, typ)
+		return "null as unknown as " + o.tsFunctionZeroValueTypeFor(ctx, typ)
 	}
 	typeParam, ok := types.Unalias(typ).(*types.TypeParam)
 	if !ok {
@@ -8328,6 +9347,13 @@ func (o *LoweringOwner) lowerDeclarationZeroValueExpr(ctx lowerFileContext, typ
 		"(__typeArgs, " + strconv.Quote(typeParam.Obj().Name()) + ", " + zeroValueExpr(typ) + ")"
 }
 
+func (o *LoweringOwner) tsFunctionZeroValueTypeFor(ctx lowerFileContext, typ types.Type) string {
+	if signature := unnamedSignatureForType(typ); signature != nil {
+		return o.tsAsyncCompatibleFunctionTypeFor(ctx, signature)
+	}
+	return o.tsTypeFor(ctx, typ)
+}
+
 func (o *LoweringOwner) runtimeTypeInfoExpr(typ types.Type) string {
 	return o.runtimeTypeInfoExprWithSeen(typ, make(map[types.Type]bool))
 }
@@ -8789,6 +9815,9 @@ func (o *LoweringOwner) tsNonNilTypeFor(ctx lowerFileContext, typ types.Type) st
 	}
 	if named, ok := types.Unalias(typ).(*types.Named); ok {
 		if _, ok := named.Underlying().(*types.Interface); ok {
+			if !ctx.canReferenceNamedType(named) {
+				return "any"
+			}
 			return "Exclude<" + o.namedTypeExpr(ctx, named) + ", null>"
 		}
 	}
@@ -8851,7 +9880,7 @@ func zeroValueExpr(typ types.Type) string {
 		return "undefined"
 	}
 	if named := namedStructType(typ); named != nil && isStructValueType(typ) {
-		return "new " + named.Obj().Name() + "()"
+		return "new " + safeIdentifier(named.Obj().Name()) + "()"
 	}
 	switch typed := types.Unalias(typ).Underlying().(type) {
 	case *types.Basic:
@@ -8941,6 +9970,11 @@ func namedFunctionType(typ types.Type) *types.Named {
 	return named
 }
 
+func overrideNamedStringType(ctx lowerFileContext, owner *LoweringOwner, typ types.Type) bool {
+	named, _ := types.Unalias(typ).(*types.Named)
+	return named != nil && isStringType(named) && owner.typeUsesOverride(named)
+}
+
 func isBuiltinErrorType(typ types.Type) bool {
 	if typ == nil {
 		return false
@@ -9091,6 +10125,16 @@ func isStructValueType(typ types.Type) bool {
 	return namedStructType(typ) != nil
 }
 
+func isStructComparableType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
+	if _, ok := types.Unalias(typ).Underlying().(*types.Struct); !ok {
+		return false
+	}
+	return types.Comparable(typ)
+}
+
 func isPointerToStructType(typ types.Type) bool {
 	pointer, ok := types.Unalias(typ).Underlying().(*types.Pointer)
 	if !ok {
@@ -9270,6 +10314,14 @@ func isFixedSignedWideIntegerType(typ types.Type) bool {
 	return ok && basic.Kind() == types.Int64
 }
 
+func isRuntimeWideIntegerType(typ types.Type) bool {
+	if isFixedWideIntegerType(typ) {
+		return true
+	}
+	bits, ok := unsignedIntegerBits(typ)
+	return ok && bits > 32
+}
+
 func isRuneSliceType(typ types.Type) bool {
 	slice, ok := types.Unalias(typ).Underlying().(*types.Slice)
 	return ok && isRuneType(slice.Elem())
@@ -9355,8 +10407,7 @@ func (o *LoweringOwner) functionAsync(ctx lowerFileContext, fn *types.Func) bool
 	if fn == nil || ctx.model == nil {
 		return false
 	}
-	semFn := semanticFunctionFor(ctx.model, fn)
-	return semFn != nil && semFn.async
+	return ctx.model.functionAsync(fn)
 }
 
 func (o *LoweringOwner) callNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool {
@@ -9505,6 +10556,18 @@ func (o *LoweringOwner) inferGenericTypeArg(
 		}
 		return
 	}
+	if paramNamed, ok := types.Unalias(paramType).(*types.Named); ok {
+		if argNamed, ok := types.Unalias(argType).(*types.Named); ok &&
+			namedOriginsEqual(paramNamed, argNamed) {
+			paramArgs := paramNamed.TypeArgs()
+			argArgs := argNamed.TypeArgs()
+			if paramArgs != nil && argArgs != nil {
+				for idx := range min(paramArgs.Len(), argArgs.Len()) {
+					o.inferGenericTypeArg(inferred, paramArgs.At(idx), argArgs.At(idx))
+				}
+			}
+		}
+	}
 	switch param := types.Unalias(paramType).Underlying().(type) {
 	case *types.Slice:
 		if arg, ok := types.Unalias(argType).Underlying().(*types.Slice); ok {
@@ -9517,6 +10580,24 @@ func (o *LoweringOwner) inferGenericTypeArg(
 	}
 }
 
+func namedOriginsEqual(a, b *types.Named) bool {
+	if a == nil || b == nil {
+		return false
+	}
+	aOrigin := a.Origin()
+	if aOrigin == nil {
+		aOrigin = a
+	}
+	bOrigin := b.Origin()
+	if bOrigin == nil {
+		bOrigin = b
+	}
+	if aOrigin.Obj() == nil || bOrigin.Obj() == nil {
+		return aOrigin == bOrigin
+	}
+	return aOrigin.Obj() == bOrigin.Obj()
+}
+
 func (o *LoweringOwner) genericTypeDescriptorExpr(ctx lowerFileContext, typ types.Type) string {
 	if typeParam, ok := types.Unalias(typ).(*types.TypeParam); ok && typeParamInScope(ctx, typeParam) {
 		return "__typeArgs?.[" + strconv.Quote(typeParam.Obj().Name()) + "] ?? { type: " +
@@ -9560,7 +10641,12 @@ func (o *LoweringOwner) genericMethodDescriptorsForType(
 		if sig, _ := method.Type().(*types.Signature); sig != nil {
 			if recv := sig.Recv(); recv != nil {
 				if _, ok := types.Unalias(recv.Type()).Underlying().(*types.Pointer); !ok {
-					receiver = o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) + "(receiver)"
+					if _, ok := types.Unalias(methodSetType).Underlying().(*types.Pointer); ok {
+						receiver = o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) + "(receiver)"
+					} else {
+						receiver = "(" + o.runtimeOwner.QualifiedHelper(RuntimeHelperIsVarRef) +
+							"(receiver) ? receiver.value : receiver)"
+					}
 				}
 			}
 		}
@@ -9590,9 +10676,9 @@ func namedNonStructMethodSetType(typ types.Type) (*types.Named, types.Type) {
 
 func methodFunctionName(receiver *types.Named, method string) string {
 	if receiver == nil || receiver.Obj() == nil {
-		return method
+		return safeIdentifier(method)
 	}
-	return receiver.Obj().Name() + "_" + method
+	return safeIdentifier(receiver.Obj().Name()) + "_" + safeIdentifier(method)
 }
 
 func methodReceiverNamedType(obj types.Object) *types.Named {
@@ -9629,7 +10715,7 @@ func (o *LoweringOwner) namedTypeExpr(ctx lowerFileContext, named *types.Named)
 	if named == nil || named.Obj() == nil {
 		return "unknown"
 	}
-	baseName := named.Obj().Name()
+	baseName := safeIdentifier(named.Obj().Name())
 	if alias := ctx.localAliases[named.Obj()]; alias != "" {
 		baseName = alias + "." + baseName
 	} else if named.Obj().Pkg() != nil {
@@ -9692,11 +10778,30 @@ func runtimeNamedTypeName(named *types.Named) string {
 }
 
 func goRuntimeTypeString(typ types.Type) string {
-	return types.TypeString(typ, func(pkg *types.Package) string {
+	return types.TypeString(runtimeIdentityType(typ), func(pkg *types.Package) string {
 		return pkg.Name()
 	})
 }
 
+func runtimeIdentityType(typ types.Type) types.Type {
+	switch typed := typ.(type) {
+	case *types.Alias:
+		return runtimeIdentityType(types.Unalias(typed))
+	case *types.Pointer:
+		return types.NewPointer(runtimeIdentityType(typed.Elem()))
+	case *types.Slice:
+		return types.NewSlice(runtimeIdentityType(typed.Elem()))
+	case *types.Array:
+		return types.NewArray(runtimeIdentityType(typed.Elem()), typed.Len())
+	case *types.Map:
+		return types.NewMap(runtimeIdentityType(typed.Key()), runtimeIdentityType(typed.Elem()))
+	case *types.Chan:
+		return types.NewChan(typed.Dir(), runtimeIdentityType(typed.Elem()))
+	default:
+		return typ
+	}
+}
+
 func basicRuntimeName(basic *types.Basic) string {
 	if basic == nil {
 		return "unknown"
@@ -9706,6 +10811,32 @@ func basicRuntimeName(basic *types.Basic) string {
 		return "bool"
 	case types.String:
 		return "string"
+	case types.Int:
+		return "int"
+	case types.Int8:
+		return "int8"
+	case types.Int16:
+		return "int16"
+	case types.Int32:
+		return "int32"
+	case types.Int64:
+		return "int64"
+	case types.Uint:
+		return "uint"
+	case types.Uint8:
+		return "uint8"
+	case types.Uint16:
+		return "uint16"
+	case types.Uint32:
+		return "uint32"
+	case types.Uint64:
+		return "uint64"
+	case types.Uintptr:
+		return "uintptr"
+	case types.Float32:
+		return "float32"
+	case types.Float64:
+		return "float64"
 	case types.Complex64:
 		return "complex64"
 	case types.Complex128: