goscript 0.2.5 → 0.2.7

package/compiler/lowering.go

@@ -36,6 +36,8 @@ type LoweringOptions struct {
 	OutputPath string
 	// ProtobufTypeScriptBinding binds .pb.go files to sibling .pb.ts files.
 	ProtobufTypeScriptBinding bool
+	// TrimTypeInfo drops metadata used only by reflect from named type registration payloads.
+	TrimTypeInfo bool
 }
 
 // NewLoweringOwner creates the lowering owner.
@@ -74,7 +76,7 @@ func (o *LoweringOwner) Build(ctx context.Context, model *SemanticModel, opts ..
 		options = opts[0]
 	}
 
-	program := &LoweredProgram{}
+	program := &LoweredProgram{trimTypeInfo: options.TrimTypeInfo}
 	lazyPackageVars := make(map[string]map[types.Object]bool, len(model.packages))
 	asyncLazyFunctionCache := make(map[*types.Func]bool)
 	asyncLazyFunctionVisiting := make(map[*types.Func]bool)
@@ -159,6 +161,7 @@ func (o *LoweringOwner) lowerPackage(
 				asyncLazyFunctionVisiting,
 				runtimeMethodSets,
 				protobufAdapter,
+				options.TrimTypeInfo,
 				options.DisplayRoot,
 			)
 			diagnostics = append(diagnostics, fileDiagnostics...)
@@ -181,6 +184,7 @@ func (o *LoweringOwner) lowerPackage(
 			asyncLazyFunctionVisiting,
 			runtimeMethodSets,
 			false,
+			options.TrimTypeInfo,
 			options.DisplayRoot,
 		)
 		diagnostics = append(diagnostics, fileDiagnostics...)
