goscript 0.1.3 → 0.2.0

package/compiler/lowering.go

@@ -24,6 +24,16 @@ type LoweringOwner struct {
 	overrideOwner *OverrideRegistryOwner
 }
 
+// LoweringOptions are request-scoped lowering switches.
+type LoweringOptions struct {
+	// SourceRoot is the request source root that may contain sibling protobuf TypeScript files.
+	SourceRoot string
+	// OutputPath is the TypeScript output root used for generated relative imports.
+	OutputPath string
+	// ProtobufTypeScriptBinding binds .pb.go files to sibling .pb.ts files.
+	ProtobufTypeScriptBinding bool
+}
+
 // NewLoweringOwner creates the lowering owner.
 func NewLoweringOwner(runtimeOwner *RuntimeContractOwner, overrideOwner *OverrideRegistryOwner) *LoweringOwner {
 	if runtimeOwner == nil {
@@ -39,7 +49,7 @@ func NewLoweringOwner(runtimeOwner *RuntimeContractOwner, overrideOwner *Overrid
 }
 
 // Build converts the semantic model into the compiler IR.
-func (o *LoweringOwner) Build(ctx context.Context, model *SemanticModel) (*LoweredProgram, []Diagnostic) {
+func (o *LoweringOwner) Build(ctx context.Context, model *SemanticModel, opts ...LoweringOptions) (*LoweredProgram, []Diagnostic) {
 	if err := ctx.Err(); err != nil {
 		return nil, []Diagnostic{{
 			Severity: DiagnosticSeverityError,
@@ -55,7 +65,14 @@ func (o *LoweringOwner) Build(ctx context.Context, model *SemanticModel) (*Lower
 		}}
 	}
 
+	var options LoweringOptions
+	if len(opts) != 0 {
+		options = opts[0]
+	}
+
 	program := &LoweredProgram{}
+	lazyPackageVars := make(map[string]map[types.Object]bool, len(model.packages))
+	runtimeMethodSets := make(runtimeMethodSetCache)
 	semPkgs := make([]*semanticPackage, 0, len(model.packages))
 	for _, semPkg := range model.packages {
 		semPkgs = append(semPkgs, semPkg)
@@ -70,7 +87,7 @@ func (o *LoweringOwner) Build(ctx context.Context, model *SemanticModel) (*Lower
 			diagnostics = append(diagnostics, loweringUnsupported("package", semPkg.pkgPath, "missing semantic source package"))
 			continue
 		}
-		loweredPkg, pkgDiagnostics := o.lowerPackage(model, semPkg)
+		loweredPkg, pkgDiagnostics := o.lowerPackage(model, semPkg, lazyPackageVars, runtimeMethodSets, options)
 		diagnostics = append(diagnostics, pkgDiagnostics...)
 		if loweredPkg != nil {
 			program.packages = append(program.packages, loweredPkg)
@@ -82,18 +99,68 @@ func (o *LoweringOwner) Build(ctx context.Context, model *SemanticModel) (*Lower
 	return program, nil
 }
 
-func (o *LoweringOwner) lowerPackage(model *SemanticModel, semPkg *semanticPackage) (*loweredPackage, []Diagnostic) {
+func (o *LoweringOwner) lowerPackage(
+	model *SemanticModel,
+	semPkg *semanticPackage,
+	lazyPackageVarsByPkg map[string]map[types.Object]bool,
+	runtimeMethodSets runtimeMethodSetCache,
+	options LoweringOptions,
+) (*loweredPackage, []Diagnostic) {
 	loweredPkg := &loweredPackage{
 		pkgPath: semPkg.pkgPath,
 		name:    semPkg.name,
 	}
 	declFiles := packageDeclFiles(semPkg)
 	outputNames := packageOutputNames(semPkg)
-	lazyPackageVars := o.lazyPackageVars(semPkg, declFiles)
-	var diagnostics []Diagnostic
+	protobufBindings, bindingDiagnostics := protobufTypeScriptBindings(semPkg, options)
+	for sourcePath, binding := range protobufBindings {
+		outputNames[sourcePath] = binding.outputName
+	}
+	lazyPackageVars := o.packageLazyVars(semPkg, lazyPackageVarsByPkg, declFiles)
+	diagnostics := append([]Diagnostic(nil), bindingDiagnostics...)
 	for idx, file := range semPkg.source.Syntax {
 		sourcePath := sourceFilePath(semPkg, idx, file)
-		loweredFile, fileDiagnostics := o.lowerFile(model, semPkg, file, sourcePath, declFiles, outputNames, lazyPackageVars)
+		if options.ProtobufTypeScriptBinding && protobufSRPCHasGoScriptReplacement(sourcePath) {
+			stub, stubDiagnostics := lowerProtobufSRPCTypeScriptBindingStub(semPkg, sourcePath, options)
+			diagnostics = append(diagnostics, stubDiagnostics...)
+			if stub != nil {
+				loweredPkg.files = append(loweredPkg.files, stub)
+			}
+			continue
+		}
+		if binding, ok := protobufBindings[sourcePath]; ok {
+			protobufAdapter := !binding.hasOneof && !strings.HasSuffix(filepath.Base(binding.sourcePath), "_srpc.pb.go")
+			loweredFile, fileDiagnostics := o.lowerFile(
+				model,
+				semPkg,
+				file,
+				sourcePath,
+				declFiles,
+				outputNames,
+				lazyPackageVars,
+				lazyPackageVarsByPkg,
+				runtimeMethodSets,
+				protobufAdapter,
+			)
+			diagnostics = append(diagnostics, fileDiagnostics...)
+			rewriteProtobufTypeScriptBindingFile(loweredFile, binding)
+			if loweredFile != nil {
+				loweredPkg.files = append(loweredPkg.files, loweredFile)
+			}
+			continue
+		}
+		loweredFile, fileDiagnostics := o.lowerFile(
+			model,
+			semPkg,
+			file,
+			sourcePath,
+			declFiles,
+			outputNames,
+			lazyPackageVars,
+			lazyPackageVarsByPkg,
+			runtimeMethodSets,
+			false,
+		)
 		diagnostics = append(diagnostics, fileDiagnostics...)
 		if loweredFile != nil {
 			loweredPkg.files = append(loweredPkg.files, loweredFile)
@@ -125,6 +192,9 @@ func (o *LoweringOwner) lowerFile(
 	declFiles map[types.Object]string,
 	outputNames map[string]string,
 	lazyPackageVars map[types.Object]bool,
+	lazyPackageVarsByPkg map[string]map[types.Object]bool,
+	runtimeMethodSets runtimeMethodSetCache,
+	protobufTypeScriptAdapter bool,
 ) (*loweredFile, []Diagnostic) {
 	associatedMethods := o.methodDeclsForFileTypes(semPkg, file)
 	relevantImportFiles := map[string]bool{sourcePath: true}
@@ -146,7 +216,7 @@ func (o *LoweringOwner) lowerFile(
 	importPaths := make(map[string]string)
 	importNames := make(map[string]string)
 	importObjects := make(map[*types.PkgName]string)
-	localRefs := o.analyzeLocalFileReferences(semPkg, file, sourcePath, associatedMethods, declFiles, outputNames)
+	localRefs := o.analyzeLocalFileReferences(semPkg, file, sourcePath, associatedMethods, declFiles, outputNames, runtimeMethodSets)
 	reservedImportAliases := localRefs.reservedNames
 	seenImport := make(map[string]bool)
 	for idx, importFile := range semPkg.source.Syntax {
@@ -231,18 +301,20 @@ func (o *LoweringOwner) lowerFile(
 	loweredFile.imports = append(loweredFile.imports, localImports...)
 
 	ctx := lowerFileContext{
-		model:           model,
-		semPkg:          semPkg,
-		file:            file,
-		importAliases:   importAliases,
-		importPaths:     importPaths,
-		importNames:     importNames,
-		importObjects:   importObjects,
-		sourcePath:      sourcePath,
-		localAliases:    localRefs.aliases,
-		lazyPackageVars: lazyPackageVars,
-		tempNames:       newTempNameOwner(),
-		topLevel:        true,
+		model:                model,
+		semPkg:               semPkg,
+		file:                 file,
+		importAliases:        importAliases,
+		importPaths:          importPaths,
+		importNames:          importNames,
+		importObjects:        importObjects,
+		sourcePath:           sourcePath,
+		localAliases:         localRefs.aliases,
+		lazyPackageVars:      lazyPackageVars,
+		lazyPackageVarsByPkg: lazyPackageVarsByPkg,
+		tempNames:            newTempNameOwner(),
+		topLevel:             true,
+		protobufTSAdapter:    protobufTypeScriptAdapter,
 	}
 	var diagnostics []Diagnostic
 	var packageInitCalls []string
@@ -451,6 +523,24 @@ type localFileReferenceAnalysis struct {
 	implicitRuntime map[string]bool
 }
 
+type runtimeMethodSetCache map[*types.Named][]types.Object
+
+func (c runtimeMethodSetCache) methods(named *types.Named) []types.Object {
+	if named == nil {
+		return nil
+	}
+	if methods, ok := c[named]; ok {
+		return methods
+	}
+	methodSet := types.NewMethodSet(types.NewPointer(named))
+	methods := make([]types.Object, 0, methodSet.Len())
+	for method := range methodSet.Methods() {
+		methods = append(methods, method.Obj())
+	}
+	c[named] = methods
+	return methods
+}
+
 func (o *LoweringOwner) analyzeLocalFileReferences(
 	semPkg *semanticPackage,
 	file *ast.File,
@@ -458,6 +548,7 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 	associatedMethods []*ast.FuncDecl,
 	declFiles map[types.Object]string,
 	outputNames map[string]string,
+	runtimeMethodSets runtimeMethodSetCache,
 ) localFileReferenceAnalysis {
 	analysis := localFileReferenceAnalysis{
 		reservedNames:   make(map[string]bool),
@@ -469,6 +560,8 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 	}
 	seenObjects := make(map[types.Object]bool)
 	seenTypes := make(map[types.Type]bool)
+	seenRuntimeTypes := make(map[types.Type]bool)
+	seenRuntimeOwnerTypes := make(map[types.Type]bool)
 	var addTypeDeps func(typ types.Type)
 	var addRuntimeTypeDeps func(typ types.Type)
 	var addRuntimeTypeOwnerDeps func(typ types.Type)
@@ -636,6 +729,10 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 		if typ == nil {
 			return
 		}
+		if seenRuntimeTypes[typ] {
+			return
+		}
+		seenRuntimeTypes[typ] = true
 		if alias, ok := typ.(*types.Alias); ok {
 			addObject(alias.Obj(), true)
 			if args := alias.TypeArgs(); args != nil {
@@ -651,9 +748,8 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 			for method := range named.Methods() {
 				addObject(method, true)
 			}
-			methodSet := types.NewMethodSet(types.NewPointer(named))
-			for method := range methodSet.Methods() {
-				addObject(method.Obj(), true)
+			for _, method := range runtimeMethodSets.methods(named) {
+				addObject(method, true)
 			}
 			if args := named.TypeArgs(); args != nil {
 				for t := range args.Types() {
@@ -680,6 +776,10 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 		if typ == nil {
 			return
 		}
+		if seenRuntimeOwnerTypes[typ] {
+			return
+		}
+		seenRuntimeOwnerTypes[typ] = true
 		if alias, ok := typ.(*types.Alias); ok {
 			addObject(alias.Obj(), true)
 			if args := alias.TypeArgs(); args != nil {
@@ -773,6 +873,9 @@ func (o *LoweringOwner) analyzeLocalFileReferences(
 	}
 	ast.Inspect(file, inspect)
 	for _, methodDecl := range associatedMethods {
+		if sourcePos(semPkg.source, methodDecl.Pos()).file == sourcePath {
+			continue
+		}
 		ast.Inspect(methodDecl, inspect)
 	}
 	return analysis
@@ -984,36 +1087,39 @@ func safeParamName(param *types.Var, idx int) string {
 }
 
 type lowerFileContext struct {
-	model             *SemanticModel
-	semPkg            *semanticPackage
-	file              *ast.File
-	importAliases     map[string]string
-	importPaths       map[string]string
-	importNames       map[string]string
-	importObjects     map[*types.PkgName]string
-	sourcePath        string
-	localAliases      map[types.Object]string
-	lazyPackageVars   map[types.Object]bool
-	identAliases      map[types.Object]string
-	identAliasRefs    map[types.Object]bool
-	tempNames         *tempNameOwner
-	signature         *types.Signature
-	typeParams        map[string]bool
-	staticTypeParams  map[string]bool
-	asyncFunction     bool
-	functionTypeDepth int
-	deferState        *loweredDeferState
-	rangeBranch       *loweredRangeBranch
-	rangeBreak        bool
-	rangeContinue     bool
-	gotoLabels        map[string]bool
-	forwardGotos      map[string]bool
-	gotoStateLabels   map[string]bool
-	gotoStateVar      string
-	gotoStateLoop     string
-	loopLabel         string
-	switchBreak       bool
-	topLevel          bool
+	model                *SemanticModel
+	semPkg               *semanticPackage
+	file                 *ast.File
+	importAliases        map[string]string
+	importPaths          map[string]string
+	importNames          map[string]string
+	importObjects        map[*types.PkgName]string
+	sourcePath           string
+	localAliases         map[types.Object]string
+	lazyPackageVars      map[types.Object]bool
+	lazyPackageVarsByPkg map[string]map[types.Object]bool
+	identAliases         map[types.Object]string
+	identAliasRefs       map[types.Object]bool
+	tempNames            *tempNameOwner
+	signature            *types.Signature
+	typeParams           map[string]bool
+	staticTypeParams     map[string]bool
+	asyncFunction        bool
+	functionTypeDepth    int
+	deferState           *loweredDeferState
+	rangeBranch          *loweredRangeBranch
+	rangeBreak           bool
+	rangeContinue        bool
+	gotoLabels           map[string]bool
+	forwardGotos         map[string]bool
+	gotoStateLabels      map[string]bool
+	gotoStateVar         string
+	gotoStateLoop        string
+	functionScopedDecls  bool
+	loopLabel            string
+	switchBreak          bool
+	topLevel             bool
+	protobufTSAdapter    bool
 }
 
 type tempNameOwner struct {
@@ -1124,7 +1230,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) {
@@ -1171,7 +1277,7 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				if _, ok := obj.(*types.Const); !ok && ctx.model.needsVarRef[obj] {
 					value = o.runtimeOwner.QualifiedHelper(RuntimeHelperVarRef) + "(" + value + ")"
 				}
-				keyword := "let"
+				keyword := strings.TrimSpace(declarationKeyword(ctx))
 				if _, ok := obj.(*types.Const); ok || decl.Tok == token.CONST {
 					keyword = "const"
 				}
@@ -1190,7 +1296,7 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				code := keyword + " " + declName + ": " + variableType + " = " + value
 				if lazy {
 					keyword = "var"
-					code = "var " + declName + ": " + variableType + " = undefined as unknown as " + variableType
+					code = "var " + declName + ": " + variableType
 				}
 				indexExport := ""
 				if ctx.topLevel && name.Name != "_" {
@@ -1402,7 +1508,10 @@ func packageDeclFiles(semPkg *semanticPackage) map[types.Object]string {
 	if semPkg == nil || semPkg.source == nil {
 		return nil
 	}
-	declFiles := make(map[types.Object]string)
+	if len(semPkg.source.Syntax) <= 1 {
+		return nil
+	}
+	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
@@ -1423,6 +1532,31 @@ func packageOutputNames(semPkg *semanticPackage) map[string]string {
 	return outputNames
 }
 
+func (o *LoweringOwner) packageLazyVars(
+	semPkg *semanticPackage,
+	cache map[string]map[types.Object]bool,
+	declFiles map[types.Object]string,
+) map[types.Object]bool {
+	if semPkg == nil {
+		return nil
+	}
+	if cache == nil {
+		if declFiles == nil {
+			declFiles = packageDeclFiles(semPkg)
+		}
+		return o.lazyPackageVars(semPkg, declFiles)
+	}
+	if lazy, ok := cache[semPkg.pkgPath]; ok {
+		return lazy
+	}
+	if declFiles == nil {
+		declFiles = packageDeclFiles(semPkg)
+	}
+	lazy := o.lazyPackageVars(semPkg, declFiles)
+	cache[semPkg.pkgPath] = lazy
+	return lazy
+}
+
 func (o *LoweringOwner) lazyPackageVars(semPkg *semanticPackage, declFiles map[types.Object]string) map[types.Object]bool {
 	if semPkg == nil || semPkg.source == nil {
 		return nil
@@ -1589,7 +1723,7 @@ func (o *LoweringOwner) packageVarIsLazy(ctx lowerFileContext, obj *types.Var) b
 	if semPkg == nil {
 		return false
 	}
-	for lazyObj := range o.lazyPackageVars(semPkg, packageDeclFiles(semPkg)) {
+	for lazyObj := range o.packageLazyVars(semPkg, ctx.lazyPackageVarsByPkg, nil) {
 		if lazyObj != nil && lazyObj.Name() == obj.Name() &&
 			lazyObj.Pkg() != nil && lazyObj.Pkg().Path() == obj.Pkg().Path() {
 			return true
@@ -1606,7 +1740,7 @@ func (o *LoweringOwner) packageVarNameIsLazy(ctx lowerFileContext, pkgPath, name
 	if semPkg == nil {
 		return false
 	}
-	for lazyObj := range o.lazyPackageVars(semPkg, packageDeclFiles(semPkg)) {
+	for lazyObj := range o.packageLazyVars(semPkg, ctx.lazyPackageVarsByPkg, nil) {
 		if lazyObj != nil && lazyObj.Name() == name {
 			return true
 		}
@@ -1962,6 +2096,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 {
@@ -2006,35 +2147,218 @@ func (o *LoweringOwner) lowerGoEmbedValue(
 	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")}
 	}
-	pattern := strings.Trim(patterns[0], "`\"")
+	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 == "" ||
-		strings.Contains(pattern, "*") ||
 		path.IsAbs(pattern) ||
 		cleanPattern == "." ||
 		cleanPattern == ".." ||
 		strings.HasPrefix(cleanPattern, "../") {
-		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+		return "", false, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
 	}
-	data, err := os.ReadFile(filepath.Join(filepath.Dir(ctx.sourcePath), filepath.FromSlash(cleanPattern)))
+	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 "", []Diagnostic{{
-			Severity: DiagnosticSeverityError,
-			Code:     "goscript/lowering:embed",
-			Message:  "failed to read go:embed file",
-			Detail:   ctx.semPkg.pkgPath + ": " + err.Error(),
-		}}
+		return nil, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
 	}
-	if isStringType(typ) {
-		return strconv.Quote(string(data)), nil
+	if !info.IsDir() {
+		file, diagnostics := readGoEmbedAbsFile(ctx, pkgDir, absPath)
+		if len(diagnostics) != 0 {
+			return nil, diagnostics
+		}
+		return []goEmbedFile{file}, nil
 	}
-	if slice, ok := types.Unalias(typ).Underlying().(*types.Slice); ok && isByteType(slice.Elem()) {
-		return byteSliceLiteral(data), 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)}
+	}
+	if len(files) == 0 {
+		return nil, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "go:embed directory matched no files")}
+	}
+	return files, nil
+}
+
+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
+	}
+	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(absPath)
+	if err != nil {
+		return goEmbedFile{}, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
+	}
+	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(),
 	}
-	return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed target type")}
+}
+
+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 named.Obj().Pkg().Path() == "embed" && named.Obj().Name() == "FS"
 }
 
 func byteSliceLiteral(data []byte) string {
@@ -2202,6 +2526,7 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 		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)
@@ -2221,6 +2546,11 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 			runtimeType: o.runtimeTypeInfoExpr(field.typ),
 			doc:         field.doc,
 			tag:         field.tag,
+			pkgPath:     field.pkgPath,
+			index:       field.index,
+			offset:      field.offset,
+			anonymous:   field.embedded,
+			exported:    field.exported,
 			structValue: structValue,
 			arrayValue:  isArrayType(field.typ),
 		})
@@ -2228,14 +2558,23 @@ 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
 	for _, methodDecl := range methodDecls {
-		method, methodDiagnostics := o.lowerFuncDecl(ctx, methodDecl)
+		lowerDecl := methodDecl
+		if ctx.protobufTSAdapter && protobufTypeScriptBindingReplacesMethodName(methodDecl.Name.Name) {
+			bodyless := *methodDecl
+			bodyless.Body = nil
+			lowerDecl = &bodyless
+		}
+		method, methodDiagnostics := o.lowerFuncDecl(ctx, lowerDecl)
 		diagnostics = append(diagnostics, methodDiagnostics...)
 		if method != nil {
 			if method.name == "clone" {
@@ -2287,11 +2626,12 @@ func (o *LoweringOwner) lowerEmbeddedMethodForwarders(
 		async := o.functionAsync(ctx, method)
 		targetType := o.tsEmbeddedForwarderTargetType(ctx, field.typ)
 		lowered := loweredFunction{
-			async:       async,
-			name:        methodMemberName(method.Name()),
-			runtimeName: method.Name(),
-			result:      asyncResultType("any", async),
-			deferState:  &loweredDeferState{},
+			async:            async,
+			name:             methodMemberName(method.Name()),
+			runtimeName:      method.Name(),
+			runtimeSignature: o.runtimeMethodSignature(method, make(map[types.Type]bool)),
+			result:           asyncResultType("any", async),
+			deferState:       &loweredDeferState{},
 		}
 		args := make([]string, 0, signature.Params().Len())
 		for idx := range signature.Params().Len() {
@@ -2510,6 +2850,9 @@ func (o *LoweringOwner) lowerFuncDecl(ctx lowerFileContext, decl *ast.FuncDecl)
 		deferState:    deferState,
 		namedResults:  o.lowerNamedResults(functionCtx, signature),
 	}
+	if decl.Recv != nil {
+		lowered.runtimeSignature = o.runtimeMethodSignature(fnObj, make(map[types.Type]bool))
+	}
 	if signature.TypeParams() != nil && signature.TypeParams().Len() != 0 {
 		lowered.typeParams = signatureTypeParamNames(signature)
 		lowered.params = append(lowered.params, loweredParam{
@@ -2652,6 +2995,9 @@ func expressionUsesObject(ctx lowerFileContext, expr ast.Expr, obj types.Object)
 	if expr == nil || obj == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false
 	}
+	if ident, ok := ast.Unparen(expr).(*ast.Ident); ok {
+		return ctx.semPkg.source.TypesInfo.Uses[ident] == obj || ctx.semPkg.source.TypesInfo.Defs[ident] == obj
+	}
 	uses := false
 	ast.Inspect(expr, func(node ast.Node) bool {
 		if uses {
@@ -2731,9 +3077,22 @@ func (ctx lowerFileContext) withDeferState(deferState *loweredDeferState) lowerF
 
 func (ctx lowerFileContext) withLocalScope() lowerFileContext {
 	ctx.topLevel = false
+	ctx.functionScopedDecls = false
+	return ctx
+}
+
+func (ctx lowerFileContext) withFunctionScopedDecls() lowerFileContext {
+	ctx.functionScopedDecls = true
 	return ctx
 }
 
+func declarationKeyword(ctx lowerFileContext) string {
+	if ctx.functionScopedDecls {
+		return "var "
+	}
+	return "let "
+}
+
 func (ctx lowerFileContext) withRangeBranch(branch *loweredRangeBranch) lowerFileContext {
 	ctx.rangeBranch = branch
 	ctx.rangeBreak = true
@@ -2821,6 +3180,10 @@ func (o *LoweringOwner) lowerBlock(ctx lowerFileContext, block *ast.BlockStmt) (
 }
 
 func (o *LoweringOwner) lowerStmt(ctx lowerFileContext, stmt ast.Stmt) ([]loweredStmt, []Diagnostic) {
+	return o.lowerStmtInto(ctx, stmt, nil)
+}
+
+func (o *LoweringOwner) lowerStmtInto(ctx lowerFileContext, stmt ast.Stmt, out []loweredStmt) ([]loweredStmt, []Diagnostic) {
 	switch typed := stmt.(type) {
 	case *ast.DeclStmt:
 		decls, diagnostics := o.lowerDecl(ctx, typed.Decl)
@@ -2836,27 +3199,28 @@ func (o *LoweringOwner) lowerStmt(ctx lowerFileContext, stmt ast.Stmt) ([]lowere
 				stmts = append(stmts, loweredStmt{text: strings.TrimRight(b.String(), "\n")})
 			}
 		}
-		return stmts, diagnostics
+		return append(out, stmts...), diagnostics
 	case *ast.BlockStmt:
 		body, diagnostics := o.lowerBlock(ctx, typed)
-		return []loweredStmt{{hasBlock: true, children: body}}, diagnostics
+		return append(out, loweredStmt{hasBlock: true, children: body}), diagnostics
 	case *ast.AssignStmt:
-		return o.lowerAssignStmt(ctx, typed)
+		stmts, diagnostics := o.lowerAssignStmt(ctx, typed)
+		return append(out, stmts...), diagnostics
 	case *ast.SendStmt:
 		text, diagnostics := o.lowerSendStmt(ctx, typed)
-		return []loweredStmt{{text: text}}, diagnostics
+		return append(out, loweredStmt{text: text}), diagnostics
 	case *ast.GoStmt:
 		text, diagnostics := o.lowerGoStmt(ctx, typed)
-		return []loweredStmt{{text: text}}, diagnostics
+		return append(out, loweredStmt{text: text}), diagnostics
 	case *ast.DeferStmt:
 		text, diagnostics := o.lowerDeferStmt(ctx, typed)
-		return []loweredStmt{{text: text}}, diagnostics
+		return append(out, loweredStmt{text: text}), diagnostics
 	case *ast.ExprStmt:
 		text, diagnostics := o.lowerExpr(ctx, typed.X)
-		return []loweredStmt{{text: expressionStmtText(text)}}, diagnostics
+		return append(out, loweredStmt{text: expressionStmtText(text)}), diagnostics
 	case *ast.ReturnStmt:
 		text, diagnostics := o.lowerReturnStmt(ctx, typed)
-		return []loweredStmt{{text: text}}, diagnostics
+		return append(out, loweredStmt{text: text}), diagnostics
 	case *ast.IfStmt:
 		var diagnostics []Diagnostic
 		var init []loweredStmt
@@ -2889,39 +3253,43 @@ func (o *LoweringOwner) lowerStmt(ctx lowerFileContext, stmt ast.Stmt) ([]lowere
 		}
 		if len(init) != 0 {
 			init = append(init, stmt)
-			return append(initPrelude, loweredStmt{children: init}), diagnostics
+			initPrelude = append(initPrelude, loweredStmt{children: init})
+			return append(out, initPrelude...), diagnostics
 		}
-		return []loweredStmt{stmt}, diagnostics
+		return append(out, stmt), diagnostics
 	case *ast.ForStmt:
 		lowered, diagnostics := o.lowerForStmt(ctx, typed)
-		return []loweredStmt{lowered}, diagnostics
+		return append(out, lowered), diagnostics
 	case *ast.RangeStmt:
 		lowered, diagnostics := o.lowerRangeStmt(ctx, typed)
-		return []loweredStmt{lowered}, diagnostics
+		return append(out, lowered), diagnostics
 	case *ast.SelectStmt:
 		lowered, diagnostics := o.lowerSelectStmt(ctx, typed)
-		return []loweredStmt{{selectStmt: lowered}}, diagnostics
+		return append(out, loweredStmt{selectStmt: lowered}), diagnostics
 	case *ast.SwitchStmt:
-		return o.lowerSwitchStmt(ctx, typed)
+		stmts, diagnostics := o.lowerSwitchStmt(ctx, typed)
+		return append(out, stmts...), diagnostics
 	case *ast.TypeSwitchStmt:
-		return o.lowerTypeSwitchStmt(ctx, typed)
+		stmts, diagnostics := o.lowerTypeSwitchStmt(ctx, typed)
+		return append(out, stmts...), diagnostics
 	case *ast.LabeledStmt:
 		lowered, diagnostics := o.lowerStmt(ctx, typed.Stmt)
 		if len(lowered) != 0 {
 			label := safeIdentifier(typed.Label.Name)
 			if lowered[0].text == "" {
-				return []loweredStmt{{text: label + ":", children: lowered}}, diagnostics
+				return append(out, loweredStmt{text: label + ":", children: lowered}), diagnostics
 			}
 			if labeledTextCannotPrefix(lowered[0].text) {
-				return append([]loweredStmt{{text: label + ":;"}}, lowered...), diagnostics
+				out = append(out, loweredStmt{text: label + ":;"})
+				return append(out, lowered...), diagnostics
 			}
 			lowered[0].text = label + ": " + lowered[0].text
 		}
-		return lowered, diagnostics
+		return append(out, lowered...), diagnostics
 	case *ast.IncDecStmt:
 		if star, ok := unwrapParenExpr(typed.X).(*ast.StarExpr); ok {
 			expr, diagnostics := o.lowerPointerStorageExpr(ctx, star.X)
-			return []loweredStmt{{text: expr + typed.Tok.String()}}, diagnostics
+			return append(out, loweredStmt{text: expr + typed.Tok.String()}), diagnostics
 		}
 		if index, ok := unwrapParenExpr(typed.X).(*ast.IndexExpr); ok && isMapType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)) {
 			right := "1"
@@ -2929,7 +3297,8 @@ func (o *LoweringOwner) lowerStmt(ctx lowerFileContext, stmt ast.Stmt) ([]lowere
 			if typed.Tok == token.DEC {
 				tok = token.SUB_ASSIGN
 			}
-			return o.lowerMapIndexUpdateStmts(ctx, index, tok, right, ctx.semPkg.source.TypesInfo.TypeOf(typed.X))
+			stmts, diagnostics := o.lowerMapIndexUpdateStmts(ctx, index, tok, right, ctx.semPkg.source.TypesInfo.TypeOf(typed.X))
+			return append(out, stmts...), diagnostics
 		}
 		if setter, ok := o.packageVarSetterForAssignment(ctx, typed.X); ok {
 			expr, diagnostics := o.lowerExpr(ctx, typed.X)
@@ -2937,58 +3306,58 @@ func (o *LoweringOwner) lowerStmt(ctx lowerFileContext, stmt ast.Stmt) ([]lowere
 			if typed.Tok == token.DEC {
 				op = "-"
 			}
-			return []loweredStmt{{text: setter + "(" + expr + " " + op + " 1)"}}, diagnostics
+			return append(out, loweredStmt{text: setter + "(" + expr + " " + op + " 1)"}), diagnostics
 		}
 		expr, diagnostics := o.lowerExpr(ctx, typed.X)
-		return []loweredStmt{{text: expr + typed.Tok.String()}}, diagnostics
+		return append(out, loweredStmt{text: expr + typed.Tok.String()}), diagnostics
 	case *ast.BranchStmt:
 		if typed.Label != nil {
 			switch typed.Tok {
 			case token.BREAK, token.CONTINUE:
-				return []loweredStmt{{text: typed.Tok.String() + " " + safeIdentifier(typed.Label.Name)}}, nil
+				return append(out, loweredStmt{text: typed.Tok.String() + " " + safeIdentifier(typed.Label.Name)}), nil
 			case token.GOTO:
 				label := safeIdentifier(typed.Label.Name)
 				if ctx.gotoStateLabels[label] {
-					return []loweredStmt{
-						{text: ctx.gotoStateVar + " = " + strconv.Quote(label)},
-						{text: "continue " + ctx.gotoStateLoop},
-					}, nil
+					return append(out,
+						loweredStmt{text: ctx.gotoStateVar + " = " + strconv.Quote(label)},
+						loweredStmt{text: "continue " + ctx.gotoStateLoop},
+					), nil
 				}
 				if ctx.forwardGotos[label] {
-					return []loweredStmt{{text: "break " + label}}, nil
+					return append(out, loweredStmt{text: "break " + label}), nil
 				}
 				if ctx.gotoLabels[label] {
-					return []loweredStmt{{text: "continue " + label}}, nil
+					return append(out, loweredStmt{text: "continue " + label}), nil
 				}
-				return nil, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported goto branch to "+label)}
+				return out, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported goto branch to "+label)}
 			default:
-				return nil, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported labeled branch")}
+				return out, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported labeled branch")}
 			}
 		}
 		switch typed.Tok {
 		case token.BREAK, token.CONTINUE:
 			if typed.Tok == token.BREAK && ctx.loopLabel != "" && !ctx.switchBreak {
-				return []loweredStmt{{text: "break " + ctx.loopLabel}}, nil
+				return append(out, loweredStmt{text: "break " + ctx.loopLabel}), nil
 			}
 			if typed.Tok == token.CONTINUE && ctx.loopLabel != "" {
-				return []loweredStmt{{text: "continue " + ctx.loopLabel}}, nil
+				return append(out, loweredStmt{text: "continue " + ctx.loopLabel}), nil
 			}
 			if typed.Tok == token.BREAK && ctx.rangeBranch != nil && ctx.rangeBreak {
-				return []loweredStmt{{text: "return false"}}, nil
+				return append(out, loweredStmt{text: "return false"}), nil
 			}
 			if typed.Tok == token.CONTINUE && ctx.rangeBranch != nil && ctx.rangeContinue {
-				return []loweredStmt{{text: "return true"}}, nil
+				return append(out, loweredStmt{text: "return true"}), nil
 			}
-			return []loweredStmt{{text: typed.Tok.String()}}, nil
+			return append(out, loweredStmt{text: typed.Tok.String()}), nil
 		case token.FALLTHROUGH:
-			return []loweredStmt{{text: "fallthrough"}}, nil
+			return append(out, loweredStmt{text: "fallthrough"}), nil
 		default:
-			return nil, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported branch")}
+			return out, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported branch")}
 		}
 	case *ast.EmptyStmt:
-		return nil, nil
+		return out, nil
 	default:
-		return nil, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported statement kind")}
+		return out, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported statement kind")}
 	}
 }
 
@@ -3034,113 +3403,122 @@ 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)
+			start := len(lowered)
+			var stmtDiagnostics []Diagnostic
+			lowered, stmtDiagnostics = o.lowerStmtInto(stmtCtx, stmt, lowered)
 			diagnostics = append(diagnostics, stmtDiagnostics...)
-			if len(stmtLowered) != 0 && len(leading) != 0 {
-				stmtLowered[0].leading = append(leading, stmtLowered[0].leading...)
+			if len(lowered) > start && len(leading) != 0 {
+				lowered[start].leading = append(leading, lowered[start].leading...)
 			}
-			lowered = append(lowered, stmtLowered...)
 			ctx = nextCtx
 			if endLine := sourceLine(ctx, stmt.End()); endLine != 0 {
 				prevEndLine = endLine
@@ -3165,12 +3543,13 @@ func (o *LoweringOwner) lowerStmtListAfter(
 			}
 			continue
 		}
-		stmtLowered, stmtDiagnostics := o.lowerStmt(ctx, stmt)
+		start := len(lowered)
+		var stmtDiagnostics []Diagnostic
+		lowered, stmtDiagnostics = o.lowerStmtInto(ctx, stmt, lowered)
 		diagnostics = append(diagnostics, stmtDiagnostics...)
-		if len(stmtLowered) != 0 && len(leading) != 0 {
-			stmtLowered[0].leading = append(leading, stmtLowered[0].leading...)
+		if len(lowered) > start && len(leading) != 0 {
+			lowered[start].leading = append(leading, lowered[start].leading...)
 		}
-		lowered = append(lowered, stmtLowered...)
 		if endLine := sourceLine(ctx, stmt.End()); endLine != 0 {
 			prevEndLine = endLine
 		}
@@ -3204,7 +3583,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")
 			}
 		}
@@ -3308,7 +3687,7 @@ func (o *LoweringOwner) lowerGotoStateCluster(
 	for _, label := range cluster.labels {
 		labels[label.name] = true
 	}
-	stateCtx := ctx.withGotoState(labels, stateVar, loopLabel)
+	stateCtx := ctx.withGotoState(labels, stateVar, loopLabel).withFunctionScopedDecls()
 
 	var diagnostics []Diagnostic
 	initialState := cluster.labels[0].name
@@ -3404,7 +3783,7 @@ func (o *LoweringOwner) lowerBackwardGotoLoop(
 	var lowered []loweredStmt
 	var body []loweredStmt
 	var diagnostics []Diagnostic
-	bodyCtx := ctx.withGotoLabels(gotoLabels)
+	bodyCtx := ctx.withGotoLabels(gotoLabels).withFunctionScopedDecls()
 	if initialForwardLabel != "" {
 		skipVar := ctx.tempName("Skip")
 		init := loweredStmt{text: "let " + skipVar + " = true"}
@@ -3452,9 +3831,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)
@@ -3673,7 +4073,7 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 		}
 		prefix := ""
 		if stmt.Tok == token.DEFINE {
-			prefix = "let "
+			prefix = declarationKeyword(ctx)
 			if !allShortAssignTargetsNew(ctx, stmt.Lhs) || o.tupleDeclarationNeedsElementStatements(ctx, stmt) {
 				return o.lowerTupleReassignmentStmt(ctx, stmt, right, diagnostics)
 			}
@@ -3734,26 +4134,18 @@ 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 {
 			if ident, ok := lhs.(*ast.Ident); ok {
 				right = o.lowerDeclaredValue(ctx, ident, right)
 			}
-			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 + ")"})
+			stmts = append(stmts, loweredStmt{text: declarationKeyword(ctx) + left + o.shortDeclTypeAnnotation(ctx, lhs, stmt.Rhs[idx]) + " = " + right})
 			continue
 		}
 		if helper, ok := wideIntegerAssignHelper(targetType, stmt.Tok); ok {
@@ -3768,6 +4160,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
@@ -3810,6 +4206,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
@@ -3830,6 +4227,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 + ")"
@@ -3866,30 +4266,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
 	}
@@ -3922,7 +4323,7 @@ func (o *LoweringOwner) lowerChannelReceiveAssignStmt(
 		diagnostics = append(diagnostics, leftDiagnostics...)
 		prefix := ""
 		if stmt.Tok == token.DEFINE {
-			prefix = "let "
+			prefix = declarationKeyword(ctx)
 			left += o.shortDeclTypeAnnotation(ctx, stmt.Lhs[0], nil)
 			value = o.lowerDeclaredValue(ctx, stmt.Lhs[0], value)
 		}
@@ -3983,7 +4384,8 @@ func isIdentLikeExpr(expr ast.Expr) bool {
 func shortDeclNeedsTypeAnnotation(typ types.Type) bool {
 	switch typed := types.Unalias(typ).Underlying().(type) {
 	case *types.Pointer:
-		return namedStructType(typed.Elem()) != nil || namedNonStructType(typed.Elem()) != nil
+		_, pointsToArray := types.Unalias(typed.Elem()).Underlying().(*types.Array)
+		return pointsToArray || namedStructType(typed.Elem()) != nil || namedNonStructType(typed.Elem()) != nil
 	case *types.Map:
 		return true
 	case *types.Slice:
@@ -4025,7 +4427,7 @@ func (o *LoweringOwner) lowerTupleTargetAssignmentStmt(
 	left, diagnostics := o.lowerAssignmentTarget(ctx, lhs, declare)
 	prefix := ""
 	if declare {
-		prefix = "let "
+		prefix = declarationKeyword(ctx)
 		left += o.shortDeclTypeAnnotation(ctx, lhs, nil)
 		value = o.lowerDeclaredValue(ctx, lhs, value)
 	}
@@ -4172,7 +4574,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")
 		}
 	}
@@ -4201,12 +4603,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
 		}
@@ -4214,6 +4628,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,
@@ -5273,7 +5721,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,
@@ -5902,6 +6350,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)
@@ -6030,6 +6491,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...)
 			}
@@ -6073,6 +6537,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"))
@@ -6155,7 +6623,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)
@@ -6276,7 +6744,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
 		}
@@ -6962,6 +7430,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):
@@ -7020,13 +7490,15 @@ 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
 		}
 	}
 	if named := namedFunctionType(targetType); named != nil {
+		typeName := runtimeNamedTypeName(named)
 		return o.runtimeOwner.QualifiedHelper(RuntimeHelperNamedFunction) +
-			"(" + value + ", " + strconv.Quote(runtimeNamedTypeName(named)) + ")", diagnostics
+			"(" + value + ", " + strconv.Quote(typeName) + ", " +
+			o.runtimeFunctionTypeInfo(named.Underlying().(*types.Signature), typeName) + ")", diagnostics
 	}
 	if named := namedNonStructType(targetType); named != nil {
 		if _, ok := named.Underlying().(*types.Slice); ok {
@@ -7052,8 +7524,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
 	}
@@ -7329,6 +7801,12 @@ func (o *LoweringOwner) lowerPointerReceiverMethodCall(
 			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
@@ -8492,12 +8970,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
 	}
@@ -8562,6 +9068,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())
@@ -8715,7 +9224,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
 		}
 	}
@@ -8744,6 +9253,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 {
@@ -8789,6 +9320,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)
@@ -8837,6 +9371,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 {
@@ -8876,7 +9429,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 {
@@ -8898,7 +9452,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 {
@@ -8955,7 +9510,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 {
@@ -8972,6 +9527,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))
 }
@@ -9062,7 +9624,7 @@ func (o *LoweringOwner) shallowRuntimeTypeInfoExpr(typ types.Type) string {
 	case *types.Pointer:
 		return "{ kind: " + typeKind + ".Pointer, elemType: { kind: " + typeKind + ".Basic, name: \"unknown\" } }"
 	case *types.Struct:
-		return "{ kind: " + typeKind + ".Struct, methods: [], fields: {} }"
+		return "{ kind: " + typeKind + ".Struct, methods: [], fields: [] }"
 	case *types.Slice:
 		return "{ kind: " + typeKind + ".Slice, elemType: { kind: " + typeKind + ".Basic, name: \"unknown\" } }"
 	case *types.Array:
@@ -9078,6 +9640,11 @@ func (o *LoweringOwner) shallowRuntimeTypeInfoExpr(typ types.Type) string {
 
 func (o *LoweringOwner) runtimeStructFieldsExpr(structType *types.Struct, seen map[types.Type]bool) string {
 	fields := make([]string, 0, structType.NumFields())
+	var vars []*types.Var
+	for field := range structType.Fields() {
+		vars = append(vars, field)
+	}
+	offsets := structFieldOffsets(goScriptTypeSizes(), vars)
 	for idx := range structType.NumFields() {
 		field := structType.Field(idx)
 		fieldName := tsStructFieldName(field.Name(), idx)
@@ -9085,30 +9652,71 @@ func (o *LoweringOwner) runtimeStructFieldsExpr(structType *types.Struct, seen m
 		if fieldName != field.Name() {
 			runtimeName = field.Name()
 		}
+		pkgPath := ""
+		if !field.Exported() && field.Pkg() != nil {
+			pkgPath = field.Pkg().Path()
+		}
 		fieldInfo := runtimeStructFieldInfoExpr(
 			o.runtimeTypeInfoExprWithSeen(field.Type(), seen),
+			fieldName,
 			runtimeName,
 			structType.Tag(idx),
+			pkgPath,
+			field.Embedded(),
+			[]int{idx},
+			offsets[idx],
+			field.Exported(),
 		)
-		fields = append(fields, strconv.Quote(fieldName)+": "+fieldInfo)
+		fields = append(fields, fieldInfo)
 	}
-	return "{" + strings.Join(fields, ", ") + "}"
+	return "[" + strings.Join(fields, ", ") + "]"
 }
 
-func runtimeStructFieldInfoExpr(runtimeType string, runtimeName string, tag string) string {
-	if runtimeName == "" && tag == "" {
-		return runtimeType
+func runtimeStructFieldInfoExpr(
+	runtimeType string,
+	storageKey string,
+	runtimeName string,
+	tag string,
+	pkgPath string,
+	anonymous bool,
+	index []int,
+	offset int64,
+	exported bool,
+) string {
+	name := runtimeName
+	if name == "" {
+		name = storageKey
+	}
+	fields := []string{
+		"name: " + strconv.Quote(name),
+		"key: " + strconv.Quote(storageKey),
+		"type: " + runtimeType,
 	}
-	fields := []string{"type: " + runtimeType}
 	if runtimeName != "" {
-		fields = append(fields, "name: "+strconv.Quote(runtimeName))
+		fields = append(fields, "pkgPath: "+strconv.Quote(pkgPath))
+	} else if pkgPath != "" {
+		fields = append(fields, "pkgPath: "+strconv.Quote(pkgPath))
 	}
 	if tag != "" {
 		fields = append(fields, "tag: "+strconv.Quote(tag))
 	}
+	if anonymous {
+		fields = append(fields, "anonymous: true")
+	}
+	fields = append(fields, "index: "+runtimeStructFieldIndexExpr(index))
+	fields = append(fields, "offset: "+strconv.FormatInt(offset, 10))
+	fields = append(fields, "exported: "+strconv.FormatBool(exported))
 	return "{ " + strings.Join(fields, ", ") + " }"
 }
 
+func runtimeStructFieldIndexExpr(index []int) string {
+	values := make([]string, 0, len(index))
+	for _, value := range index {
+		values = append(values, strconv.Itoa(value))
+	}
+	return "[" + strings.Join(values, ", ") + "]"
+}
+
 func (o *LoweringOwner) runtimeFunctionTypeInfo(signature *types.Signature, name string) string {
 	return o.runtimeFunctionTypeInfoWithSeen(signature, name, make(map[types.Type]bool))
 }
@@ -9588,6 +10196,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
@@ -9738,6 +10351,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 {
@@ -9917,6 +10540,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())
@@ -10002,8 +10633,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 {
@@ -10152,6 +10782,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 {
@@ -10164,6 +10806,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: " +
@@ -10175,16 +10835,28 @@ func (o *LoweringOwner) genericTypeDescriptorExpr(ctx lowerFileContext, typ type
 	}
 	if methods := o.genericMethodDescriptors(ctx, typ); methods != "" {
 		parts = append(parts, "methods: "+methods)
+		if signatures := o.genericMethodSignatureDescriptors(typ); signatures != "" &&
+			genericTypeDescriptorNeedsMethodSignatures(typ) {
+			parts = append(parts, "methodSignatures: "+signatures)
+		}
 	}
 	return "{ " + strings.Join(parts, ", ") + " }"
 }
 
+func genericTypeDescriptorNeedsMethodSignatures(typ types.Type) bool {
+	named, _ := genericMethodSetDescriptorTarget(typ)
+	if named == nil {
+		return false
+	}
+	return namedStructType(named) == nil && !isInterfaceType(named)
+}
+
 func (o *LoweringOwner) genericMethodDescriptors(ctx lowerFileContext, typ types.Type) string {
-	named, _ := types.Unalias(typ).(*types.Named)
+	named, methodSetType := genericMethodSetDescriptorTarget(typ)
 	if named == nil {
 		return ""
 	}
-	return o.genericMethodDescriptorsForType(ctx, named, named)
+	return o.genericMethodDescriptorsForType(ctx, named, methodSetType)
 }
 
 func (o *LoweringOwner) genericMethodDescriptorsForType(
@@ -10225,6 +10897,33 @@ func (o *LoweringOwner) genericMethodDescriptorsForType(
 	return "{" + strings.Join(methods, ", ") + "}"
 }
 
+func (o *LoweringOwner) genericMethodSignatureDescriptors(typ types.Type) string {
+	_, methodSetType := genericMethodSetDescriptorTarget(typ)
+	if methodSetType == nil {
+		return ""
+	}
+	methodSet := types.NewMethodSet(methodSetType)
+	methods := make([]string, 0, methodSet.Len())
+	for method := range methodSet.Methods() {
+		fn, _ := method.Obj().(*types.Func)
+		if fn != nil {
+			methods = append(methods, o.runtimeMethodSignature(fn, make(map[types.Type]bool)))
+		}
+	}
+	if len(methods) == 0 {
+		return ""
+	}
+	return "[" + strings.Join(methods, ", ") + "]"
+}
+
+func genericMethodSetDescriptorTarget(typ types.Type) (*types.Named, types.Type) {
+	named, _ := types.Unalias(typ).(*types.Named)
+	if named == nil {
+		return namedNonStructMethodSetType(typ)
+	}
+	return named, named
+}
+
 func namedNonStructMethodSetType(typ types.Type) (*types.Named, types.Type) {
 	if named := namedNonStructType(typ); named != nil {
 		return named, named
@@ -10377,6 +11076,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: