goscript 0.0.58 → 0.0.59

package/compiler/stmt-range.go

@@ -55,7 +55,7 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 
 	// Handle basic types (string, integer)
 	if basic, ok := underlying.(*types.Basic); ok {
-		if basic.Info()&types.IsString != 0 {
+		if c.isStringType(iterType) {
 			return c.writeStringRange(exp)
 		} else if basic.Info()&types.IsInteger != 0 {
 			return c.writeIntegerRange(exp)
@@ -96,28 +96,6 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 
 // Helper functions
 
-func (c *GoToTSCompiler) isMapType(iterType, underlying types.Type) bool {
-	if _, ok := underlying.(*types.Map); ok {
-		return true
-	}
-	if typeParam, isTypeParam := iterType.(*types.TypeParam); isTypeParam {
-		constraint := typeParam.Constraint()
-		if constraint != nil {
-			constraintUnderlying := constraint.Underlying()
-			if iface, isInterface := constraintUnderlying.(*types.Interface); isInterface {
-				return hasMapConstraint(iface)
-			}
-		}
-	}
-	return false
-}
-
-func (c *GoToTSCompiler) isArrayOrSlice(underlying types.Type) bool {
-	_, isSlice := underlying.(*types.Slice)
-	_, isArray := underlying.(*types.Array)
-	return isArray || isSlice
-}
-
 func (c *GoToTSCompiler) isIteratorSignature(sig *types.Signature) bool {
 	params := sig.Params()
 	if params.Len() != 1 {
@@ -195,7 +173,9 @@ func (c *GoToTSCompiler) writeStringRange(exp *ast.RangeStmt) error {
 		if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
 			c.tsw.WriteLiterally("const ")
 			c.WriteIdent(ident, false)
-			c.tsw.WriteLiterally(" = _runes[i]") // TODO: should be indexVarName?
+			c.tsw.WriteLiterally(" = _runes[")
+			c.tsw.WriteLiterally(indexVarName)
+			c.tsw.WriteLiterally("]")
 			c.tsw.WriteLine("")
 		}
 	}

package/compiler/stmt.go

@@ -139,7 +139,7 @@ func (c *GoToTSCompiler) WriteStmtDecl(stmt *ast.DeclStmt) error {
 					return fmt.Errorf("failed to write type spec in declaration statement: %w", err)
 				}
 			} else {
-				c.tsw.WriteCommentLinef("unhandled spec in DeclStmt: %T", spec)
+				return fmt.Errorf("unhandled spec in DeclStmt: %T", spec)
 			}
 		}
 	} else {
@@ -213,7 +213,7 @@ func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 	case *ast.Ident:
 		// Handle named functions: go namedFunc(args)
 		// Get the object for this function
-		obj := c.pkg.TypesInfo.Uses[fun]
+		obj := c.objectOfIdent(fun)
 		if obj == nil {
 			return errors.Errorf("could not find object for function: %s", fun.Name)
 		}
@@ -255,7 +255,7 @@ func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 	case *ast.SelectorExpr:
 		// Handle selector expressions: go x.Method(args)
 		// Get the object for the selected method
-		obj := c.pkg.TypesInfo.Uses[fun.Sel]
+		obj := c.objectOfIdent(fun.Sel)
 		if obj == nil {
 			return errors.Errorf("could not find object for selected method: %s", fun.Sel.Name)
 		}
@@ -447,64 +447,22 @@ func (c *GoToTSCompiler) WriteStmtSend(exp *ast.SendStmt) error {
 func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 	// Handle optional initialization statement
 	if exp.Init != nil {
-		// Check for variable shadowing in the initialization first
-		if c.analysis.HasVariableShadowing(exp) {
-			shadowingInfo := c.analysis.GetShadowingInfo(exp)
-			if shadowingInfo != nil {
-				// Handle variable shadowing by creating temporary variables
-				for varName, tempVarName := range shadowingInfo.TempVariables {
-					c.tsw.WriteLiterally("const ")
-					c.tsw.WriteLiterally(tempVarName)
-					c.tsw.WriteLiterally(" = ")
-
-					// Check if this is a built-in function and handle it directly
-					if c.isBuiltinFunction(varName) {
-						c.tsw.WriteLiterally("$.")
-						c.tsw.WriteLiterally(varName)
-					} else {
-						// Get the original object for this shadowed variable
-						if originalObj, exists := shadowingInfo.ShadowedVariables[varName]; exists {
-							// Create an identifier with the original name and use WriteValueExpr to properly resolve it
-							originalIdent := &ast.Ident{Name: varName}
-							// Set the identifier in the Uses map so WriteValueExpr can find the object
-							c.pkg.TypesInfo.Uses[originalIdent] = originalObj
-							c.WriteValueExpr(originalIdent)
-						} else {
-							// Fallback to literal name if no object found (shouldn't happen in normal cases)
-							c.tsw.WriteLiterally(varName)
-						}
-					}
-					c.tsw.WriteLine("")
-				}
-			}
+		shadowingInfo := c.analysis.GetShadowingInfo(exp)
+
+		// Write temp variables if shadowing detected
+		if shadowingInfo != nil {
+			c.writeShadowingTempVars(shadowingInfo)
 		}
 
 		c.tsw.WriteLine("{")
 		c.tsw.Indent(1)
 
-		// Handle the initialization with or without shadowing support
-		if c.analysis.HasVariableShadowing(exp) {
-			shadowingInfo := c.analysis.GetShadowingInfo(exp)
-			if shadowingInfo != nil {
-				// Handle the initialization with shadowing support
-				if assignStmt, ok := exp.Init.(*ast.AssignStmt); ok {
-					if err := c.writeShadowedAssignmentWithoutTempVars(assignStmt, shadowingInfo); err != nil {
-						return fmt.Errorf("failed to write shadowed assignment in if init: %w", err)
-					}
-				} else {
-					// Non-assignment initialization statement
-					if err := c.WriteStmt(exp.Init); err != nil {
-						return fmt.Errorf("failed to write if initialization statement: %w", err)
-					}
-				}
-			} else {
-				// No shadowing info, write normally
-				if err := c.WriteStmt(exp.Init); err != nil {
-					return fmt.Errorf("failed to write if initialization statement: %w", err)
-				}
+		// Write initialization with shadowing support if needed
+		if assignStmt, ok := exp.Init.(*ast.AssignStmt); ok && shadowingInfo != nil {
+			if err := c.writeAssignmentWithShadowing(assignStmt, shadowingInfo); err != nil {
+				return fmt.Errorf("failed to write shadowed assignment in if init: %w", err)
 			}
 		} else {
-			// No variable shadowing, write initialization normally
 			if err := c.WriteStmt(exp.Init); err != nil {
 				return fmt.Errorf("failed to write if initialization statement: %w", err)
 			}
@@ -675,6 +633,9 @@ func (c *GoToTSCompiler) WriteStmtBlock(exp *ast.BlockStmt, suppressNewline bool
 	hasAsyncDefer := false
 	for _, stmt := range exp.List {
 		if deferStmt, ok := stmt.(*ast.DeferStmt); ok {
+			if deferStmt.Call == nil || deferStmt.Call.Fun == nil {
+				continue
+			}
 			if funcLit, ok := deferStmt.Call.Fun.(*ast.FuncLit); ok {
 				if c.analysis.IsFuncLitAsync(funcLit) {
 					hasAsyncDefer = true
@@ -682,7 +643,7 @@ func (c *GoToTSCompiler) WriteStmtBlock(exp *ast.BlockStmt, suppressNewline bool
 				}
 			} else {
 				// Check if the deferred call is to an async function
-				if c.isCallAsyncInDefer(deferStmt.Call) {
+				if c.isCallExprAsync(deferStmt.Call) {
 					hasAsyncDefer = true
 					break
 				}
@@ -854,7 +815,7 @@ func (c *GoToTSCompiler) WriteStmtSwitch(exp *ast.SwitchStmt) error {
 				return fmt.Errorf("failed to write case clause in switch statement: %w", err)
 			}
 		} else {
-			c.tsw.WriteCommentLinef("unhandled statement in switch body: %T", stmt)
+			return fmt.Errorf("unhandled statement in switch body: %T", stmt)
 		}
 	}
 
@@ -885,7 +846,7 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 		isAsyncDeferred = c.analysis.IsFuncLitAsync(funcLit)
 	} else {
 		// Check if the deferred call is to an async function
-		isAsyncDeferred = c.isCallAsyncInDefer(exp.Call)
+		isAsyncDeferred = c.isCallExprAsync(exp.Call)
 	}
 
 	// Set async prefix based on pre-computed async status
@@ -923,35 +884,6 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 	return nil
 }
 
-// isCallAsyncInDefer determines if a call expression in a defer statement is async
-func (c *GoToTSCompiler) isCallAsyncInDefer(callExpr *ast.CallExpr) bool {
-	switch fun := callExpr.Fun.(type) {
-	case *ast.Ident:
-		// Direct function call (e.g., defer myFunc())
-		if obj := c.pkg.TypesInfo.Uses[fun]; obj != nil {
-			return c.analysis.IsAsyncFunc(obj)
-		}
-	case *ast.SelectorExpr:
-		// Method call (e.g., defer handle.Release()) or package function call
-		if selection := c.pkg.TypesInfo.Selections[fun]; selection != nil {
-			// Method call on an object
-			if methodObj := selection.Obj(); methodObj != nil {
-				return c.analysis.IsAsyncFunc(methodObj)
-			}
-		} else if ident, ok := fun.X.(*ast.Ident); ok {
-			// Package-level function call (e.g., defer time.Sleep())
-			if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
-				if pkgName, isPkg := obj.(*types.PkgName); isPkg {
-					methodName := fun.Sel.Name
-					pkgPath := pkgName.Imported().Path()
-					return c.analysis.IsMethodAsync(pkgPath, "", methodName)
-				}
-			}
-		}
-	}
-	return false
-}
-
 // WriteStmtLabeled handles labeled statements (ast.LabeledStmt), such as "label: statement".
 // In TypeScript, labels cannot be used with variable declarations, so we need to handle this case specially.
 func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
@@ -992,10 +924,10 @@ func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
 	return nil
 }
 
-// writeShadowedAssignment writes an assignment statement that has variable shadowing,
-// using pre-computed identifier mappings from analysis instead of dynamic context.
-func (c *GoToTSCompiler) writeShadowedAssignment(stmt *ast.AssignStmt, shadowingInfo *ShadowingInfo) error {
-	// First, create temporary variables for the shadowed variables
+// ============ Variable Shadowing Support ============
+
+// writeShadowingTempVars creates temporary variables for shadowed variables
+func (c *GoToTSCompiler) writeShadowingTempVars(shadowingInfo *ShadowingInfo) {
 	for varName, tempVarName := range shadowingInfo.TempVariables {
 		c.tsw.WriteLiterally("const ")
 		c.tsw.WriteLiterally(tempVarName)
@@ -1020,94 +952,20 @@ func (c *GoToTSCompiler) writeShadowedAssignment(stmt *ast.AssignStmt, shadowing
 		}
 		c.tsw.WriteLine("")
 	}
-
-	// Now write the LHS variables (these are new declarations)
-	for i, lhsExpr := range stmt.Lhs {
-		if i > 0 {
-			c.tsw.WriteLiterally(", ")
-		}
-
-		if ident, ok := lhsExpr.(*ast.Ident); ok {
-			if ident.Name == "_" {
-				c.tsw.WriteLiterally("_")
-			} else {
-				c.tsw.WriteLiterally("let ")
-				c.WriteIdent(ident, false) // Don't use temp variable for LHS
-			}
-		} else {
-			// For non-identifier LHS (shouldn't happen in := assignments), write normally
-			if err := c.WriteValueExpr(lhsExpr); err != nil {
-				return err
-			}
-		}
-	}
-
-	c.tsw.WriteLiterally(" = ")
-
-	// Write RHS expressions - but we need to replace shadowed variables with temporary variables
-	for i, rhsExpr := range stmt.Rhs {
-		if i > 0 {
-			c.tsw.WriteLiterally(", ")
-		}
-		if err := c.writeShadowedRHSExpression(rhsExpr, shadowingInfo); err != nil {
-			return err
-		}
-	}
-
-	c.tsw.WriteLine("")
-	return nil
 }
 
-// writeShadowedAssignmentWithoutTempVars writes an assignment statement that has variable shadowing,
-// but assumes temporary variables have already been created outside this scope.
-func (c *GoToTSCompiler) writeShadowedAssignmentWithoutTempVars(stmt *ast.AssignStmt, shadowingInfo *ShadowingInfo) error {
-	if len(stmt.Rhs) == 1 {
-		if typeAssert, isTypeAssert := stmt.Rhs[0].(*ast.TypeAssertExpr); isTypeAssert {
-			if len(stmt.Lhs) != 2 {
-				return fmt.Errorf("type assertion assignment requires 2 LHS, got %d", len(stmt.Lhs))
-			}
-			valueExpr := stmt.Lhs[0]
-			okExpr := stmt.Lhs[1]
-			valueIdent, valueIsIdent := valueExpr.(*ast.Ident)
-			okIdent, okIsIdent := okExpr.(*ast.Ident)
-			if valueIsIdent && okIsIdent {
-				valueName := valueIdent.Name
-				okName := okIdent.Name
-				valueIsBlank := valueName == "_"
-				okIsBlank := okName == "_"
-				if valueIsBlank && okIsBlank {
-					// Both blank, evaluate RHS for side effects
-					if err := c.writeShadowedRHSExpression(typeAssert.X, shadowingInfo); err != nil {
-						return err
-					}
-					c.tsw.WriteLine("")
-					return nil
-				}
-				c.tsw.WriteLiterally("let { ")
-				var parts []string
-				if !valueIsBlank {
-					parts = append(parts, "value: "+valueName)
-				}
-				if !okIsBlank {
-					parts = append(parts, "ok: "+okName)
-				}
-				c.tsw.WriteLiterally(strings.Join(parts, ", "))
-				c.tsw.WriteLiterally(" } = $.typeAssert<")
-				c.WriteTypeExpr(typeAssert.Type)
-				c.tsw.WriteLiterally(">(")
-				if err := c.writeShadowedRHSExpression(typeAssert.X, shadowingInfo); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally(", ")
-				c.writeTypeDescription(typeAssert.Type)
-				c.tsw.WriteLiterally(")")
-				c.tsw.WriteLine("")
-				return nil
-			}
+// writeAssignmentWithShadowing writes an assignment statement that has variable shadowing.
+// Handles both regular assignments and type assertions, with optional temp variable creation.
+func (c *GoToTSCompiler) writeAssignmentWithShadowing(stmt *ast.AssignStmt, shadowingInfo *ShadowingInfo) error {
+	// Check for type assertion special case
+	if len(stmt.Rhs) == 1 && len(stmt.Lhs) == 2 {
+		if typeAssert, ok := stmt.Rhs[0].(*ast.TypeAssertExpr); ok {
+			return c.writeTypeAssertWithShadowing(stmt, typeAssert, shadowingInfo)
 		}
 	}
 
-	var firstDecl = true
+	// Regular assignment: write LHS declarations
+	firstDecl := true
 	for i, lhsExpr := range stmt.Lhs {
 		if i > 0 {
 			c.tsw.WriteLiterally(", ")
@@ -1128,12 +986,14 @@ func (c *GoToTSCompiler) writeShadowedAssignmentWithoutTempVars(stmt *ast.Assign
 			}
 		}
 	}
+
+	// Write RHS with shadowed variable substitution
 	c.tsw.WriteLiterally(" = ")
 	for i, rhsExpr := range stmt.Rhs {
 		if i > 0 {
 			c.tsw.WriteLiterally(", ")
 		}
-		if err := c.writeShadowedRHSExpression(rhsExpr, shadowingInfo); err != nil {
+		if err := c.substituteExprForShadowing(rhsExpr, shadowingInfo); err != nil {
 			return err
 		}
 	}
@@ -1141,8 +1001,54 @@ func (c *GoToTSCompiler) writeShadowedAssignmentWithoutTempVars(stmt *ast.Assign
 	return nil
 }
 
-// writeShadowedRHSExpression writes a RHS expression, replacing shadowed variables with temporary variables
-func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo *ShadowingInfo) error {
+// writeTypeAssertWithShadowing writes a type assertion assignment (v, ok := x.(T)) with shadowing support
+func (c *GoToTSCompiler) writeTypeAssertWithShadowing(stmt *ast.AssignStmt, typeAssert *ast.TypeAssertExpr, shadowingInfo *ShadowingInfo) error {
+	valueIdent, valueIsIdent := stmt.Lhs[0].(*ast.Ident)
+	okIdent, okIsIdent := stmt.Lhs[1].(*ast.Ident)
+
+	if !valueIsIdent || !okIsIdent {
+		return fmt.Errorf("type assertion LHS must be identifiers")
+	}
+
+	valueName := valueIdent.Name
+	okName := okIdent.Name
+	valueIsBlank := valueName == "_"
+	okIsBlank := okName == "_"
+
+	if valueIsBlank && okIsBlank {
+		// Both blank, evaluate RHS for side effects only
+		if err := c.substituteExprForShadowing(typeAssert.X, shadowingInfo); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("")
+		return nil
+	}
+
+	// Destructure into value and ok
+	c.tsw.WriteLiterally("let { ")
+	var parts []string
+	if !valueIsBlank {
+		parts = append(parts, "value: "+valueName)
+	}
+	if !okIsBlank {
+		parts = append(parts, "ok: "+okName)
+	}
+	c.tsw.WriteLiterally(strings.Join(parts, ", "))
+	c.tsw.WriteLiterally(" } = $.typeAssert<")
+	c.WriteTypeExpr(typeAssert.Type)
+	c.tsw.WriteLiterally(">(")
+	if err := c.substituteExprForShadowing(typeAssert.X, shadowingInfo); err != nil {
+		return err
+	}
+	c.tsw.WriteLiterally(", ")
+	c.writeTypeDescription(typeAssert.Type)
+	c.tsw.WriteLiterally(")")
+	c.tsw.WriteLine("")
+	return nil
+}
+
+// substituteExprForShadowing writes an expression, replacing shadowed variables with temporary variables
+func (c *GoToTSCompiler) substituteExprForShadowing(expr ast.Expr, shadowingInfo *ShadowingInfo) error {
 	switch e := expr.(type) {
 	case *ast.Ident:
 		// Check if this identifier is a shadowed variable
@@ -1157,7 +1063,7 @@ func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo
 
 	case *ast.CallExpr:
 		// Handle function calls - replace identifiers in arguments with temp variables
-		if err := c.writeShadowedRHSExpression(e.Fun, shadowingInfo); err != nil {
+		if err := c.substituteExprForShadowing(e.Fun, shadowingInfo); err != nil {
 			return err
 		}
 
@@ -1169,7 +1075,7 @@ func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo
 			if i > 0 {
 				c.tsw.WriteLiterally(", ")
 			}
-			if err := c.writeShadowedRHSExpression(arg, shadowingInfo); err != nil {
+			if err := c.substituteExprForShadowing(arg, shadowingInfo); err != nil {
 				return err
 			}
 		}
@@ -1178,7 +1084,7 @@ func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo
 
 	case *ast.SelectorExpr:
 		// Handle selector expressions (e.g., obj.Method)
-		if err := c.writeShadowedRHSExpression(e.X, shadowingInfo); err != nil {
+		if err := c.substituteExprForShadowing(e.X, shadowingInfo); err != nil {
 			return err
 		}
 		c.tsw.WriteLiterally(".")
@@ -1187,11 +1093,11 @@ func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo
 
 	case *ast.IndexExpr:
 		// Handle index expressions (e.g., arr[i])
-		if err := c.writeShadowedRHSExpression(e.X, shadowingInfo); err != nil {
+		if err := c.substituteExprForShadowing(e.X, shadowingInfo); err != nil {
 			return err
 		}
 		c.tsw.WriteLiterally("[")
-		if err := c.writeShadowedRHSExpression(e.Index, shadowingInfo); err != nil {
+		if err := c.substituteExprForShadowing(e.Index, shadowingInfo); err != nil {
 			return err
 		}
 		c.tsw.WriteLiterally("]")
@@ -1200,22 +1106,22 @@ func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo
 	case *ast.UnaryExpr:
 		// Handle unary expressions (e.g., &x, -x)
 		c.tsw.WriteLiterally(e.Op.String())
-		return c.writeShadowedRHSExpression(e.X, shadowingInfo)
+		return c.substituteExprForShadowing(e.X, shadowingInfo)
 
 	case *ast.BinaryExpr:
 		// Handle binary expressions (e.g., x + y)
-		if err := c.writeShadowedRHSExpression(e.X, shadowingInfo); err != nil {
+		if err := c.substituteExprForShadowing(e.X, shadowingInfo); err != nil {
 			return err
 		}
 		c.tsw.WriteLiterally(" ")
 		c.tsw.WriteLiterally(e.Op.String())
 		c.tsw.WriteLiterally(" ")
-		return c.writeShadowedRHSExpression(e.Y, shadowingInfo)
+		return c.substituteExprForShadowing(e.Y, shadowingInfo)
 
 	case *ast.ParenExpr:
 		// Handle parenthesized expressions
 		c.tsw.WriteLiterally("(")
-		if err := c.writeShadowedRHSExpression(e.X, shadowingInfo); err != nil {
+		if err := c.substituteExprForShadowing(e.X, shadowingInfo); err != nil {
 			return err
 		}
 		c.tsw.WriteLiterally(")")
@@ -1229,22 +1135,5 @@ func (c *GoToTSCompiler) writeShadowedRHSExpression(expr ast.Expr, shadowingInfo
 
 // isBuiltinFunction checks if the given name is a Go built-in function
 func (c *GoToTSCompiler) isBuiltinFunction(name string) bool {
-	builtins := map[string]bool{
-		"len":     true,
-		"cap":     true,
-		"make":    true,
-		"new":     true,
-		"append":  true,
-		"copy":    true,
-		"delete":  true,
-		"complex": true,
-		"real":    true,
-		"imag":    true,
-		"close":   true,
-		"panic":   true,
-		"recover": true,
-		"print":   true,
-		"println": true,
-	}
-	return builtins[name]
+	return builtinFunctions[name]
 }

package/compiler/type-utils.go

@@ -0,0 +1,185 @@
+package compiler
+
+import (
+	"go/ast"
+	"go/types"
+)
+
+// isByteSliceType checks if a type is []byte (slice of uint8)
+func (c *GoToTSCompiler) isByteSliceType(t types.Type) bool {
+	if sliceType, isSlice := t.Underlying().(*types.Slice); isSlice {
+		if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+			return true
+		}
+	}
+	return false
+}
+
+// isRuneSliceType checks if a type is []rune (slice of int32)
+func (c *GoToTSCompiler) isRuneSliceType(t types.Type) bool {
+	if sliceType, isSlice := t.Underlying().(*types.Slice); isSlice {
+		if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Int32 {
+			return true
+		}
+	}
+	return false
+}
+
+// isStringType checks if a type is string
+func (c *GoToTSCompiler) isStringType(t types.Type) bool {
+	if basic, isBasic := t.Underlying().(*types.Basic); isBasic {
+		return basic.Kind() == types.String || basic.Kind() == types.UntypedString
+	}
+	return false
+}
+
+// isPointerType checks if a type expression represents a pointer type
+func (c *GoToTSCompiler) isPointerType(expr ast.Expr) bool {
+	_, isPointer := expr.(*ast.StarExpr)
+	return isPointer
+}
+
+// isProtobufType checks if a given type is a protobuf type by examining its methods
+// and, when available, by verifying it implements the protobuf-go-lite Message interface.
+func (c *GoToTSCompiler) isProtobufType(typ types.Type) bool {
+	// Normalize to a named type if possible
+	var named *types.Named
+	switch t := typ.(type) {
+	case *types.Named:
+		named = t
+	case *types.Pointer:
+		if n, ok := t.Elem().(*types.Named); ok {
+			named = n
+		}
+	}
+	if named == nil {
+		return false
+	}
+
+	// Prefer interface-based detection when the protobuf-go-lite package is loaded
+	if iface := c.getProtobufMessageInterface(); iface != nil {
+		if types.Implements(named, iface) || types.Implements(types.NewPointer(named), iface) {
+			return true
+		}
+	}
+
+	// Fallback: method-set detection for common protobuf-go-lite methods
+	// Check both value and pointer method sets
+	if c.typeHasMethods(named, "MarshalVT", "UnmarshalVT") || c.typeHasMethods(types.NewPointer(named), "MarshalVT", "UnmarshalVT") {
+		return true
+	}
+
+	return false
+}
+
+// isNamedNumericType checks if a given type is a named type with an underlying numeric type.
+func (c *GoToTSCompiler) isNamedNumericType(t types.Type) bool {
+	finalType, wasNamed := c.getFinalUnderlyingType(t)
+	if !wasNamed {
+		return false
+	}
+
+	if basicType, isBasic := finalType.(*types.Basic); isBasic {
+		info := basicType.Info()
+		return (info&types.IsInteger) != 0 || (info&types.IsFloat) != 0
+	}
+
+	return false
+}
+
+// isWrapperType checks if a type should be treated as a wrapper type (type alias with basic underlying type).
+// Wrapper types are rendered as TypeScript type aliases rather than classes with constructors.
+// Examples: os.FileMode (uint32), MyString (string), etc.
+func (c *GoToTSCompiler) isWrapperType(t types.Type) bool {
+	// Check analysis cache first (for types with methods in analyzed packages)
+	if c.analysis.IsNamedBasicType(t) {
+		return true
+	}
+
+	// For external package types, check if it's a named type with a basic underlying type
+	if namedType, ok := t.(*types.Named); ok {
+		if _, ok := namedType.Underlying().(*types.Basic); ok {
+			return true
+		}
+	}
+
+	// Also check for type aliases with basic underlying types
+	if aliasType, ok := t.(*types.Alias); ok {
+		if _, ok := aliasType.Underlying().(*types.Basic); ok {
+			return true
+		}
+	}
+
+	return false
+}
+
+// isStructValueType checks if a type is a named struct type
+func (c *GoToTSCompiler) isStructValueType(fieldType types.Type) bool {
+	if named, ok := fieldType.(*types.Named); ok {
+		if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+			return true
+		}
+	}
+	return false
+}
+
+// isImportedBasicType checks if a type is an imported named type with a basic underlying type
+func (c *GoToTSCompiler) isImportedBasicType(fieldType types.Type) bool {
+	// Handle named types
+	if named, isNamed := fieldType.(*types.Named); isNamed {
+		obj := named.Obj()
+		if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
+			return false // Not imported or is local
+		}
+
+		underlying := named.Underlying()
+		if underlying == nil {
+			return false
+		}
+
+		_, isBasic := underlying.(*types.Basic)
+		return isBasic
+	}
+
+	// Handle type aliases (like os.FileMode = fs.FileMode)
+	if alias, isAlias := fieldType.(*types.Alias); isAlias {
+		obj := alias.Obj()
+		if obj == nil || obj.Pkg() == nil || obj.Pkg() == c.pkg.Types {
+			return false // Not imported or is local
+		}
+
+		underlying := alias.Underlying()
+		if underlying == nil {
+			return false
+		}
+
+		_, isBasic := underlying.(*types.Basic)
+		return isBasic
+	}
+
+	return false
+}
+
+// isMapType checks if a type is a map type (including type parameters constrained to maps)
+func (c *GoToTSCompiler) isMapType(iterType, underlying types.Type) bool {
+	if _, ok := underlying.(*types.Map); ok {
+		return true
+	}
+	if typeParam, isTypeParam := iterType.(*types.TypeParam); isTypeParam {
+		constraint := typeParam.Constraint()
+		if constraint != nil {
+			constraintUnderlying := constraint.Underlying()
+			if iface, isInterface := constraintUnderlying.(*types.Interface); isInterface {
+				return hasMapConstraint(iface)
+			}
+		}
+	}
+	return false
+}
+
+// isArrayOrSlice checks if a type is an array or slice type
+func (c *GoToTSCompiler) isArrayOrSlice(underlying types.Type) bool {
+	_, isSlice := underlying.(*types.Slice)
+	_, isArray := underlying.(*types.Array)
+	return isArray || isSlice
+}