goscript 0.1.4 → 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 {
@@ -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"
 				}
@@ -1402,6 +1508,9 @@ func packageDeclFiles(semPkg *semanticPackage) map[types.Object]string {
 	if semPkg == nil || semPkg.source == nil {
 		return nil
 	}
+	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 != "" {
@@ -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
 		}
@@ -2412,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),
 		})
@@ -2429,7 +2568,13 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 	}
 	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" {
@@ -2481,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() {
@@ -2704,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{
@@ -2846,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 {
@@ -2925,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
@@ -3015,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)
@@ -3030,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
@@ -3083,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"
@@ -3123,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)
@@ -3131,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")}
 	}
 }
 
@@ -3337,12 +3512,13 @@ func (o *LoweringOwner) lowerStmtListAfter(
 			}
 		}
 		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
@@ -3367,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
 		}
@@ -3510,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
@@ -3606,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"}
@@ -3896,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)
 			}
@@ -3968,7 +4145,7 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 			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})
+			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 {
@@ -4146,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)
 		}
@@ -4207,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:
@@ -4249,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)
 	}
@@ -7317,8 +7495,10 @@ func (o *LoweringOwner) lowerConversionExpr(
 		}
 	}
 	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 {
@@ -9444,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:
@@ -9460,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)
@@ -9467,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))
 }
@@ -10609,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(
@@ -10659,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