goscript 0.2.2 → 0.2.3

package/compiler/gotest/testdata/browserapi/browserapi_test.go

@@ -3,6 +3,8 @@
 package browserapi
 
 import (
+	"fmt"
+	"os"
 	"syscall/js"
 	"testing"
 )
@@ -18,3 +20,37 @@ func TestBrowserAPI(t *testing.T) {
 		t.Fatalf("div id = %q", got)
 	}
 }
+
+func TestBrowserStderrUsesConsoleLog(t *testing.T) {
+	console := js.Global().Get("console")
+	if console.IsUndefined() || console.IsNull() {
+		t.Fatal("missing browser console")
+	}
+
+	originalLog := console.Get("log")
+	originalError := console.Get("error")
+	calls := make([]string, 0, 1)
+	logFn := js.FuncOf(func(this js.Value, args []js.Value) any {
+		calls = append(calls, "log:"+args[0].String())
+		return nil
+	})
+	errorFn := js.FuncOf(func(this js.Value, args []js.Value) any {
+		calls = append(calls, "error:"+args[0].String())
+		return nil
+	})
+	defer logFn.Release()
+	defer errorFn.Release()
+	defer console.Set("log", originalLog)
+	defer console.Set("error", originalError)
+
+	console.Set("log", logFn)
+	console.Set("error", errorFn)
+
+	if _, err := fmt.Fprintln(os.Stderr, "goscript stderr proof"); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(calls) != 1 || calls[0] != "log:goscript stderr proof" {
+		t.Fatalf("stderr console calls = %#v, want console.log", calls)
+	}
+}

package/compiler/lowering.go

@@ -16,6 +16,8 @@ import (
 	"strconv"
 	"strings"
 	"unicode/utf8"
+
+	"golang.org/x/tools/go/packages"
 )
 
 // LoweringOwner owns conversion from the semantic model to compiler IR.