@@ -219,6 +223,7 @@ func (o *LoweringOwner) lowerFile(
 	asyncLazyFunctionVisiting map[*types.Func]bool,
 	runtimeMethodSets runtimeMethodSetCache,
 	protobufTypeScriptAdapter bool,
+	trimTypeInfo bool,
 	displayRoot string,
 ) (*loweredFile, []Diagnostic) {
 	associatedMethods := o.methodDeclsForFileTypes(semPkg, file)
@@ -342,6 +347,7 @@ func (o *LoweringOwner) lowerFile(
 		tempNames:                 newTempNameOwner(),
 		topLevel:                  true,
 		protobufTSAdapter:         protobufTypeScriptAdapter,
+		trimTypeInfo:              trimTypeInfo,
 		displayRoot:               displayRoot,
 	}
 	var diagnostics []Diagnostic
@@ -1150,6 +1156,7 @@ type lowerFileContext struct {
 	switchBreak               bool
 	topLevel                  bool
 	protobufTSAdapter         bool
+	trimTypeInfo              bool
 	displayRoot               string
 }
 
@@ -1311,7 +1318,7 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				}
 				value := o.lowerDeclarationZeroValueExpr(ctx, obj.Type())
 				if constObj, ok := obj.(*types.Const); ok {
-					if constValue, ok := lowerConstantValue(constObj.Val()); ok {
+					if constValue, ok := lowerConstantValueForType(constObj.Val(), constObj.Type()); ok {
 						value = constValue
 					}
 				} else if idx < len(typed.Values) {
@@ -2575,6 +2582,17 @@ func lowerLargeIntegerConstantValue(value constant.Value) (string, bool) {
 	return value.ExactString(), true
 }
 
+// lowerConstantValueForType lowers an integer constant to a bigint literal when
+// its declared type is bigint-backed (int64/uint64 and named types over them),
+// so that const declarations and inlined const references carry the same
+// representation as the values they participate in arithmetic with.
+func lowerConstantValueForType(value constant.Value, typ types.Type) (string, bool) {
+	if value != nil && value.Kind() == constant.Int && isBigIntBackedType(typ) {
+		return value.ExactString() + "n", true
+	}
+	return lowerConstantValue(value)
+}
+
 func lowerWideIntegerConstantValue(value constant.Value) (string, bool) {
 	if value == nil || value.Kind() != constant.Int || constant.BitLen(value) <= 53 {
 		return "", false
@@ -2918,9 +2936,13 @@ func (o *LoweringOwner) lowerInterfaceType(ctx lowerFileContext, semType *semant
 			typeIndexExport = typeName
 		}
 	}
+	methodSignatures := o.runtimeMethodSignatures(iface)
+	if ctx.trimTypeInfo {
+		methodSignatures = o.runtimeTrimmedMethodSignatures(iface)
+	}
 	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" + methodSignatures + "\n);"
 	return loweredDecl{code: code, typeIndexExport: typeIndexExport, sideEffect: true}
 }
 
@@ -2957,6 +2979,18 @@ func (o *LoweringOwner) runtimeMethodSignaturesWithSeen(iface *types.Interface,
 	return "[" + strings.Join(methods, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeTrimmedMethodSignatures(iface *types.Interface) string {
+	return o.runtimeTrimmedMethodSignaturesWithSeen(iface, make(map[types.Type]bool))
+}
+
+func (o *LoweringOwner) runtimeTrimmedMethodSignaturesWithSeen(iface *types.Interface, seen map[types.Type]bool) string {
+	methods := make([]string, 0, iface.NumMethods())
+	for method := range iface.Methods() {
+		methods = append(methods, o.runtimeTrimmedMethodSignature(method, seen))
+	}
+	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() {
@@ -2975,6 +3009,16 @@ func (o *LoweringOwner) runtimeMethodSignature(method *types.Func, seen map[type
 		", returns: " + o.runtimeMethodReturns(signature.Results(), seen) + " }"
 }
 
+func (o *LoweringOwner) runtimeTrimmedMethodSignature(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.runtimeTrimmedMethodArgs(signature.Params()) +
+		", returns: " + o.runtimeTrimmedMethodReturns(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 {
@@ -3001,6 +3045,19 @@ func (o *LoweringOwner) runtimeMethodArgs(tuple *types.Tuple, seen map[types.Typ
 	return "[" + strings.Join(args, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeTrimmedMethodArgs(tuple *types.Tuple) string {
+	if tuple == nil || tuple.Len() == 0 {
+		return "[]"
+	}
+	typeKind := o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeKind)
+	arg := "{ type: { kind: " + typeKind + ".Basic, name: \"unknown\" } }"
+	args := make([]string, 0, tuple.Len())
+	for range tuple.Len() {
+		args = append(args, arg)
+	}
+	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 "[]"
@@ -3033,6 +3090,17 @@ func (o *LoweringOwner) runtimeMethodReturns(tuple *types.Tuple, seen map[types.
 	return "[" + strings.Join(results, ", ") + "]"
 }
 
+func (o *LoweringOwner) runtimeTrimmedMethodReturns(tuple *types.Tuple, seen map[types.Type]bool) string {
+	if tuple == nil || tuple.Len() == 0 {
+		return "[]"
+	}
+	results := make([]string, 0, tuple.Len())
+	for result := range tuple.Variables() {
+		results = append(results, "{ type: "+o.runtimeTypeInfoExprWithSeen(result.Type(), seen)+" }")
+	}
+	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 "[]"
@@ -3291,13 +3359,14 @@ func (o *LoweringOwner) lowerEmbeddedMethodForwarders(
 		async := o.functionAsync(ctx, method)
 		targetType := o.tsEmbeddedForwarderTargetType(ctx, field.typ)
 		lowered := loweredFunction{
-			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{},
+			async:                   async,
+			sourcePath:              ctx.sourcePath,
+			name:                    methodMemberName(method.Name()),
+			runtimeName:             method.Name(),
+			runtimeSignature:        o.runtimeMethodSignature(method, make(map[types.Type]bool)),
+			runtimeTrimmedSignature: o.runtimeTrimmedMethodSignature(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() {
@@ -3462,8 +3531,13 @@ func (o *LoweringOwner) lowerNamedReceiverMethodDecl(
 		lowered.params, lowered.paramBindings = o.appendLoweredParam(ctx, lowered.params, lowered.paramBindings, param, idx, decl.Body == nil || async)
 	}
 	if decl.Body != nil {
-		body, diagnostics := o.lowerBlock(ctx.withSignature(signature).withAsyncFunction(async).withDeferState(deferState), decl.Body)
+		bodyCtx := ctx.withSignature(signature).withAsyncFunction(async).withDeferState(deferState)
+		body, diagnostics := o.lowerBlock(bodyCtx, decl.Body)
 		lowered.body = body
+		if deferState.used && funcBodyUsesRecover(bodyCtx, decl.Body) {
+			deferState.recover = true
+			lowered.recoverReturn = o.recoverReturnStmt(bodyCtx, signature)
+		}
 		if deferState.async && !lowered.async {
 			lowered.async = true
 			lowered.result = asyncResultType(o.tsSignatureResultFor(ctx.withAsyncFunction(true), signature), true)
@@ -3520,6 +3594,7 @@ func (o *LoweringOwner) lowerFuncDecl(ctx lowerFileContext, decl *ast.FuncDecl)
 	}
 	if decl.Recv != nil {
 		lowered.runtimeSignature = o.runtimeMethodSignature(fnObj, make(map[types.Type]bool))
+		lowered.runtimeTrimmedSignature = o.runtimeTrimmedMethodSignature(fnObj, make(map[types.Type]bool))
 	}
 	if signature.TypeParams() != nil && signature.TypeParams().Len() != 0 {
 		lowered.typeParams = signatureTypeParamNames(signature)
@@ -3550,8 +3625,13 @@ func (o *LoweringOwner) lowerFuncDecl(ctx lowerFileContext, decl *ast.FuncDecl)
 		lowered.params, lowered.paramBindings = o.appendLoweredParam(functionCtx, lowered.params, lowered.paramBindings, param, idx, decl.Body == nil || async)
 	}
 	if decl.Body != nil {
-		body, diagnostics := o.lowerBlock(functionCtx.withAsyncFunction(async).withDeferState(deferState), decl.Body)
+		bodyCtx := functionCtx.withAsyncFunction(async).withDeferState(deferState)
+		body, diagnostics := o.lowerBlock(bodyCtx, decl.Body)
 		lowered.body = body
+		if deferState.used && funcBodyUsesRecover(bodyCtx, decl.Body) {
+			deferState.recover = true
+			lowered.recoverReturn = o.recoverReturnStmt(bodyCtx, signature)
+		}
 		if deferState.async && !lowered.async {
 			lowered.async = true
 			lowered.result = asyncResultType(o.tsSignatureResultFor(functionCtx.withAsyncFunction(true), signature), true)
@@ -3863,7 +3943,7 @@ func (o *LoweringOwner) lowerStmtInto(ctx lowerFileContext, stmt ast.Stmt, out [
 			}
 			if decl.structType != nil {
 				var b strings.Builder
-				renderStruct(&b, decl.structType, o.runtimeOwner)
+				renderStruct(&b, decl.structType, o.runtimeOwner, ctx.trimTypeInfo)
 				stmts = append(stmts, loweredStmt{text: strings.TrimRight(b.String(), "\n")})
 			}
 		}
@@ -3955,17 +4035,22 @@ func (o *LoweringOwner) lowerStmtInto(ctx lowerFileContext, stmt ast.Stmt, out [
 		}
 		return append(out, lowered...), diagnostics
 	case *ast.IncDecStmt:
+		// A bigint-backed operand (int64/uint64) needs a bigint step literal so
+		// the generated +/- does not mix bigint and number.
+		oneLiteral := "1"
+		if isBigIntBackedType(ctx.semPkg.source.TypesInfo.TypeOf(typed.X)) {
+			oneLiteral = "1n"
+		}
 		if star, ok := unwrapParenExpr(typed.X).(*ast.StarExpr); ok {
 			expr, diagnostics := o.lowerPointerStorageExpr(ctx, star.X)
 			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"
 			tok := token.ADD_ASSIGN
 			if typed.Tok == token.DEC {
 				tok = token.SUB_ASSIGN
 			}
-			stmts, diagnostics := o.lowerMapIndexUpdateStmts(ctx, index, tok, right, ctx.semPkg.source.TypesInfo.TypeOf(typed.X))
+			stmts, diagnostics := o.lowerMapIndexUpdateStmts(ctx, index, tok, oneLiteral, ctx.semPkg.source.TypesInfo.TypeOf(typed.X))
 			return append(out, stmts...), diagnostics
 		}
 		if setter, ok := o.packageVarSetterForAssignment(ctx, typed.X); ok {
@@ -3974,7 +4059,14 @@ func (o *LoweringOwner) lowerStmtInto(ctx lowerFileContext, stmt ast.Stmt, out [
 			if typed.Tok == token.DEC {
 				op = "-"
 			}
-			return append(out, loweredStmt{text: setter + "(" + expr + " " + op + " 1)"}), diagnostics
+			return append(out, loweredStmt{text: setter + "(" + expr + " " + op + " " + oneLiteral + ")"}), diagnostics
+		}
+		if _, ok := unwrapParenExpr(typed.X).(*ast.IndexExpr); ok {
+			// Array/slice index increment needs the assignable target[index] form;
+			// the read path wraps indexing in a bounds-checked helper that cannot be
+			// an increment operand. Map index increment is handled above.
+			target, diagnostics := o.lowerAssignmentTarget(ctx, typed.X, false)
+			return append(out, loweredStmt{text: target + typed.Tok.String()}), diagnostics
 		}
 		expr, diagnostics := o.lowerExpr(ctx, typed.X)
 		return append(out, loweredStmt{text: expr + typed.Tok.String()}), diagnostics
@@ -4896,7 +4988,8 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 			continue
 		}
 		if helper, ok := wideIntegerAssignHelper(targetType, stmt.Tok); ok {
-			stmts = append(stmts, loweredStmt{text: left + " = " + o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")"})
+			call := coerceWideHelperResult(o.runtimeOwner, targetType, o.runtimeOwner.QualifiedHelper(helper)+"("+left+", "+right+")")
+			stmts = append(stmts, loweredStmt{text: left + " = " + call})
 			continue
 		}
 		if value, ok := integerQuotientAssignExpr(targetType, left, right, stmt.Tok); ok {
@@ -4951,7 +5044,7 @@ func lowerCompoundAssignValue(
 	tok token.Token,
 ) string {
 	if helper, ok := wideIntegerAssignHelper(targetType, tok); ok {
-		return runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")"
+		return coerceWideHelperResult(runtimeOwner, targetType, runtimeOwner.QualifiedHelper(helper)+"("+left+", "+right+")")
 	}
 	if value, ok := integerQuotientAssignValueExpr(targetType, left, right, tok); ok {
 		return value
@@ -6099,6 +6192,23 @@ func (o *LoweringOwner) lowerNamedResultReturn(ctx lowerFileContext) (string, bo
 	return "[" + strings.Join(parts, ", ") + "]", true
 }
 
+// recoverReturnStmt builds the return statement a defer+recover function runs
+// after its deferred recover() swallows a panic: the named results, the zero
+// values for unnamed results, or an empty string for a void function (which
+// falls through and returns undefined).
+func (o *LoweringOwner) recoverReturnStmt(ctx lowerFileContext, signature *types.Signature) string {
+	if signature == nil || signature.Results() == nil || signature.Results().Len() == 0 {
+		return ""
+	}
+	if expr, ok := o.lowerNamedResultReturn(ctx); ok {
+		return "return " + expr
+	}
+	if zeroReturn, ok := o.lowerBodylessReturnStmt(ctx, signature); ok {
+		return zeroReturn
+	}
+	return ""
+}
+
 func (o *LoweringOwner) lowerForStmt(ctx lowerFileContext, stmt *ast.ForStmt) (loweredStmt, []Diagnostic) {
 	bodyCtx := ctx.withoutRangeLoopBranches().withoutLoopLabel()
 	loopLabel := ""
@@ -7042,8 +7152,7 @@ func isFunctionType(typ types.Type) bool {
 }
 
 func isBoolType(typ types.Type) bool {
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Kind() == types.Bool
+	return basicKind(typ, types.Bool)
 }
 
 func isUntypedNilType(typ types.Type) bool {
@@ -7326,17 +7435,22 @@ 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 {
+			resultType := ctx.semPkg.source.TypesInfo.TypeOf(typed)
+			// The int64*/uint64* family returns bigint; number-typed wide results
+			// (uint, uintptr) keep full 64-bit width through coerceWideHelperResult.
+			wideComplement := func(helper RuntimeHelper) string {
+				return coerceWideHelperResult(o.runtimeOwner, resultType,
+					o.runtimeOwner.QualifiedHelper(helper)+"("+value+", -1n)")
+			}
+			if bits, ok := unsignedIntegerBits(resultType); ok {
 				if bits <= 32 {
 					return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
 						"(~" + value + ", " + strconv.Itoa(bits) + ")", diagnostics
 				}
-				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Xor) +
-					"(" + value + ", -1n)", diagnostics
+				return wideComplement(RuntimeHelperUint64Xor), diagnostics
 			}
-			if bits, ok := signedIntegerBits(ctx.semPkg.source.TypesInfo.TypeOf(typed)); ok && bits > 32 {
-				return o.runtimeOwner.QualifiedHelper(RuntimeHelperInt64Xor) +
-					"(" + value + ", -1n)", diagnostics
+			if bits, ok := signedIntegerBits(resultType); ok && bits > 32 {
+				return wideComplement(RuntimeHelperInt64Xor), diagnostics
 			}
 			return "~" + value, diagnostics
 		}
@@ -7470,11 +7584,15 @@ func (o *LoweringOwner) lowerFuncLitArrowWithAsyncCalls(
 		}
 	}
 	body, diagnostics := o.lowerBlock(bodyCtx, lit.Body)
+	litFn := &loweredFunction{body: body, deferState: deferState}
+	if deferState.used && funcBodyUsesRecover(bodyCtx, lit.Body) {
+		deferState.recover = true
+		litFn.recoverReturn = o.recoverReturnStmt(bodyCtx, signature)
+	}
 	var rendered strings.Builder
 	renderStmts(&rendered, paramBindings, 1)
 	renderNamedResults(&rendered, o.lowerNamedResults(ctx, signature), 1)
-	renderDeferStack(&rendered, deferState, 1)
-	renderStmts(&rendered, body, 1)
+	renderBodyWithDefer(&rendered, litFn, 1)
 	async := bodyCtx.asyncFunction || stmtsContainAwait(body) || deferState.async
 	prefix := ""
 	if async {
@@ -7578,7 +7696,7 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 		return alias
 	}
 	if constObj, ok := obj.(*types.Const); ok && !raw {
-		if constValue, ok := lowerConstantValue(constObj.Val()); ok {
+		if constValue, ok := lowerConstantValueForType(constObj.Val(), constObj.Type()); ok {
 			return constValue
 		}
 	}
@@ -8173,6 +8291,34 @@ func isBuiltinCallTarget(ctx lowerFileContext, expr ast.Expr) bool {
 	return ok
 }
 
+// funcBodyUsesRecover reports whether body lexically contains a call to the
+// builtin recover. The scan descends into nested function literals because a
+// recover() inside a deferred func literal recovers the enclosing function's
+// panic, so that enclosing function is the one that needs the recover-aware
+// emission.
+func funcBodyUsesRecover(ctx lowerFileContext, body ast.Node) bool {
+	found := false
+	ast.Inspect(body, func(node ast.Node) bool {
+		if found {
+			return false
+		}
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		ident, ok := call.Fun.(*ast.Ident)
+		if !ok || ident.Name != "recover" {
+			return true
+		}
+		if _, ok := objectForIdent(ctx, ident).(*types.Builtin); ok {
+			found = true
+			return false
+		}
+		return true
+	})
+	return found
+}
+
 func (o *LoweringOwner) callUsesOverridePackage(ctx lowerFileContext, expr ast.Expr) bool {
 	if o.overrideOwner == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false
@@ -8219,11 +8365,13 @@ func (o *LoweringOwner) lowerMakeExpr(ctx lowerFileContext, expr *ast.CallExpr)
 		if len(expr.Args) >= 2 {
 			var lengthDiagnostics []Diagnostic
 			length, lengthDiagnostics = o.lowerExpr(ctx, expr.Args[1])
+			length = o.lowerNumberIndexValue(ctx, expr.Args[1], length)
 			diagnostics = append(diagnostics, lengthDiagnostics...)
 		}
 		if len(expr.Args) >= 3 {
 			var capacityDiagnostics []Diagnostic
 			capacity, capacityDiagnostics = o.lowerExpr(ctx, expr.Args[2])
+			capacity = o.lowerNumberIndexValue(ctx, expr.Args[2], capacity)
 			diagnostics = append(diagnostics, capacityDiagnostics...)
 		}
 		args := []string{length}
@@ -8256,6 +8404,7 @@ func (o *LoweringOwner) lowerMakeExpr(ctx lowerFileContext, expr *ast.CallExpr)
 		if len(expr.Args) >= 2 {
 			var capacityDiagnostics []Diagnostic
 			capacity, capacityDiagnostics = o.lowerExpr(ctx, expr.Args[1])
+			capacity = o.lowerNumberIndexValue(ctx, expr.Args[1], capacity)
 			diagnostics = append(diagnostics, capacityDiagnostics...)
 		}
 		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMakeChannel) +
@@ -8400,8 +8549,18 @@ func (o *LoweringOwner) lowerConversionExpr(
 	}
 	if isNumericType(targetType) {
 		if isFloatType(targetType) {
+			if isBigIntBackedType(sourceType) {
+				return "Number(" + value + ")", diagnostics
+			}
 			return value, diagnostics
 		}
+		if isBigIntBackedType(targetType) {
+			helper := RuntimeHelperInt64
+			if _, ok := unsignedIntegerBits(targetType); ok {
+				helper = RuntimeHelperUint64
+			}
+			return o.runtimeOwner.QualifiedHelper(helper) + "(" + value + ")", diagnostics
+		}
 		if bits, ok := unsignedIntegerBits(targetType); ok {
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
 				"(" + value + ", " + strconv.Itoa(bits) + ")", diagnostics
@@ -8415,14 +8574,39 @@ func (o *LoweringOwner) lowerConversionExpr(
 	return value, diagnostics
 }
 
+// coerceWideHelperResult coerces a bigint result from the int64*/uint64* runtime
+// family back to resultType's representation. int64/uint64 results stay bigint.
+// Unsigned number-typed wide results (uint, uintptr) flow through $.uint(_, 64),
+// which keeps values above 2^53 as a runtime bigint so full 64-bit width
+// survives; a precision-losing Number() wrap would truncate values like
+// ^uint(0). Signed platform int coerces with Number (accepted precision loss
+// above 2^53, matching Model A's int->number mapping): $.uint on a signed value
+// would reinterpret its sign bit as magnitude.
+func coerceWideHelperResult(runtimeOwner *RuntimeContractOwner, resultType types.Type, call string) string {
+	if isBigIntBackedType(resultType) {
+		return call
+	}
+	if _, ok := unsignedIntegerBits(resultType); ok {
+		return runtimeOwner.QualifiedHelper(RuntimeHelperUint) + "(" + call + ", 64)"
+	}
+	return "Number(" + call + ")"
+}
+
 func (o *LoweringOwner) lowerWideIntegerBinaryExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
-	resultWide := isRuntimeWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr))
+	resultType := ctx.semPkg.source.TypesInfo.TypeOf(expr)
+	resultWide := isRuntimeWideIntegerType(resultType)
 	leftWide := isRuntimeWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr.X))
 	if !resultWide && !leftWide {
 		return "", false
 	}
-	signed := isFixedSignedWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr)) ||
+	signed := isFixedSignedWideIntegerType(resultType) ||
 		isFixedSignedWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr.X))
+	wrap := func(call string) string {
+		return coerceWideHelperResult(o.runtimeOwner, resultType, call)
+	}
+	helperCall := func(helper RuntimeHelper) string {
+		return wrap(o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")")
+	}
 	switch expr.Op {
 	case token.SHL, token.SHR:
 		helper := RuntimeHelperUint64Shr
@@ -8436,27 +8620,27 @@ func (o *LoweringOwner) lowerWideIntegerBinaryExpr(ctx lowerFileContext, expr *a
 			}
 		}
 		if _, ok := constantShiftAmount(ctx, expr.Y); !ok {
-			return o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")", true
+			return helperCall(helper), true
 		}
 		amount, ok := constantShiftAmount(ctx, expr.Y)
 		if ok && amount >= 32 && expr.Op == token.SHL && !signed {
 			base := o.lowerWideShiftLeftOperand(ctx, expr.X, left)
-			return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Mul) +
-				"(" + base + ", " + shiftMultiplier(amount) + ")", true
+			return wrap(o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Mul) +
+				"(" + base + ", " + shiftMultiplier(amount) + ")"), true
 		}
-		return o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")", true
+		return helperCall(helper), true
 	case token.MUL:
-		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Mul, RuntimeHelperInt64Mul)) + "(" + left + ", " + right + ")", true
+		return helperCall(wideIntegerHelper(signed, RuntimeHelperUint64Mul, RuntimeHelperInt64Mul)), true
 	case token.QUO:
-		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Div, RuntimeHelperInt64Div)) + "(" + left + ", " + right + ")", true
+		return helperCall(wideIntegerHelper(signed, RuntimeHelperUint64Div, RuntimeHelperInt64Div)), true
 	case token.REM:
-		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Mod, RuntimeHelperInt64Mod)) + "(" + left + ", " + right + ")", true
+		return helperCall(wideIntegerHelper(signed, RuntimeHelperUint64Mod, RuntimeHelperInt64Mod)), true
 	case token.ADD:
-		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Add, RuntimeHelperInt64Add)) + "(" + left + ", " + right + ")", true
+		return helperCall(wideIntegerHelper(signed, RuntimeHelperUint64Add, RuntimeHelperInt64Add)), true
 	case token.SUB:
-		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Sub, RuntimeHelperInt64Sub)) + "(" + left + ", " + right + ")", true
+		return helperCall(wideIntegerHelper(signed, RuntimeHelperUint64Sub, RuntimeHelperInt64Sub)), true
 	case token.AND:
-		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64And, RuntimeHelperInt64And)) + "(" + left + ", " + right + ")", true
+		return helperCall(wideIntegerHelper(signed, RuntimeHelperUint64And, RuntimeHelperInt64And)), true
 	case token.XOR:
 		if isZeroIntegerExpr(ctx, expr.Y) {
 			return left, true
@@ -8464,15 +8648,15 @@ func (o *LoweringOwner) lowerWideIntegerBinaryExpr(ctx lowerFileContext, expr *a
 		if isZeroIntegerExpr(ctx, expr.X) {
 			return right, true
 		}
-		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Xor, RuntimeHelperInt64Xor)) + "(" + left + ", " + right + ")", true
+		return helperCall(wideIntegerHelper(signed, RuntimeHelperUint64Xor, RuntimeHelperInt64Xor)), true
 	case token.OR:
 		shift, ok := wideLeftShiftExpr(ctx, expr.X)
 		if ok && !signed {
 			if bits, ok := lowIntegerBits(ctx, expr.Y); ok && bits <= shift {
-				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Add) + "(" + left + ", " + right + ")", true
+				return helperCall(RuntimeHelperUint64Add), true
 			}
 		}
-		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Or, RuntimeHelperInt64Or)) + "(" + left + ", " + right + ")", true
+		return helperCall(wideIntegerHelper(signed, RuntimeHelperUint64Or, RuntimeHelperInt64Or)), true
 	default:
 		return "", false
 	}
@@ -8965,7 +9149,7 @@ func (o *LoweringOwner) packageVarAssignmentValue(
 		return left + " & ~(" + right + ")", true
 	}
 	if helper, ok := wideIntegerAssignHelper(targetType, tok); ok {
-		return o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")", true
+		return coerceWideHelperResult(o.runtimeOwner, targetType, o.runtimeOwner.QualifiedHelper(helper)+"("+left+", "+right+")"), true
 	}
 	if value, ok := integerQuotientAssignValueExpr(targetType, left, right, tok); ok {
 		return value, true
@@ -9336,6 +9520,18 @@ func (o *LoweringOwner) lowerAssignmentTarget(
 		return o.lowerIdent(ctx, typed, false), nil
 	case *ast.StarExpr:
 		return o.lowerPointerValueExpr(ctx, typed.X)
+	case *ast.IndexExpr:
+		// Assignment targets need an assignable JS reference (target[index]); the
+		// read path wraps array/slice indexing in a bounds-checked helper, which
+		// is not assignable. Map and string targets keep their own paths.
+		targetType := ctx.semPkg.source.TypesInfo.TypeOf(typed.X)
+		if isStringType(targetType) || isMapType(targetType) {
+			return o.lowerExpr(ctx, expr)
+		}
+		target, targetDiagnostics := o.lowerExpr(ctx, typed.X)
+		index, indexDiagnostics := o.lowerExpr(ctx, typed.Index)
+		diagnostics := append(targetDiagnostics, indexDiagnostics...)
+		return o.lowerIndexTarget(ctx, target, targetType) + "[" + o.lowerNumberIndexValue(ctx, typed.Index, index) + "]", diagnostics
 	default:
 		return o.lowerExpr(ctx, expr)
 	}
@@ -9428,7 +9624,7 @@ func (o *LoweringOwner) lowerIndexAddressExpr(ctx lowerFileContext, expr *ast.In
 	if isStringType(targetType) || isMapType(targetType) {
 		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
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexRef) + "(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + o.lowerNumberIndexValue(ctx, expr.Index, index) + ")", diagnostics
 }
 
 func (o *LoweringOwner) lowerAddressEqualityExpr(
@@ -9506,7 +9702,7 @@ func (o *LoweringOwner) lowerIndexAddressIntegerExpr(
 		return "", diagnostics, false
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexAddress) +
-		"(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + index + ")", diagnostics, true
+		"(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + o.lowerNumberIndexValue(ctx, indexExpr.Index, index) + ")", diagnostics, true
 }
 
 func (o *LoweringOwner) lowerIndexByteAddressIntegerExpr(
@@ -9530,7 +9726,7 @@ func (o *LoweringOwner) lowerIndexByteAddressIntegerExpr(
 	}
 	elementSize := goScriptElementByteSize(ctx, indexElementType(targetType))
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexByteAddress) +
-		"(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + index + ", " + strconv.FormatInt(elementSize, 10) + ")", diagnostics, true
+		"(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + o.lowerNumberIndexValue(ctx, indexExpr.Index, index) + ", " + strconv.FormatInt(elementSize, 10) + ")", diagnostics, true
 }
 
 func (o *LoweringOwner) lowerPointerValueExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
