goscript 0.1.4 → 0.2.1

package/compiler/lowering.go

@@ -24,6 +24,18 @@ 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
+	// DisplayRoot is the request root used to format source file names in diagnostics.
+	DisplayRoot 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 +51,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 +67,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 +89,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 +101,70 @@ 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,
+				options.DisplayRoot,
+			)
+			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,
+			options.DisplayRoot,
+		)
 		diagnostics = append(diagnostics, fileDiagnostics...)
 		if loweredFile != nil {
 			loweredPkg.files = append(loweredPkg.files, loweredFile)
@@ -125,6 +196,10 @@ 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,
+	displayRoot string,
 ) (*loweredFile, []Diagnostic) {
 	associatedMethods := o.methodDeclsForFileTypes(semPkg, file)
 	relevantImportFiles := map[string]bool{sourcePath: true}
@@ -146,7 +221,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 +306,21 @@ 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,
+		displayRoot:          displayRoot,
 	}
 	var diagnostics []Diagnostic
 	var packageInitCalls []string
@@ -451,6 +529,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 +554,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 +566,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 +735,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 +754,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 +782,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 +879,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 +1093,61 @@ 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
+	displayRoot          string
+}
+
+func (ctx lowerFileContext) diagnosticPosition(pos token.Pos) *DiagnosticPosition {
+	if ctx.semPkg == nil {
+		return nil
+	}
+	return diagnosticPositionFromSource(sourcePos(ctx.semPkg.source, pos), ctx.displayRoot)
+}
+
+func loweringUnsupportedAt(ctx lowerFileContext, node ast.Node, kind string, subject string, detail string) Diagnostic {
+	diag := loweringUnsupported(kind, subject, detail)
+	if node != nil {
+		diag.Position = ctx.diagnosticPosition(node.Pos())
+	}
+	return diag
+}
+
+func loweringUnsupportedPos(ctx lowerFileContext, pos token.Pos, kind string, subject string, detail string) Diagnostic {
+	diag := loweringUnsupported(kind, subject, detail)
+	diag.Position = ctx.diagnosticPosition(pos)
+	return diag
 }
 
 type tempNameOwner struct {
@@ -1102,7 +1236,7 @@ func (o *LoweringOwner) lowerDecl(ctx lowerFileContext, decl ast.Decl) ([]lowere
 			if receiver := receiverNamedTypeFromDecl(ctx, typed); receiver != nil && namedStructType(receiver) == nil {
 				fn, diagnostics := o.lowerNamedReceiverMethodDecl(ctx, typed, receiver)
 				if fn == nil {
-					return nil, []Diagnostic{loweringUnsupported("function", typed.Name.Name, "missing type information")}
+					return nil, []Diagnostic{loweringUnsupportedAt(ctx, typed, "function", typed.Name.Name, "missing type information")}
 				}
 				return []loweredDecl{{function: fn}}, diagnostics
 			}
@@ -1110,11 +1244,11 @@ func (o *LoweringOwner) lowerDecl(ctx lowerFileContext, decl ast.Decl) ([]lowere
 		}
 		fn, diagnostics := o.lowerFuncDecl(ctx, typed)
 		if fn == nil {
-			return nil, []Diagnostic{loweringUnsupported("function", typed.Name.Name, "missing type information")}
+			return nil, []Diagnostic{loweringUnsupportedAt(ctx, typed, "function", typed.Name.Name, "missing type information")}
 		}
 		return []loweredDecl{{function: fn}}, diagnostics
 	default:
-		return nil, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported declaration kind")}
+		return nil, []Diagnostic{loweringUnsupportedAt(ctx, decl, "declaration", ctx.semPkg.pkgPath, "unsupported declaration kind")}
 	}
 }
 
@@ -1162,7 +1296,7 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 					value = o.lowerValueForTarget(ctx, typed.Values[idx], obj.Type(), lowered)
 					value = o.lowerTopLevelInitializerValue(ctx, typed.Values[idx], value)
 				} else if len(embedPatterns) != 0 {
-					embedded, embedDiagnostics := o.lowerGoEmbedValue(ctx, obj.Type(), embedPatterns)
+					embedded, embedDiagnostics := o.lowerGoEmbedValue(ctx, typed.Pos(), obj.Type(), embedPatterns)
 					diagnostics = append(diagnostics, embedDiagnostics...)
 					if embedded != "" {
 						value = embedded
@@ -1171,7 +1305,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"
 				}
@@ -1253,7 +1387,7 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				}
 			}
 		default:
-			diagnostics = append(diagnostics, loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported general declaration"))
+			diagnostics = append(diagnostics, loweringUnsupportedAt(ctx, typed, "declaration", ctx.semPkg.pkgPath, "unsupported general declaration"))
 		}
 	}
 	return decls, diagnostics
@@ -1402,6 +1536,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 +1560,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 +1751,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 +1768,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
 		}