@@ -2506,6 +2508,14 @@ func (o *LoweringOwner) runtimeMethodSignaturesWithSeen(iface *types.Interface,
 	return "[" + strings.Join(methods, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeMethodAssertSignaturesWithSeen(ctx lowerFileContext, iface *types.Interface, seen map[types.Type]bool) string {
+	methods := make([]string, 0, iface.NumMethods())
+	for method := range iface.Methods() {
+		methods = append(methods, o.runtimeMethodAssertSignature(ctx, method, seen))
+	}
+	return "[" + strings.Join(methods, ", ") + "]"
+}
+
 func (o *LoweringOwner) runtimeMethodSignature(method *types.Func, seen map[types.Type]bool) string {
 	signature, _ := method.Type().(*types.Signature)
 	if signature == nil {
@@ -2516,6 +2526,16 @@ func (o *LoweringOwner) runtimeMethodSignature(method *types.Func, seen map[type
 		", returns: " + o.runtimeMethodReturns(signature.Results(), seen) + " }"
 }
 
+func (o *LoweringOwner) runtimeMethodAssertSignature(ctx lowerFileContext, method *types.Func, seen map[types.Type]bool) string {
+	signature, _ := method.Type().(*types.Signature)
+	if signature == nil {
+		return "{ name: " + strconv.Quote(method.Name()) + ", args: [], returns: [] }"
+	}
+	return "{ name: " + strconv.Quote(method.Name()) +
+		", args: " + o.runtimeMethodAssertArgs(ctx, signature.Params(), seen) +
+		", returns: " + o.runtimeMethodAssertReturns(ctx, signature.Results(), seen) + " }"
+}
+
 func (o *LoweringOwner) runtimeMethodArgs(tuple *types.Tuple, seen map[types.Type]bool) string {
 	if tuple == nil || tuple.Len() == 0 {
 		return "[]"
@@ -2532,6 +2552,22 @@ func (o *LoweringOwner) runtimeMethodArgs(tuple *types.Tuple, seen map[types.Typ
 	return "[" + strings.Join(args, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeMethodAssertArgs(ctx lowerFileContext, tuple *types.Tuple, seen map[types.Type]bool) string {
+	if tuple == nil || tuple.Len() == 0 {
+		return "[]"
+	}
+	args := make([]string, 0, tuple.Len())
+	for idx := range tuple.Len() {
+		param := tuple.At(idx)
+		name := param.Name()
+		if name == "" {
+			name = "_p" + strconv.Itoa(idx)
+		}
+		args = append(args, "{ name: "+strconv.Quote(name)+", type: "+o.runtimeTypeAssertInfoExprWithSeen(ctx, param.Type(), seen)+" }")
+	}
+	return "[" + strings.Join(args, ", ") + "]"
+}
+
 func (o *LoweringOwner) runtimeMethodReturns(tuple *types.Tuple, seen map[types.Type]bool) string {
 	if tuple == nil || tuple.Len() == 0 {
 		return "[]"
@@ -2548,6 +2584,22 @@ func (o *LoweringOwner) runtimeMethodReturns(tuple *types.Tuple, seen map[types.
 	return "[" + strings.Join(results, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeMethodAssertReturns(ctx lowerFileContext, tuple *types.Tuple, seen map[types.Type]bool) string {
+	if tuple == nil || tuple.Len() == 0 {
+		return "[]"
+	}
+	results := make([]string, 0, tuple.Len())
+	for idx := range tuple.Len() {
+		result := tuple.At(idx)
+		name := result.Name()
+		if name == "" {
+			name = "_r" + strconv.Itoa(idx)
+		}
+		results = append(results, "{ name: "+strconv.Quote(name)+", type: "+o.runtimeTypeAssertInfoExprWithSeen(ctx, result.Type(), seen)+" }")
+	}
+	return "[" + strings.Join(results, ", ") + "]"
+}
+
 func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticType) (*loweredStruct, []Diagnostic) {
 	lowered := &loweredStruct{
 		exported:             ctx.topLevel,
@@ -6799,7 +6851,7 @@ func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (st
 	deferState := &loweredDeferState{}
 	bodyCtx := ctx.withSignature(signature).withAsyncFunction(false).withDeferState(deferState).withoutRangeBranch()
 	asyncCompatibleParams := funcLiteralNeedsAsyncFunctionParamCalls(signature)
-	if asyncCompatibleParams || funcLiteralUsesFunctionIdentifierCall(ctx, lit) {
+	if asyncCompatibleParams || funcLiteralUsesAwaitableCall(ctx, lit) {
 		bodyCtx = bodyCtx.withAsyncFunction(true)
 	}
 	var params []loweredParam
@@ -6816,7 +6868,7 @@ func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (st
 	renderNamedResults(&rendered, o.lowerNamedResults(ctx, signature), 1)
 	renderDeferStack(&rendered, deferState, 1)
 	renderStmts(&rendered, body, 1)
-	async := stmtsContainAwait(body) || deferState.async
+	async := bodyCtx.asyncFunction || stmtsContainAwait(body) || deferState.async
 	prefix := ""
 	if async {
 		prefix = "async "
@@ -6839,7 +6891,7 @@ func renderLoweredParams(params []loweredParam) string {
 	return strings.Join(rendered, ", ")
 }
 
-func funcLiteralUsesFunctionIdentifierCall(ctx lowerFileContext, lit *ast.FuncLit) bool {
+func funcLiteralUsesAwaitableCall(ctx lowerFileContext, lit *ast.FuncLit) bool {
 	if lit == nil || lit.Body == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false
 	}
@@ -6855,7 +6907,8 @@ func funcLiteralUsesFunctionIdentifierCall(ctx lowerFileContext, lit *ast.FuncLi
 		if !ok {
 			return true
 		}
-		uses = callUsesFunctionIdentifier(ctx.semPkg.source, call.Fun)
+		uses = callUsesFunctionIdentifier(ctx.semPkg.source, call.Fun) ||
+			callUsesInterfaceMethod(ctx.semPkg.source, call.Fun)
 		return !uses
 	})
 	return uses
@@ -7057,15 +7110,16 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 						}
 					}
 				}
+				appendHelper := o.runtimeOwner.QualifiedHelper(RuntimeHelperAppend)
 				if expr.Ellipsis != token.NoPos && len(args) > 1 {
 					last := len(args) - 1
 					spread := args[last]
 					if isStringType(ctx.semPkg.source.TypesInfo.TypeOf(expr.Args[len(expr.Args)-1])) {
 						spread = o.runtimeOwner.QualifiedHelper(RuntimeHelperStringToBytes) + "(" + spread + ")"
 					}
-					args[last] = "...(" + spread + " ?? [])"
+					args[last] = spread
+					appendHelper = o.runtimeOwner.QualifiedHelper(RuntimeHelperAppendSlice)
 				}
-				appendHelper := o.runtimeOwner.QualifiedHelper(RuntimeHelperAppend)
 				if len(args) > 0 && args[0] == "null" {
 					if slice, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(expr)).Underlying().(*types.Slice); ok {
 						appendHelper += "<" + o.tsTypeFor(ctx, slice.Elem()) + ">"
@@ -7975,6 +8029,13 @@ func (o *LoweringOwner) lowerPointerReceiverMethodCall(
 			methodMemberName(selector.Sel.Name) + "(" + strings.Join(args, ", ") + ")"
 		return call, diagnostics, true
 	}
+	if receiver != nil && receiver.Obj() != nil && receiver.Obj().Pkg() != nil {
+		pkgPath := receiver.Obj().Pkg().Path()
+		if ctx.importPaths[pkgPath] == "" && !o.hasGeneratedImportPackage(ctx.model, pkgPath) {
+			call := receiverExpr + "." + methodMemberName(selector.Sel.Name) + "(" + strings.Join(args, ", ") + ")"
+			return call, diagnostics, true
+		}
+	}
 	if crossPackageUnexportedNamedType(ctx, receiver) {
 		call := o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
 			"<any>(" + receiverExpr + ")." + methodMemberName(selector.Sel.Name) +
@@ -9786,12 +9847,61 @@ func (o *LoweringOwner) runtimeTypeInfoExpr(typ types.Type) string {
 }
 
 func (o *LoweringOwner) runtimeTypeAssertInfoExpr(ctx lowerFileContext, typ types.Type) string {
+	return o.runtimeTypeAssertInfoExprWithSeen(ctx, typ, make(map[types.Type]bool))
+}
+
+func (o *LoweringOwner) runtimeTypeAssertInfoExprWithSeen(ctx lowerFileContext, typ types.Type, seen map[types.Type]bool) string {
 	typeParam, ok := types.Unalias(typ).(*types.TypeParam)
-	if !ok || !typeParamInScope(ctx, typeParam) {
+	if ok && typeParamInScope(ctx, typeParam) {
+		return "__typeArgs?.[" + strconv.Quote(typeParam.Obj().Name()) + "]?.type ?? " +
+			o.runtimeTypeInfoExpr(typ)
+	}
+
+	typeKind := o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeKind)
+	if typ == nil {
+		return "{ kind: " + typeKind + ".Basic, name: \"unknown\" }"
+	}
+	typeKey := types.Unalias(typ)
+	if typeKey != nil {
+		if seen[typeKey] {
+			return o.shallowRuntimeTypeInfoExpr(typ)
+		}
+		seen[typeKey] = true
+		defer delete(seen, typeKey)
+	}
+	if named := namedFunctionType(typ); named != nil {
+		return o.runtimeFunctionTypeAssertInfoWithSeen(ctx, named.Underlying().(*types.Signature), runtimeNamedTypeName(named), seen)
+	}
+	if named := namedStructType(typ); named != nil {
+		return strconv.Quote(runtimeNamedTypeName(named))
+	}
+	if named := namedNonStructType(typ); named != nil {
+		if basic, ok := types.Unalias(named.Underlying()).(*types.Basic); ok {
+			return runtimeBasicTypeInfoExpr(typeKind, basic, runtimeNamedTypeName(named))
+		}
+		return strconv.Quote(runtimeNamedTypeName(named))
+	}
+	switch typed := types.Unalias(typ).Underlying().(type) {
+	case *types.Pointer:
+		return "{ kind: " + typeKind + ".Pointer, elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
+	case *types.Struct:
+		return "{ kind: " + typeKind + ".Struct, methods: [], fields: " + o.runtimeStructAssertFieldsExpr(ctx, typed, seen) + " }"
+	case *types.Slice:
+		return "{ kind: " + typeKind + ".Slice, elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
+	case *types.Array:
+		return "{ kind: " + typeKind + ".Array, elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + ", length: " + strconv.FormatInt(typed.Len(), 10) + " }"
+	case *types.Map:
+		return "{ kind: " + typeKind + ".Map, keyType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Key(), seen) + ", elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
+	case *types.Chan:
+		return "{ kind: " + typeKind + ".Channel, direction: " + strconv.Quote(channelDirectionString(typed.Dir())) + ", elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
+	case *types.Interface:
+		typed.Complete()
+		return "{ kind: " + typeKind + ".Interface, methods: " + o.runtimeMethodAssertSignaturesWithSeen(ctx, typed, seen) + " }"
+	case *types.Signature:
+		return o.runtimeFunctionTypeAssertInfoWithSeen(ctx, typed, "", seen)
+	default:
 		return o.runtimeTypeInfoExpr(typ)
 	}
-	return "__typeArgs?.[" + strconv.Quote(typeParam.Obj().Name()) + "]?.type ?? " +
-		o.runtimeTypeInfoExpr(typ)
 }
 
 func (o *LoweringOwner) runtimeTypeInfoExprWithSeen(typ types.Type, seen map[types.Type]bool) string {
@@ -9919,6 +10029,40 @@ func (o *LoweringOwner) runtimeStructFieldsExpr(structType *types.Struct, seen m
 	return "[" + strings.Join(fields, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeStructAssertFieldsExpr(ctx lowerFileContext, 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)
+		runtimeName := ""
+		if fieldName != field.Name() {
+			runtimeName = field.Name()
+		}
+		pkgPath := ""
+		if !field.Exported() && field.Pkg() != nil {
+			pkgPath = field.Pkg().Path()
+		}
+		fieldInfo := runtimeStructFieldInfoExpr(
+			o.runtimeTypeAssertInfoExprWithSeen(ctx, field.Type(), seen),
+			fieldName,
+			runtimeName,
+			structType.Tag(idx),
+			pkgPath,
+			field.Embedded(),
+			[]int{idx},
+			offsets[idx],
+			field.Exported(),
+		)
+		fields = append(fields, fieldInfo)
+	}
+	return "[" + strings.Join(fields, ", ") + "]"
+}
+
 func runtimeStructFieldInfoExpr(
 	runtimeType string,
 	storageKey string,
@@ -9983,6 +10127,26 @@ func (o *LoweringOwner) runtimeFunctionTypeInfoWithSeen(signature *types.Signatu
 	return "({ " + strings.Join(parts, ", ") + " } as " + runtimePackage + ".FunctionTypeInfo)"
 }
 
+func (o *LoweringOwner) runtimeFunctionTypeAssertInfoWithSeen(
+	ctx lowerFileContext,
+	signature *types.Signature,
+	name string,
+	seen map[types.Type]bool,
+) string {
+	typeKind := o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeKind)
+	parts := []string{"kind: " + typeKind + ".Function"}
+	if name != "" {
+		parts = append(parts, "name: "+strconv.Quote(name))
+	}
+	parts = append(parts, "params: "+o.runtimeTypeAssertSignatureTypes(ctx, signature.Params(), seen))
+	parts = append(parts, "results: "+o.runtimeTypeAssertSignatureTypes(ctx, signature.Results(), seen))
+	if signature.Variadic() {
+		parts = append(parts, "isVariadic: true")
+	}
+	runtimePackage := strings.TrimSuffix(typeKind, ".TypeKind")
+	return "({ " + strings.Join(parts, ", ") + " } as " + runtimePackage + ".FunctionTypeInfo)"
+}
+
 func (o *LoweringOwner) runtimeSignatureTypes(tuple *types.Tuple, seen map[types.Type]bool) string {
 	if tuple == nil || tuple.Len() == 0 {
 		return "[]"
@@ -9994,6 +10158,17 @@ func (o *LoweringOwner) runtimeSignatureTypes(tuple *types.Tuple, seen map[types
 	return "[" + strings.Join(types, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeTypeAssertSignatureTypes(ctx lowerFileContext, tuple *types.Tuple, seen map[types.Type]bool) string {
+	if tuple == nil || tuple.Len() == 0 {
+		return "[]"
+	}
+	types := make([]string, 0, tuple.Len())
+	for v := range tuple.Variables() {
+		types = append(types, o.runtimeTypeAssertInfoExprWithSeen(ctx, v.Type(), seen))
+	}
+	return "[" + strings.Join(types, ", ") + "]"
+}
+
 func tsStructFieldName(name string, idx int) string {
 	if name == "_" {
 		return "_blank" + strconv.Itoa(idx)
@@ -10945,6 +11120,7 @@ func (o *LoweringOwner) callNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool
 			return o.functionAsync(ctx, calledFunction(ctx.semPkg.source, fun)) ||
 				o.overrideCallNeedsAwait(ctx, fun) ||
 				callUsesFunctionValue(ctx.semPkg.source, fun) ||
+				(ctx.asyncFunction && callUsesInterfaceMethod(ctx.semPkg.source, fun)) ||
 				(ctx.asyncFunction && callUsesFunctionIdentifier(ctx.semPkg.source, fun))
 		}
 		if ctx.semPkg == nil || ctx.semPkg.source == nil {
@@ -10953,10 +11129,48 @@ func (o *LoweringOwner) callNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool
 		return o.functionAsync(ctx, calledFunction(ctx.semPkg.source, fun)) ||
 			o.overrideCallNeedsAwait(ctx, fun) ||
 			callUsesFunctionValue(ctx.semPkg.source, fun) ||
+			(ctx.asyncFunction && callUsesInterfaceMethod(ctx.semPkg.source, fun)) ||
 			(ctx.asyncFunction && callUsesFunctionIdentifier(ctx.semPkg.source, fun))
 	}
 }
 
+func callUsesInterfaceMethod(pkg *packages.Package, fun ast.Expr) bool {
+	if pkg == nil {
+		return false
+	}
+	selector, ok := fun.(*ast.SelectorExpr)
+	if !ok {
+		return false
+	}
+	selection := pkg.TypesInfo.Selections[selector]
+	if selection == nil || selection.Kind() != types.MethodVal {
+		return false
+	}
+	if selectionUsesSyncErrorMethod(selection) {
+		return false
+	}
+	return isInterfaceType(selection.Recv())
+}
+
+func selectionUsesSyncErrorMethod(selection *types.Selection) bool {
+	if selection == nil || selection.Kind() != types.MethodVal {
+		return false
+	}
+	method, _ := selection.Obj().(*types.Func)
+	return isSyncErrorMethodFunc(method)
+}
+
+func isSyncErrorMethodFunc(fn *types.Func) bool {
+	if fn == nil || fn.Name() != "Error" {
+		return false
+	}
+	signature, _ := fn.Type().(*types.Signature)
+	if signature == nil || signature.Params().Len() != 0 || signature.Results().Len() != 1 {
+		return false
+	}
+	return types.Identical(signature.Results().At(0).Type(), types.Typ[types.String])
+}
+
 func (o *LoweringOwner) overrideCallNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool {
 	if o.overrideOwner == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false

package/compiler/override-registry_test.go

@@ -488,6 +488,56 @@ func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesAwaitsAsyncSlicesSortFuncComparator(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/slicesasyncsort\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"slices\"",
+			"type Comparator interface { Less(a, b int) bool }",
+			"func Use(c Comparator, values []int) {",
+			"  slices.SortFunc(values, func(a, b int) int {",
+			"    if c.Less(a, b) {",
+			"      return -1",
+			"    }",
+			"    if c.Less(b, a) {",
+			"      return 1",
+			"    }",
+			"    return 0",
+			"  })",
+			"}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "slicesasyncsort", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function Use") {
+		t.Fatalf("caller was not marked async for slices.SortFunc:\n%s", text)
+	}
+	if !strings.Contains(text, "await slices.SortFunc") {
+		t.Fatalf("slices.SortFunc call was not awaited:\n%s", text)
+	}
+	if !strings.Contains(text, "$.functionValue(async") {
+		t.Fatalf("SortFunc comparator was not lowered as async:\n%s", text)
+	}
+}
+
 func TestCompilePackagesAwaitsReflectValueCall(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/reflectcallasync\n\ngo 1.25.3\n",

package/compiler/protobuf-ts-binding.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 )
 
@@ -16,6 +17,13 @@ type protobufTypeScriptBinding struct {
 	hasOneof     bool
 }
 
+type protobufTypeScriptBindingOneofCase struct {
+	groupLocalName string
+	caseLocalName  string
+	branchCtor     string
+	valueCtor      string
+}
+
 func protobufTypeScriptBindings(semPkg *semanticPackage, options LoweringOptions) (map[string]protobufTypeScriptBinding, []Diagnostic) {
 	if semPkg == nil || semPkg.source == nil || !options.ProtobufTypeScriptBinding {
 		return nil, nil
@@ -291,6 +299,7 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 		source:     binding.importSource,
 		sideEffect: true,
 	})
+	oneofCases := protobufTypeScriptBindingOneofCases(file)
 	var setupDecls []loweredDecl
 	for _, decl := range file.decls {
 		if decl.structType == nil {
@@ -306,7 +315,7 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 		if !ok {
 			continue
 		}
-		setup := protobufTypeScriptBindingStructSetupDecl(decl.structType, importAlias, messageName)
+		setup := protobufTypeScriptBindingStructSetupDecl(decl.structType, importAlias, messageName, oneofCases[decl.structType.name])
 		if setup.code != "" {
 			setupDecls = append(setupDecls, setup)
 		}
@@ -314,6 +323,102 @@ func rewriteProtobufTypeScriptBindingFile(file *loweredFile, binding protobufTyp
 	file.decls = append(file.decls, setupDecls...)
 }
 
+func protobufTypeScriptBindingOneofCases(file *loweredFile) map[string][]protobufTypeScriptBindingOneofCase {
+	parentByName := make(map[string]*loweredStruct)
+	for _, decl := range file.decls {
+		if decl.structType != nil {
+			parentByName[decl.structType.name] = decl.structType
+		}
+	}
+	out := make(map[string][]protobufTypeScriptBindingOneofCase)
+	for _, decl := range file.decls {
+		branch := decl.structType
+		if branch == nil || !strings.Contains(branch.name, "_") {
+			continue
+		}
+		parent := protobufTypeScriptBindingOneofParent(branch.name, parentByName)
+		if parent == nil {
+			continue
+		}
+		groups := protobufTypeScriptBindingOneofGroups(parent)
+		if len(groups) == 0 {
+			continue
+		}
+		groupLocalName := protobufTypeScriptBindingOneofCaseGroup(branch, parent, groups)
+		if groupLocalName == "" {
+			continue
+		}
+		for _, field := range branch.fields {
+			if !strings.Contains(field.tag, "oneof") {
+				continue
+			}
+			out[parent.name] = append(out[parent.name], protobufTypeScriptBindingOneofCase{
+				groupLocalName: groupLocalName,
+				caseLocalName:  protobufTypeScriptBindingFieldLocalName(field),
+				branchCtor:     branch.name,
+				valueCtor:      protobufTypeScriptBindingFieldCtor(field),
+			})
+		}
+	}
+	for parentName := range out {
+		slices.SortFunc(out[parentName], func(left, right protobufTypeScriptBindingOneofCase) int {
+			if left.groupLocalName != right.groupLocalName {
+				return strings.Compare(left.groupLocalName, right.groupLocalName)
+			}
+			return strings.Compare(left.caseLocalName, right.caseLocalName)
+		})
+	}
+	return out
+}
+
+func protobufTypeScriptBindingOneofParent(branchName string, parents map[string]*loweredStruct) *loweredStruct {
+	var parent *loweredStruct
+	for name, candidate := range parents {
+		if name == branchName || !strings.HasPrefix(branchName, name+"_") {
+			continue
+		}
+		if parent == nil || len(name) > len(parent.name) {
+			parent = candidate
+		}
+	}
+	return parent
+}
+
+func protobufTypeScriptBindingOneofGroups(parent *loweredStruct) map[string]string {
+	groups := make(map[string]string)
+	for _, field := range parent.fields {
+		if !strings.Contains(field.tag, "protobuf_oneof") {
+			continue
+		}
+		localName := protobufTypeScriptBindingTagValue(field.tag, "protobuf_oneof:\"")
+		if localName == "" {
+			groups[field.name] = protobufTypeScriptBindingFieldLocalName(field)
+			continue
+		}
+		groups[field.name] = protobufTypeScriptBindingProtoCamel(localName)
+	}
+	return groups
+}
+
+func protobufTypeScriptBindingOneofCaseGroup(branch, parent *loweredStruct, groups map[string]string) string {
+	if len(groups) == 1 {
+		for _, localName := range groups {
+			return localName
+		}
+	}
+	prefix := "is" + parent.name + "_"
+	for _, method := range branch.methods {
+		groupName, ok := strings.CutPrefix(method.name, prefix)
+		if !ok {
+			continue
+		}
+		if localName := groups[groupName]; localName != "" {
+			return localName
+		}
+	}
+	return ""
+}
+
 func protobufTypeScriptBindingSyntheticMapEntry(name string) bool {
 	return strings.Contains(name, "_") && strings.HasSuffix(name, "Entry")
 }
@@ -466,23 +571,66 @@ func protobufBindingParam(method *loweredFunction, idx int, fallback string) str
 	return method.params[idx].name
 }
 
-func protobufTypeScriptBindingStructSetupDecl(structType *loweredStruct, importAlias, messageName string) loweredDecl {
+func protobufTypeScriptBindingStructSetupDecl(structType *loweredStruct, importAlias, messageName string, oneofCases []protobufTypeScriptBindingOneofCase) loweredDecl {
 	if structType == nil {
 		return loweredDecl{}
 	}
 	if messageName == "" {
 		messageName = structType.name
 	}
-	entries := make([]string, 0, len(structType.fields))
+	fieldEntries := make(map[string]string)
 	for _, field := range structType.fields {
 		ctor := protobufTypeScriptBindingFieldCtor(field)
 		if ctor == "" {
 			continue
 		}
-		entries = append(entries, strconvQuote(protobufTypeScriptBindingFieldLocalName(field))+": "+ctor)
+		fieldEntries[protobufTypeScriptBindingFieldLocalName(field)] = ctor
+	}
+	for _, oneofCase := range oneofCases {
+		if oneofCase.valueCtor != "" {
+			fieldEntries[oneofCase.caseLocalName] = oneofCase.valueCtor
+		}
+	}
+	fieldNames := make([]string, 0, len(fieldEntries))
+	for name := range fieldEntries {
+		fieldNames = append(fieldNames, name)
+	}
+	slices.Sort(fieldNames)
+	entries := make([]string, 0, len(fieldNames))
+	for _, name := range fieldNames {
+		entries = append(entries, strconvQuote(name)+": "+fieldEntries[name])
+	}
+	code := "(" + structType.name + " as any).__protobufTypeScriptMessage = " + importAlias + "." + messageName + ";\n" +
+		"(" + structType.name + " as any).__protobufTypeScriptFields = {" + strings.Join(entries, ", ") + "};"
+	if len(oneofCases) != 0 {
+		code += "\n(" + structType.name + " as any).__protobufTypeScriptOneofFields = " + protobufTypeScriptBindingOneofFieldsLiteral(oneofCases) + ";"
+	}
+	return loweredDecl{code: code}
+}
+
+func protobufTypeScriptBindingOneofFieldsLiteral(oneofCases []protobufTypeScriptBindingOneofCase) string {
+	groups := make(map[string][]protobufTypeScriptBindingOneofCase)
+	for _, oneofCase := range oneofCases {
+		groups[oneofCase.groupLocalName] = append(groups[oneofCase.groupLocalName], oneofCase)
+	}
+	groupNames := make([]string, 0, len(groups))
+	for name := range groups {
+		groupNames = append(groupNames, name)
+	}
+	slices.Sort(groupNames)
+	entries := make([]string, 0, len(groupNames))
+	for _, groupName := range groupNames {
+		cases := groups[groupName]
+		slices.SortFunc(cases, func(left, right protobufTypeScriptBindingOneofCase) int {
+			return strings.Compare(left.caseLocalName, right.caseLocalName)
+		})
+		caseEntries := make([]string, 0, len(cases))
+		for _, oneofCase := range cases {
+			caseEntries = append(caseEntries, strconvQuote(oneofCase.caseLocalName)+": "+oneofCase.branchCtor)
+		}
+		entries = append(entries, strconvQuote(groupName)+": {"+strings.Join(caseEntries, ", ")+"}")
 	}
-	return loweredDecl{code: "(" + structType.name + " as any).__protobufTypeScriptMessage = " + importAlias + "." + messageName + ";\n" +
-		"(" + structType.name + " as any).__protobufTypeScriptFields = {" + strings.Join(entries, ", ") + "};"}
+	return "{" + strings.Join(entries, ", ") + "}"
 }
 
 func protobufTypeScriptBindingFieldLocalName(field loweredStructField) string {