@@ -10037,14 +10233,27 @@ func (o *LoweringOwner) lowerIndexExpr(ctx lowerFileContext, expr *ast.IndexExpr
 	targetType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
 	switch {
 	case isStringType(targetType):
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexStringOrBytes) + "(" + target + ", " + index + ")", diagnostics
+		return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexStringOrBytes) + "(" + target + ", " + o.lowerNumberIndexValue(ctx, expr.Index, index) + ")", diagnostics
 	case isMapType(targetType):
 		return o.lowerMapGetValue(ctx, expr, target, index), diagnostics
 	default:
-		return o.lowerIndexTarget(ctx, target, targetType) + "[" + index + "]", diagnostics
+		return o.runtimeOwner.QualifiedHelper(RuntimeHelperArrayIndex) + "(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + o.lowerNumberIndexValue(ctx, expr.Index, index) + ")", diagnostics
 	}
 }
 
+// lowerNumberIndexValue coerces an index or size expression to a JS number when
+// its Go type is bigint-backed (int64/uint64/uint/uintptr). Array indices, slice
+// bounds, string/byte offsets, and make/len sizes must be number, not bigint.
+func (o *LoweringOwner) lowerNumberIndexValue(ctx lowerFileContext, expr ast.Expr, value string) string {
+	if expr == nil {
+		return value
+	}
+	if isBigIntBackedType(ctx.semPkg.source.TypesInfo.TypeOf(expr)) {
+		return "Number(" + value + ")"
+	}
+	return value
+}
+
 func (o *LoweringOwner) lowerGenericFunctionValue(
 	ctx lowerFileContext,
 	callee ast.Expr,
@@ -10103,6 +10312,9 @@ func (o *LoweringOwner) lowerSliceExpr(ctx lowerFileContext, expr *ast.SliceExpr
 	low, lowDiagnostics := o.lowerOptionalExpr(ctx, expr.Low)
 	high, highDiagnostics := o.lowerOptionalExpr(ctx, expr.High)
 	max, maxDiagnostics := o.lowerOptionalExpr(ctx, expr.Max)
+	low = o.lowerNumberIndexValue(ctx, expr.Low, low)
+	high = o.lowerNumberIndexValue(ctx, expr.High, high)
+	max = o.lowerNumberIndexValue(ctx, expr.Max, max)
 	diagnostics = append(diagnostics, lowDiagnostics...)
 	diagnostics = append(diagnostics, highDiagnostics...)
 	diagnostics = append(diagnostics, maxDiagnostics...)
@@ -10530,6 +10742,9 @@ func (o *LoweringOwner) lowerNumericConstantExprForTarget(ctx lowerFileContext,
 	}
 	tv, ok := ctx.semPkg.source.TypesInfo.Types[expr]
 	if ok && tv.Value != nil {
+		if isBigIntBackedType(targetType) && tv.Value.Kind() == constant.Int {
+			return tv.Value.ExactString() + "n", true
+		}
 		if bits, ok := unsignedIntegerBits(targetType); ok && bits >= 64 {
 			if value, ok := lowerWideIntegerConstantValue(tv.Value); ok {
 				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) + "(" +
@@ -10616,6 +10831,16 @@ func (o *LoweringOwner) lowerValueForTargetTypes(
 		return o.lowerStructClone(value)
 	}
 	if isIntegerType(targetType) && isIntegerType(sourceType) {
+		if isBigIntBackedType(targetType) {
+			if isBigIntBackedType(sourceType) {
+				return value
+			}
+			helper := RuntimeHelperInt64
+			if _, ok := unsignedIntegerBits(targetType); ok {
+				helper = RuntimeHelperUint64
+			}
+			return o.runtimeOwner.QualifiedHelper(helper) + "(" + value + ")"
+		}
 		if isBasicFixedWideIntegerType(targetType) {
 			if bits, ok := unsignedIntegerBits(targetType); ok {
 				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
@@ -10761,6 +10986,10 @@ func (o *LoweringOwner) lowerZeroValueExprFor(ctx lowerFileContext, typ types.Ty
 			return "\"\""
 		}
 		if typed.Info()&types.IsNumeric != 0 {
+			switch typed.Kind() {
+			case types.Int64, types.Uint64:
+				return "0n"
+			}
 			return "0"
 		}
 		return "undefined"
@@ -10813,6 +11042,13 @@ func (o *LoweringOwner) runtimeTypeAssertInfoExpr(ctx lowerFileContext, typ type
 	return o.runtimeTypeAssertInfoExprWithSeen(ctx, typ, make(map[types.Type]bool))
 }
 
+// runtimeTypeAssertInfoExprWithSeen renders the runtime type descriptor for a
+// type-assertion or type-switch target. It mirrors runtimeTypeInfoExprWithSeen
+// but threads ctx so a type parameter in scope resolves to its runtime
+// __typeArgs entry. Keep the two structurally in sync: the named-type checks,
+// the underlying switch arms, and the leaf cases must stay parallel; the only
+// intended differences are the type-parameter prefix and the ctx-threaded
+// recursion.
 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) {
@@ -10832,12 +11068,12 @@ func (o *LoweringOwner) runtimeTypeAssertInfoExprWithSeen(ctx lowerFileContext,
 		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 := namedFunctionType(typ); named != nil {
+		return o.runtimeFunctionTypeAssertInfoWithSeen(ctx, named.Underlying().(*types.Signature), runtimeNamedTypeName(named), seen)
+	}
 	if named := namedNonStructType(typ); named != nil {
 		if basic, ok := types.Unalias(named.Underlying()).(*types.Basic); ok {
 			return runtimeBasicTypeInfoExpr(typeKind, basic, runtimeNamedTypeName(named))
@@ -10845,6 +11081,8 @@ func (o *LoweringOwner) runtimeTypeAssertInfoExprWithSeen(ctx lowerFileContext,
 		return strconv.Quote(runtimeNamedTypeName(named))
 	}
 	switch typed := types.Unalias(typ).Underlying().(type) {
+	case *types.Basic:
+		return runtimeBasicTypeInfoExpr(typeKind, typed, "")
 	case *types.Pointer:
 		return "{ kind: " + typeKind + ".Pointer, elemType: " + o.runtimeTypeAssertInfoExprWithSeen(ctx, typed.Elem(), seen) + " }"
 	case *types.Struct:
@@ -10867,6 +11105,8 @@ func (o *LoweringOwner) runtimeTypeAssertInfoExprWithSeen(ctx lowerFileContext,
 	}
 }
 
+// runtimeTypeInfoExprWithSeen renders the runtime type descriptor for typ. Keep
+// it structurally in sync with runtimeTypeAssertInfoExprWithSeen.
 func (o *LoweringOwner) runtimeTypeInfoExprWithSeen(typ types.Type, seen map[types.Type]bool) string {
 	typeKind := o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeKind)
 	if typ == nil {
@@ -11353,6 +11593,10 @@ func (o *LoweringOwner) tsTypeFor(ctx lowerFileContext, typ types.Type) string {
 			return "string"
 		}
 		if typed.Info()&types.IsNumeric != 0 {
+			switch typed.Kind() {
+			case types.Int64, types.Uint64:
+				return "bigint"
+			}
 			return "number"
 		}
 		return "unknown"
@@ -11517,6 +11761,10 @@ func zeroValueExpr(typ types.Type) string {
 			return "\"\""
 		}
 		if typed.Info()&types.IsNumeric != 0 {
+			switch typed.Kind() {
+			case types.Int64, types.Uint64:
+				return "0n"
+			}
 			return "0"
 		}
 		return "undefined"
@@ -11836,12 +12084,28 @@ func isChannelType(typ types.Type) bool {
 	return ok
 }
 
-func isComplexType(typ types.Type) bool {
+// basicKind reports whether typ's underlying type is a basic type of the given
+// kind. It is nil-safe and returns false for a nil type.
+func basicKind(typ types.Type, kind types.BasicKind) bool {
 	if typ == nil {
 		return false
 	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Info()&types.IsComplex != 0
+	return ok && basic.Kind() == kind
+}
+
+// basicInfo reports whether typ's underlying type is a basic type whose info
+// flags include the given flag. It is nil-safe and returns false for a nil type.
+func basicInfo(typ types.Type, flag types.BasicInfo) bool {
+	if typ == nil {
+		return false
+	}
+	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
+	return ok && basic.Info()&flag != 0
+}
+
+func isComplexType(typ types.Type) bool {
+	return basicInfo(typ, types.IsComplex)
 }
 
 func isPointerType(typ types.Type) bool {
@@ -11853,19 +12117,11 @@ func isPointerType(typ types.Type) bool {
 }
 
 func isUnsafePointerType(typ types.Type) bool {
-	if typ == nil {
-		return false
-	}
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Kind() == types.UnsafePointer
+	return basicKind(typ, types.UnsafePointer)
 }
 
 func isUintptrType(typ types.Type) bool {
-	if typ == nil {
-		return false
-	}
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Kind() == types.Uintptr
+	return basicKind(typ, types.Uintptr)
 }
 
 func channelDirectionString(dir types.ChanDir) string {
@@ -11895,35 +12151,19 @@ func unwrapParenExpr(expr ast.Expr) ast.Expr {
 }
 
 func isStringType(typ types.Type) bool {
-	if typ == nil {
-		return false
-	}
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Info()&types.IsString != 0
+	return basicInfo(typ, types.IsString)
 }
 
 func isNumericType(typ types.Type) bool {
-	if typ == nil {
-		return false
-	}
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Info()&types.IsNumeric != 0
+	return basicInfo(typ, types.IsNumeric)
 }
 
 func isIntegerType(typ types.Type) bool {
-	if typ == nil {
-		return false
-	}
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Info()&types.IsInteger != 0
+	return basicInfo(typ, types.IsInteger)
 }
 
 func isFloatType(typ types.Type) bool {
-	if typ == nil {
-		return false
-	}
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Info()&types.IsFloat != 0
+	return basicInfo(typ, types.IsFloat)
 }
 
 func unsignedIntegerBits(typ types.Type) (int, bool) {
@@ -11994,12 +12234,30 @@ func isFixedWideIntegerType(typ types.Type) bool {
 	}
 }
 
-func isFixedSignedWideIntegerType(typ types.Type) bool {
-	if typ == nil {
+// isBigIntBackedType reports whether typ lowers to a TypeScript bigint. Only the
+// fixed 64-bit Go integer types int64 and uint64 are represented as bigint to
+// preserve full-width precision and Go overflow semantics. The platform-width
+// uint and uintptr, plain int, and the narrower fixed-width integers stay number
+// so they remain usable as array indices; uint/uintptr arithmetic still routes
+// through the int64/uint64 runtime helpers and the result flows through
+// coerceWideHelperResult, which keeps values above 2^53 as a runtime bigint to
+// preserve full 64-bit width, matching design/SPEC_DIFFERENCES.md which maps
+// int64/uint64 to bigint and uint/uintptr to the number representation.
+func isBigIntBackedType(typ types.Type) bool {
+	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
+	if !ok {
+		return false
+	}
+	switch basic.Kind() {
+	case types.Int64, types.Uint64:
+		return true
+	default:
 		return false
 	}
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Kind() == types.Int64
+}
+
+func isFixedSignedWideIntegerType(typ types.Type) bool {
+	return basicKind(typ, types.Int64)
 }
 
 func isRuntimeWideIntegerType(typ types.Type) bool {
@@ -12021,13 +12279,11 @@ func isByteSliceType(typ types.Type) bool {
 }
 
 func isRuneType(typ types.Type) bool {
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Kind() == types.Int32
+	return basicKind(typ, types.Int32)
 }
 
 func isByteType(typ types.Type) bool {
-	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
-	return ok && basic.Kind() == types.Uint8
+	return basicKind(typ, types.Uint8)
 }
 
 func sliceTypeHint(typ types.Type) string {