@@ -2010,16 +2172,17 @@ func goEmbedPatterns(groups ...*ast.CommentGroup) []string {
 
 func (o *LoweringOwner) lowerGoEmbedValue(
 	ctx lowerFileContext,
+	diagPos token.Pos,
 	typ types.Type,
 	patterns []string,
 ) (string, []Diagnostic) {
 	if isEmbedFSType(typ) {
-		return o.lowerGoEmbedFSValue(ctx, patterns)
+		return o.lowerGoEmbedFSValue(ctx, diagPos, patterns)
 	}
 	if len(patterns) != 1 {
-		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern list")}
+		return "", []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern list")}
 	}
-	cleanPattern, diagnostics := cleanGoEmbedFilePattern(ctx, patterns[0])
+	cleanPattern, diagnostics := cleanGoEmbedFilePattern(ctx, diagPos, patterns[0])
 	if len(diagnostics) != 0 {
 		return "", diagnostics
 	}
@@ -2033,7 +2196,7 @@ func (o *LoweringOwner) lowerGoEmbedValue(
 	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 := loweringUnsupportedPos(ctx, diagPos, "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 ""
@@ -2043,18 +2206,18 @@ func (o *LoweringOwner) lowerGoEmbedValue(
 	return "", []Diagnostic{diag}
 }
 
-func (o *LoweringOwner) lowerGoEmbedFSValue(ctx lowerFileContext, patterns []string) (string, []Diagnostic) {
+func (o *LoweringOwner) lowerGoEmbedFSValue(ctx lowerFileContext, diagPos token.Pos, patterns []string) (string, []Diagnostic) {
 	embedAlias := ctx.importPaths["embed"]
 	if embedAlias == "" {
-		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed FS import")}
+		return "", []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "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")}
+		return "", []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern list")}
 	}
 
 	filesByPath := make(map[string][]byte)
 	for _, pattern := range patterns {
-		files, diagnostics := expandGoEmbedPattern(ctx, pattern)
+		files, diagnostics := expandGoEmbedPattern(ctx, diagPos, pattern)
 		if len(diagnostics) != 0 {
 			return "", diagnostics
 		}
@@ -2080,25 +2243,25 @@ type goEmbedFile struct {
 	data []byte
 }
 
-func cleanGoEmbedFilePattern(ctx lowerFileContext, pattern string) (string, []Diagnostic) {
-	cleanPattern, _, diagnostics := cleanGoEmbedPattern(ctx, pattern)
+func cleanGoEmbedFilePattern(ctx lowerFileContext, diagPos token.Pos, pattern string) (string, []Diagnostic) {
+	cleanPattern, _, diagnostics := cleanGoEmbedPattern(ctx, diagPos, pattern)
 	if len(diagnostics) != 0 {
 		return "", diagnostics
 	}
 	if strings.Contains(cleanPattern, "*") {
-		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+		return "", []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "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 "", []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "declaration", ctx.semPkg.pkgPath, "unsupported go:embed directory target")}
 	}
 	return cleanPattern, nil
 }
 
-func cleanGoEmbedPattern(ctx lowerFileContext, pattern string) (string, bool, []Diagnostic) {
+func cleanGoEmbedPattern(ctx lowerFileContext, diagPos token.Pos, pattern string) (string, bool, []Diagnostic) {
 	pattern = strings.Trim(pattern, "`\"")
 	all := false
 	if strings.HasPrefix(pattern, "all:") {
@@ -2111,13 +2274,13 @@ func cleanGoEmbedPattern(ctx lowerFileContext, pattern string) (string, bool, []
 		cleanPattern == "." ||
 		cleanPattern == ".." ||
 		strings.HasPrefix(cleanPattern, "../") {
-		return "", false, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+		return "", false, []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
 	}
 	return cleanPattern, all, nil
 }
 
-func expandGoEmbedPattern(ctx lowerFileContext, pattern string) ([]goEmbedFile, []Diagnostic) {
-	cleanPattern, all, diagnostics := cleanGoEmbedPattern(ctx, pattern)
+func expandGoEmbedPattern(ctx lowerFileContext, diagPos token.Pos, pattern string) ([]goEmbedFile, []Diagnostic) {
+	cleanPattern, all, diagnostics := cleanGoEmbedPattern(ctx, diagPos, pattern)
 	if len(diagnostics) != 0 {
 		return nil, diagnostics
 	}
@@ -2126,17 +2289,17 @@ func expandGoEmbedPattern(ctx lowerFileContext, pattern string) ([]goEmbedFile,
 	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")}
+			return nil, []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "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")}
+			return nil, []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "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)
+		collected, diagnostics := collectGoEmbedPath(ctx, diagPos, pkgDir, path, all)
 		if len(diagnostics) != 0 {
 			return nil, diagnostics
 		}
@@ -2148,7 +2311,7 @@ func expandGoEmbedPattern(ctx lowerFileContext, pattern string) ([]goEmbedFile,
 	return files, nil
 }
 
-func collectGoEmbedPath(ctx lowerFileContext, pkgDir, absPath string, all bool) ([]goEmbedFile, []Diagnostic) {
+func collectGoEmbedPath(ctx lowerFileContext, diagPos token.Pos, pkgDir, absPath string, all bool) ([]goEmbedFile, []Diagnostic) {
 	info, err := os.Stat(absPath)
 	if err != nil {
 		return nil, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
@@ -2185,7 +2348,7 @@ func collectGoEmbedPath(ctx lowerFileContext, pkgDir, absPath string, all bool)
 		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 nil, []Diagnostic{loweringUnsupportedPos(ctx, diagPos, "declaration", ctx.semPkg.pkgPath, "go:embed directory matched no files")}
 	}
 	return files, nil
 }
@@ -2306,7 +2469,7 @@ func (o *LoweringOwner) lowerInterfaceType(ctx lowerFileContext, semType *semant
 	}
 	code = code + "\n\n" + o.runtimeOwner.QualifiedHelper(RuntimeHelperRegisterInterfaceType) +
 		"(\n\t" + strconv.Quote(runtimeNamedTypeName(semType.named)) +
-		",\n\tnull,\n\t" + o.runtimeMethodSignatures(iface) + "\n)"
+		",\n\tnull,\n\t" + o.runtimeMethodSignatures(iface) + "\n);"
 	return loweredDecl{code: code, typeIndexExport: typeIndexExport, sideEffect: true}
 }
 
@@ -2387,12 +2550,13 @@ func (o *LoweringOwner) runtimeMethodReturns(tuple *types.Tuple, seen map[types.
 
 func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticType) (*loweredStruct, []Diagnostic) {
 	lowered := &loweredStruct{
-		exported:      ctx.topLevel,
-		indexExported: ctx.topLevel && ast.IsExported(semType.name),
-		name:          safeIdentifier(semType.name),
-		typeName:      runtimeNamedTypeName(semType.named),
-		cloneMethod:   "clone",
-		fields:        make([]loweredStructField, 0, len(semType.fields)),
+		exported:             ctx.topLevel,
+		indexExported:        ctx.topLevel && ast.IsExported(semType.name),
+		protobufPreserveJSON: ctx.protobufTSAdapter && o.protobufTypeScriptAdapterPreserveJSON(ctx, semType, make(map[*types.Named]bool)),
+		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)
@@ -2412,6 +2576,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 +2598,17 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 	}
 	var diagnostics []Diagnostic
 	for _, methodDecl := range methodDecls {
-		method, methodDiagnostics := o.lowerFuncDecl(ctx, methodDecl)
+		lowerDecl := methodDecl
+		methodSourcePath := sourcePos(ctx.semPkg.source, methodDecl.Pos()).file
+		if ctx.protobufTSAdapter &&
+			methodSourcePath == ctx.sourcePath &&
+			protobufTypeScriptBindingReplacesMethodName(methodDecl.Name.Name) &&
+			!(lowered.protobufPreserveJSON && protobufTypeScriptBindingJSONMethodName(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" {
@@ -2445,6 +2624,133 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 	return lowered, diagnostics
 }
 
+func (o *LoweringOwner) protobufTypeScriptAdapterPreserveJSON(
+	ctx lowerFileContext,
+	semType *semanticType,
+	seen map[*types.Named]bool,
+) bool {
+	if semType == nil || semType.named == nil {
+		return false
+	}
+	named := semType.named.Origin()
+	if named == nil || seen[named] {
+		return false
+	}
+	seen[named] = true
+	for _, methodDecl := range o.methodDeclsForType(ctx, named) {
+		if methodDecl == nil || !protobufTypeScriptBindingJSONMethodName(methodDecl.Name.Name) {
+			continue
+		}
+		if sourcePos(ctx.semPkg.source, methodDecl.Pos()).file != ctx.sourcePath {
+			return true
+		}
+	}
+	for _, field := range semType.fields {
+		if o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, field.typ, seen) {
+			return true
+		}
+	}
+	return false
+}
+
+func (o *LoweringOwner) protobufTypeScriptAdapterTypeHasCustomJSON(
+	ctx lowerFileContext,
+	typ types.Type,
+	seen map[*types.Named]bool,
+) bool {
+	if typ == nil {
+		return false
+	}
+	if alias, ok := typ.(*types.Alias); ok {
+		if o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, alias.Rhs(), seen) {
+			return true
+		}
+		if args := alias.TypeArgs(); args != nil {
+			for t := range args.Types() {
+				if o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, t, seen) {
+					return true
+				}
+			}
+		}
+		return false
+	}
+	if named, ok := types.Unalias(typ).(*types.Named); ok {
+		if o.protobufTypeScriptAdapterNamedTypeHasCustomJSON(ctx, named) {
+			return true
+		}
+		if obj := named.Obj(); obj != nil && obj.Pkg() != nil && obj.Pkg().Path() == ctx.semPkg.pkgPath {
+			semType := ctx.model.types[named]
+			if semType == nil {
+				semType = ctx.model.types[named.Origin()]
+			}
+			if semType != nil && o.protobufTypeScriptAdapterPreserveJSON(ctx, semType, seen) {
+				return true
+			}
+		}
+		origin := named.Origin()
+		if origin != nil {
+			if seen[origin] {
+				return false
+			}
+			seen[origin] = true
+		}
+		if args := named.TypeArgs(); args != nil {
+			for t := range args.Types() {
+				if o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, t, seen) {
+					return true
+				}
+			}
+		}
+		if o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, named.Underlying(), seen) {
+			return true
+		}
+	}
+	switch typed := types.Unalias(typ).Underlying().(type) {
+	case *types.Pointer:
+		return o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, typed.Elem(), seen)
+	case *types.Slice:
+		return o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, typed.Elem(), seen)
+	case *types.Array:
+		return o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, typed.Elem(), seen)
+	case *types.Map:
+		return o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, typed.Key(), seen) ||
+			o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, typed.Elem(), seen)
+	case *types.Struct:
+		for field := range typed.Fields() {
+			if o.protobufTypeScriptAdapterTypeHasCustomJSON(ctx, field.Type(), seen) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (o *LoweringOwner) protobufTypeScriptAdapterNamedTypeHasCustomJSON(
+	ctx lowerFileContext,
+	named *types.Named,
+) bool {
+	if named == nil {
+		return false
+	}
+	methodSet := types.NewMethodSet(types.NewPointer(named))
+	for _, name := range []string{"MarshalJSON", "MarshalProtoJSON", "UnmarshalJSON", "UnmarshalProtoJSON"} {
+		selection := methodSet.Lookup(nil, name)
+		if selection == nil {
+			continue
+		}
+		method, ok := selection.Obj().(*types.Func)
+		if !ok {
+			continue
+		}
+		sourcePath := sourcePos(ctx.semPkg.source, method.Pos()).file
+		if sourcePath == "" || strings.HasSuffix(sourcePath, ".pb.go") {
+			continue
+		}
+		return true
+	}
+	return false
+}
+
 func (o *LoweringOwner) lowerEmbeddedMethodForwarders(
 	ctx lowerFileContext,
 	field semanticField,
@@ -2481,11 +2787,13 @@ 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,
+			sourcePath:       ctx.sourcePath,
+			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() {
@@ -2624,6 +2932,7 @@ func (o *LoweringOwner) lowerNamedReceiverMethodDecl(
 		exported:      ctx.topLevel,
 		indexExported: ctx.topLevel && (ast.IsExported(receiver.Obj().Name()) || ast.IsExported(decl.Name.Name)),
 		async:         async,
+		sourcePath:    sourcePos(ctx.semPkg.source, decl.Pos()).file,
 		name:          methodFunctionName(receiver, decl.Name.Name),
 		result:        asyncResultType(result, async),
 		deferState:    deferState,
@@ -2698,12 +3007,16 @@ func (o *LoweringOwner) lowerFuncDecl(ctx lowerFileContext, decl *ast.FuncDecl)
 		indexExported: ctx.topLevel && !blankName && !initFunc && (ast.IsExported(decl.Name.Name) || decl.Name.Name == "main"),
 		init:          initFunc,
 		async:         async,
+		sourcePath:    sourcePos(ctx.semPkg.source, decl.Pos()).file,
 		name:          name,
 		runtimeName:   runtimeName,
 		result:        asyncResultType(result, async),
 		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 +3159,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 +3241,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 +3344,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 +3363,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 +3417,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 +3461,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 +3470,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{loweringUnsupportedAt(ctx, typed, "statement", ctx.semPkg.pkgPath, "unsupported goto branch to "+label)}
 			default:
-				return nil, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported labeled branch")}
+				return out, []Diagnostic{loweringUnsupportedAt(ctx, typed, "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{loweringUnsupportedAt(ctx, typed, "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{loweringUnsupportedAt(ctx, typed, "statement", ctx.semPkg.pkgPath, "unsupported statement kind")}
 	}
 }
 
@@ -3213,7 +3552,7 @@ func (o *LoweringOwner) lowerElse(ctx lowerFileContext, stmt ast.Stmt) ([]lowere
 	case *ast.IfStmt:
 		return o.lowerStmt(ctx, typed)
 	default:
-		return nil, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported else statement")}
+		return nil, []Diagnostic{loweringUnsupportedAt(ctx, typed, "statement", ctx.semPkg.pkgPath, "unsupported else statement")}
 	}
 }
 
@@ -3337,12 +3676,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 +3707,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 +3851,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 +3947,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 +4237,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 +4309,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 +4487,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 +4548,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 +4591,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)
 	}
@@ -5439,7 +5781,7 @@ func (o *LoweringOwner) lowerRangeStmt(ctx lowerFileContext, stmt *ast.RangeStmt
 	if isFunctionType(rangeType) {
 		signature := rangeFunctionSignature(rangeType)
 		if signature == nil {
-			return loweredStmt{}, append(diagnostics, loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported function range signature"))
+			return loweredStmt{}, append(diagnostics, loweringUnsupportedAt(ctx, stmt, "statement", ctx.semPkg.pkgPath, "unsupported function range signature"))
 		}
 		lowered, funcDiagnostics := o.lowerRangeFuncStmt(ctx, stmt, rangeValue, signature)
 		diagnostics = append(diagnostics, funcDiagnostics...)
@@ -5519,7 +5861,7 @@ func (o *LoweringOwner) lowerRangeFuncStmt(
 ) (loweredStmt, []Diagnostic) {
 	yieldSignature, ok := types.Unalias(signature.Params().At(0).Type()).Underlying().(*types.Signature)
 	if !ok {
-		return loweredStmt{}, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported function range yield signature")}
+		return loweredStmt{}, []Diagnostic{loweringUnsupportedAt(ctx, stmt, "statement", ctx.semPkg.pkgPath, "unsupported function range yield signature")}
 	}
 	keyName := rangeKeyName(stmt.Key)
 	valueName := rangeKeyName(stmt.Value)
@@ -5602,7 +5944,7 @@ func (o *LoweringOwner) lowerSelectStmt(ctx lowerFileContext, stmt *ast.SelectSt
 	for _, raw := range stmt.Body.List {
 		clause, ok := raw.(*ast.CommClause)
 		if !ok {
-			diagnostics = append(diagnostics, loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported select clause"))
+			diagnostics = append(diagnostics, loweringUnsupportedAt(ctx, raw, "statement", ctx.semPkg.pkgPath, "unsupported select clause"))
 			continue
 		}
 		switch comm := clause.Comm.(type) {
@@ -5655,7 +5997,7 @@ func (o *LoweringOwner) lowerSelectStmt(ctx lowerFileContext, stmt *ast.SelectSt
 			})
 			caseID++
 		default:
-			diagnostics = append(diagnostics, loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported select communication"))
+			diagnostics = append(diagnostics, loweringUnsupportedAt(ctx, comm, "statement", ctx.semPkg.pkgPath, "unsupported select communication"))
 		}
 	}
 	lowered.returns = selectCasesReturn(lowered.cases)
@@ -5759,7 +6101,7 @@ func (o *LoweringOwner) lowerSelectReceiveComm(
 	}
 	receive, ok := receiveExpr.(*ast.UnaryExpr)
 	if !ok || receive.Op != token.ARROW {
-		return "null", nil, []Diagnostic{loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported select receive")}
+		return "null", nil, []Diagnostic{loweringUnsupportedAt(ctx, receiveExpr, "statement", ctx.semPkg.pkgPath, "unsupported select receive")}
 	}
 	channel, diagnostics := o.lowerExpr(ctx, receive.X)
 	if assign == nil {
@@ -5817,7 +6159,7 @@ func (o *LoweringOwner) lowerSwitchStmt(ctx lowerFileContext, stmt *ast.SwitchSt
 	for _, raw := range stmt.Body.List {
 		clause, ok := raw.(*ast.CaseClause)
 		if !ok {
-			diagnostics = append(diagnostics, loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported switch clause"))
+			diagnostics = append(diagnostics, loweringUnsupportedAt(ctx, raw, "statement", ctx.semPkg.pkgPath, "unsupported switch clause"))
 			continue
 		}
 		bodyStmts := clause.Body
@@ -5912,7 +6254,7 @@ func (o *LoweringOwner) lowerTypeSwitchStmt(ctx lowerFileContext, stmt *ast.Type
 	valueExpr, varName, varRef, assignDiagnostics := o.lowerTypeSwitchAssign(ctx, stmt.Assign)
 	diagnostics = append(diagnostics, assignDiagnostics...)
 	if valueExpr == "" {
-		return lowered, append(diagnostics, loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported type switch assignment"))
+		return lowered, append(diagnostics, loweringUnsupportedAt(ctx, stmt.Assign, "statement", ctx.semPkg.pkgPath, "unsupported type switch assignment"))
 	}
 
 	switchIR := &loweredTypeSwitch{
@@ -5923,7 +6265,7 @@ func (o *LoweringOwner) lowerTypeSwitchStmt(ctx lowerFileContext, stmt *ast.Type
 	for _, clauseStmt := range stmt.Body.List {
 		clause, ok := clauseStmt.(*ast.CaseClause)
 		if !ok {
-			diagnostics = append(diagnostics, loweringUnsupported("statement", ctx.semPkg.pkgPath, "unsupported type switch clause"))
+			diagnostics = append(diagnostics, loweringUnsupportedAt(ctx, clauseStmt, "statement", ctx.semPkg.pkgPath, "unsupported type switch clause"))
 			continue
 		}
 		body, bodyDiagnostics := o.lowerStmtList(ctx.withoutRangeBreak().withSwitchBreak(), clause.Body)
@@ -6359,13 +6701,21 @@ 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
+			if bits, ok := unsignedIntegerBits(ctx.semPkg.source.TypesInfo.TypeOf(typed)); ok {
+				if bits <= 32 {
+					return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
+						"(~" + value + ", " + strconv.Itoa(bits) + ")", diagnostics
+				}
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Xor) +
+					"(" + value + ", -1n)", diagnostics
+			}
+			if bits, ok := signedIntegerBits(ctx.semPkg.source.TypesInfo.TypeOf(typed)); ok && bits > 32 {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperInt64Xor) +
+					"(" + value + ", -1n)", diagnostics
 			}
 			return "~" + value, diagnostics
 		}
-		return value, append(diagnostics, loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported unary operator"))
+		return value, append(diagnostics, loweringUnsupportedAt(ctx, typed, "expression", ctx.semPkg.pkgPath, "unsupported unary operator"))
 	case *ast.StarExpr:
 		return o.lowerPointerValueExpr(ctx, typed.X)
 	case *ast.ParenExpr:
@@ -6389,7 +6739,7 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 	case *ast.IndexListExpr:
 		return o.lowerExpr(ctx, typed.X)
 	default:
-		return "undefined", []Diagnostic{loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported expression kind")}
+		return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, typed, "expression", ctx.semPkg.pkgPath, "unsupported expression kind")}
 	}
 }
 
@@ -6755,7 +7105,7 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 				return o.runtimeOwner.QualifiedHelper(RuntimeHelperRecover) + "(" + strings.Join(args, ", ") + ")", diagnostics
 			case "close":
 				if len(args) != 1 {
-					return "undefined", append(diagnostics, loweringUnsupported("call", ctx.semPkg.pkgPath, "close requires one argument"))
+					return "undefined", append(diagnostics, loweringUnsupportedAt(ctx, expr, "call", ctx.semPkg.pkgPath, "close requires one argument"))
 				}
 				return args[0] + "!.close()", diagnostics
 			}
@@ -6852,9 +7202,9 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 			call := o.lowerCallableExpr(ctx, expr.Fun, callee) + "(" + strings.Join(args, ", ") + ")"
 			return o.awaitCallIfNeeded(ctx, expr.Fun, call), append(diagnostics, calleeDiagnostics...)
 		}
-		return "undefined", append(diagnostics, loweringUnsupported("call", ctx.semPkg.pkgPath, fmt.Sprintf("unsupported call target %T", expr.Fun)))
+		return "undefined", append(diagnostics, loweringUnsupportedAt(ctx, expr.Fun, "call", ctx.semPkg.pkgPath, fmt.Sprintf("unsupported call target %T", expr.Fun)))
 	}
-	return "undefined", append(diagnostics, loweringUnsupported("call", ctx.semPkg.pkgPath, fmt.Sprintf("unsupported call target %T", expr.Fun)))
+	return "undefined", append(diagnostics, loweringUnsupportedAt(ctx, expr.Fun, "call", ctx.semPkg.pkgPath, fmt.Sprintf("unsupported call target %T", expr.Fun)))
 }
 
 func (o *LoweringOwner) lowerCallableExpr(ctx lowerFileContext, expr ast.Expr, callee string) string {
@@ -7143,11 +7493,11 @@ func unsafePackageFunction(ctx lowerFileContext, expr ast.Expr, name string) boo
 
 func (o *LoweringOwner) lowerMakeExpr(ctx lowerFileContext, expr *ast.CallExpr) (string, []Diagnostic) {
 	if len(expr.Args) < 1 {
-		return "undefined", []Diagnostic{loweringUnsupported("call", ctx.semPkg.pkgPath, "make requires a type argument")}
+		return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, expr, "call", ctx.semPkg.pkgPath, "make requires a type argument")}
 	}
 	targetType := typeFromExpr(ctx, expr.Args[0])
 	if targetType == nil {
-		return "undefined", []Diagnostic{loweringUnsupported("call", ctx.semPkg.pkgPath, "make requires a type expression")}
+		return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, expr.Args[0], "call", ctx.semPkg.pkgPath, "make requires a type expression")}
 	}
 	switch typed := types.Unalias(targetType).Underlying().(type) {
 	case *types.Slice:
@@ -7200,13 +7550,13 @@ func (o *LoweringOwner) lowerMakeExpr(ctx lowerFileContext, expr *ast.CallExpr)
 			"<" + o.tsTypeFor(ctx, typed.Elem()) + ">(" + capacity + ", " +
 			o.lowerZeroValueExprFor(ctx, typed.Elem()) + ", " + strconv.Quote(channelDirectionString(typed.Dir())) + ")", diagnostics
 	default:
-		return "undefined", []Diagnostic{loweringUnsupported("call", ctx.semPkg.pkgPath, "unsupported make type")}
+		return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, expr.Args[0], "call", ctx.semPkg.pkgPath, "unsupported make type")}
 	}
 }
 
 func (o *LoweringOwner) lowerNewExpr(ctx lowerFileContext, expr *ast.CallExpr) (string, []Diagnostic) {
 	if len(expr.Args) != 1 {
-		return "undefined", []Diagnostic{loweringUnsupported("call", ctx.semPkg.pkgPath, "new requires one type argument")}
+		return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, expr, "call", ctx.semPkg.pkgPath, "new requires one type argument")}
 	}
 	typ := typeFromExpr(ctx, expr.Args[0])
 	if named := namedStructType(typ); named != nil {
@@ -7222,7 +7572,7 @@ func (o *LoweringOwner) lowerConversionExpr(
 	targetType types.Type,
 ) (string, []Diagnostic) {
 	if len(expr.Args) != 1 {
-		return "undefined", []Diagnostic{loweringUnsupported("call", ctx.semPkg.pkgPath, "unsupported conversion arity")}
+		return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, expr, "call", ctx.semPkg.pkgPath, "unsupported conversion arity")}
 	}
 	value, diagnostics := o.lowerExpr(ctx, expr.Args[0])
 	sourceType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Args[0])
@@ -7317,8 +7667,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 {
@@ -8191,7 +8543,7 @@ func (o *LoweringOwner) lowerAddressExpr(ctx lowerFileContext, expr ast.Expr) (s
 	case *ast.IndexExpr:
 		return o.lowerIndexAddressExpr(ctx, typed)
 	default:
-		return "undefined", []Diagnostic{loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported address expression")}
+		return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, typed, "expression", ctx.semPkg.pkgPath, "unsupported address expression")}
 	}
 }
 
@@ -8250,7 +8602,7 @@ func (o *LoweringOwner) lowerIndexAddressExpr(ctx lowerFileContext, expr *ast.In
 	diagnostics := append(targetDiagnostics, indexDiagnostics...)
 	targetType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
 	if isStringType(targetType) || isMapType(targetType) {
-		return "undefined", append(diagnostics, loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported address expression"))
+		return "undefined", append(diagnostics, loweringUnsupportedAt(ctx, expr, "expression", ctx.semPkg.pkgPath, "unsupported address expression"))
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexRef) + "(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + index + ")", diagnostics
 }
@@ -8278,7 +8630,7 @@ func (o *LoweringOwner) lowerUnsafePointerIntegerExpr(
 	if !ok || len(call.Args) != 1 || !isUnsafePointerType(typeFromExpr(ctx, call.Fun)) {
 		return "", nil, false
 	}
-	return o.lowerIndexAddressIntegerExpr(ctx, call.Args[0])
+	return o.lowerIndexByteAddressIntegerExpr(ctx, call.Args[0])
 }
 
 func (o *LoweringOwner) lowerIndexAddressIntegerExpr(
@@ -8304,6 +8656,30 @@ func (o *LoweringOwner) lowerIndexAddressIntegerExpr(
 		"(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + index + ")", diagnostics, true
 }
 
+func (o *LoweringOwner) lowerIndexByteAddressIntegerExpr(
+	ctx lowerFileContext,
+	expr ast.Expr,
+) (string, []Diagnostic, bool) {
+	address, ok := unwrapParenExpr(expr).(*ast.UnaryExpr)
+	if !ok || address.Op != token.AND {
+		return "", nil, false
+	}
+	indexExpr, ok := unwrapParenExpr(address.X).(*ast.IndexExpr)
+	if !ok {
+		return "", nil, false
+	}
+	target, targetDiagnostics := o.lowerExpr(ctx, indexExpr.X)
+	index, indexDiagnostics := o.lowerExpr(ctx, indexExpr.Index)
+	diagnostics := append(targetDiagnostics, indexDiagnostics...)
+	targetType := ctx.semPkg.source.TypesInfo.TypeOf(indexExpr.X)
+	if isStringType(targetType) || isMapType(targetType) {
+		return "", diagnostics, false
+	}
+	elementSize := goScriptElementByteSize(ctx, indexElementType(targetType))
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexByteAddress) +
+		"(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + index + ", " + strconv.FormatInt(elementSize, 10) + ")", diagnostics, true
+}
+
 func (o *LoweringOwner) lowerPointerValueExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
 	if value, diagnostics, ok := o.lowerUnsafeStringPointerValue(ctx, expr); ok {
 		return value, diagnostics
@@ -8311,6 +8687,12 @@ func (o *LoweringOwner) lowerPointerValueExpr(ctx lowerFileContext, expr ast.Exp
 	if value, diagnostics, ok := o.lowerUnsafeStringByteSlicePointerValue(ctx, expr); ok {
 		return value, diagnostics
 	}
+	if ref, diagnostics, ok := o.lowerUnsafeArrayPointerRefExpr(ctx, expr); ok {
+		return ref + ".value", diagnostics
+	}
+	if ref, diagnostics, ok := o.lowerUnsafePointerRefExpr(ctx, expr); ok {
+		return ref + ".value", diagnostics
+	}
 	base, diagnostics := o.lowerExpr(ctx, expr)
 	typeArg := ""
 	if pointer, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(expr)).Underlying().(*types.Pointer); ok {
@@ -8442,8 +8824,13 @@ func (o *LoweringOwner) lowerUnsafeArrayPointerConversion(
 		return "", nil, false
 	}
 	ref, diagnostics := o.lowerAddressExpr(ctx, index)
+	sourceElementSize := goScriptElementByteSize(ctx, indexElementType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)))
+	targetElementSize := goScriptElementByteSize(ctx, array.Elem())
 	helper := o.runtimeOwner.QualifiedHelper(RuntimeHelperArrayPointerFromIndexRef) +
-		"<" + o.tsTypeFor(ctx, array.Elem()) + ">(" + ref + ", " + strconv.FormatInt(array.Len(), 10) + ")"
+		"<" + o.tsTypeFor(ctx, array.Elem()) + ">(" + ref + ", " +
+		strconv.FormatInt(array.Len(), 10) + ", " +
+		strconv.FormatInt(sourceElementSize, 10) + ", " +
+		strconv.FormatInt(targetElementSize, 10) + ")"
 	return "(" + helper + " as unknown as " + o.tsTypeFor(ctx, targetType) + ")", diagnostics, true
 }
 
@@ -8537,6 +8924,12 @@ func sameLoweredSourceExpr(ctx lowerFileContext, left ast.Expr, right ast.Expr)
 }
 
 func (o *LoweringOwner) lowerPointerStorageExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
+	if ref, diagnostics, ok := o.lowerUnsafeArrayPointerRefExpr(ctx, expr); ok {
+		return ref + ".value", diagnostics
+	}
+	if ref, diagnostics, ok := o.lowerUnsafePointerRefExpr(ctx, expr); ok {
+		return ref + ".value", diagnostics
+	}
 	if ref, diagnostics, ok := o.lowerUnsafePointerStorageExpr(ctx, expr); ok {
 		return ref, diagnostics
 	}
@@ -8544,6 +8937,42 @@ func (o *LoweringOwner) lowerPointerStorageExpr(ctx lowerFileContext, expr ast.E
 	return base + "!.value", diagnostics
 }
 
+func (o *LoweringOwner) lowerUnsafeArrayPointerRefExpr(
+	ctx lowerFileContext,
+	expr ast.Expr,
+) (string, []Diagnostic, bool) {
+	call, ok := unwrapParenExpr(expr).(*ast.CallExpr)
+	if !ok || len(call.Args) != 1 {
+		return "", nil, false
+	}
+	targetType := typeFromExpr(ctx, call.Fun)
+	if targetType == nil {
+		return "", nil, false
+	}
+	return o.lowerUnsafeArrayPointerConversion(ctx, targetType, call.Args[0])
+}
+
+func (o *LoweringOwner) lowerUnsafePointerRefExpr(
+	ctx lowerFileContext,
+	expr ast.Expr,
+) (string, []Diagnostic, bool) {
+	call, ok := unwrapParenExpr(expr).(*ast.CallExpr)
+	if !ok || len(call.Args) != 1 {
+		return "", nil, false
+	}
+	targetType := typeFromExpr(ctx, call.Fun)
+	if targetType == nil {
+		return "", nil, false
+	}
+	pointer, _ := types.Unalias(targetType).Underlying().(*types.Pointer)
+	if pointer == nil || !isUnsafePointerType(ctx.semPkg.source.TypesInfo.TypeOf(call.Args[0])) {
+		return "", nil, false
+	}
+	value, diagnostics := o.lowerExpr(ctx, call.Args[0])
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperUnsafePointerRef) +
+		"<" + o.tsTypeFor(ctx, pointer.Elem()) + ">(" + value + ")", diagnostics, true
+}
+
 func (o *LoweringOwner) lowerUnsafePointerStorageExpr(
 	ctx lowerFileContext,
 	expr ast.Expr,
@@ -8713,15 +9142,11 @@ func (o *LoweringOwner) lowerCompositeLit(
 	if mapType, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(lit)).Underlying().(*types.Map); ok {
 		return o.lowerMapCompositeLit(ctx, lit, mapType)
 	}
-	position := sourcePos(ctx.semPkg.source, lit.Pos())
 	detail := "unsupported composite literal"
-	if position.file != "" {
-		detail += " at " + filepath.Base(position.file) + ":" + strconv.Itoa(position.line)
-	}
 	if typ := ctx.semPkg.source.TypesInfo.TypeOf(lit); typ != nil {
 		detail += " of type " + typ.String()
 	}
-	return "undefined", []Diagnostic{loweringUnsupported("expression", ctx.semPkg.pkgPath, detail)}
+	return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, lit, "expression", ctx.semPkg.pkgPath, detail)}
 }
 
 func (o *LoweringOwner) lowerStructCompositeLit(
@@ -8756,7 +9181,7 @@ func (o *LoweringOwner) lowerStructCompositeLit(
 			fieldType = field.Type()
 		}
 		if fieldName == "" {
-			diagnostics = append(diagnostics, loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported struct literal field"))
+			diagnostics = append(diagnostics, loweringUnsupportedAt(ctx, elt, "expression", ctx.semPkg.pkgPath, "unsupported struct literal field"))
 			continue
 		}
 		value, valueDiagnostics := o.lowerExpr(ctx, valueExpr)
@@ -8867,7 +9292,7 @@ func (o *LoweringOwner) lowerAnonymousStructCompositeLit(
 			fieldType = field.Type()
 		}
 		if fieldName == "" {
-			diagnostics = append(diagnostics, loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported anonymous struct literal field"))
+			diagnostics = append(diagnostics, loweringUnsupportedAt(ctx, elt, "expression", ctx.semPkg.pkgPath, "unsupported anonymous struct literal field"))
 			continue
 		}
 		value, valueDiagnostics := o.lowerExpr(ctx, valueExpr)
@@ -8976,7 +9401,7 @@ func (o *LoweringOwner) lowerMapCompositeLit(
 	for _, elt := range lit.Elts {
 		keyed, ok := elt.(*ast.KeyValueExpr)
 		if !ok {
-			diagnostics = append(diagnostics, loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported map literal entry"))
+			diagnostics = append(diagnostics, loweringUnsupportedAt(ctx, elt, "expression", ctx.semPkg.pkgPath, "unsupported map literal entry"))
 			continue
 		}
 		key, keyDiagnostics := o.lowerExpr(ctx, keyed.Key)
@@ -9444,7 +9869,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 +9885,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 +9897,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))
 }
@@ -10172,6 +10643,42 @@ func isMapType(typ types.Type) bool {
 	return ok
 }
 
+func indexElementType(typ types.Type) types.Type {
+	if pointer, ok := types.Unalias(typ).Underlying().(*types.Pointer); ok {
+		typ = pointer.Elem()
+	}
+	switch typed := types.Unalias(typ).Underlying().(type) {
+	case *types.Slice:
+		return typed.Elem()
+	case *types.Array:
+		return typed.Elem()
+	default:
+		return nil
+	}
+}
+
+func goScriptElementByteSize(ctx lowerFileContext, typ types.Type) int64 {
+	if typ == nil {
+		return 1
+	}
+	if sizes := ctx.semPkg.source.TypesSizes; sizes != nil {
+		if size := sizes.Sizeof(typ); size > 0 {
+			return size
+		}
+	}
+	if bits, ok := integerBits(typ); ok && bits > 0 {
+		return int64((bits + 7) / 8)
+	}
+	if isFloatType(typ) {
+		basic, _ := types.Unalias(typ).Underlying().(*types.Basic)
+		if basic != nil && basic.Kind() == types.Float32 {
+			return 4
+		}
+		return 8
+	}
+	return 1
+}
+
 func isChannelType(typ types.Type) bool {
 	if typ == nil {
 		return false
@@ -10245,6 +10752,9 @@ func isFloatType(typ types.Type) bool {
 }
 
 func unsignedIntegerBits(typ types.Type) (int, bool) {
+	if typ == nil {
+		return 0, false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	if !ok || basic.Info()&types.IsUnsigned == 0 {
 		return 0, false
@@ -10262,6 +10772,9 @@ func unsignedIntegerBits(typ types.Type) (int, bool) {
 }
 
 func signedIntegerBits(typ types.Type) (int, bool) {
+	if typ == nil {
+		return 0, false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	if !ok || basic.Info()&types.IsInteger == 0 || basic.Info()&types.IsUnsigned != 0 {
 		return 0, false
@@ -10609,16 +11122,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 +11184,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