goscript 0.0.22 → 0.0.24

package/compiler/spec-struct.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
+	"sort"
 	"strings"
 )
 
@@ -11,7 +12,7 @@ import (
 // It handles the generation of:
 //   - The class declaration.
 //   - Getters and setters for all fields (both direct and embedded).
-//   - The internal `_fields` property, which stores field values in `$.Box` containers
+//   - The internal `_fields` property, which stores field values in `$.VarRef` containers
 //     to maintain Go's value semantics.
 //   - A constructor that initializes the `_fields` and allows partial initialization.
 //   - A `clone` method for creating a deep copy of the struct instance.
@@ -23,6 +24,12 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err
 	}
+
+	// Write type parameters if present (for generics)
+	if a.TypeParams != nil {
+		c.WriteTypeParameters(a.TypeParams)
+	}
+
 	c.tsw.WriteLiterally(" ")
 	c.tsw.WriteLine("{")
 	c.tsw.Indent(1)
@@ -76,7 +83,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			fieldKeyName = field.Name()
 		}
 		fieldTsType := c.getTypeString(field.Type())
-		c.tsw.WriteLinef("%s: $.Box<%s>;", fieldKeyName, fieldTsType)
+		c.tsw.WriteLinef("%s: $.VarRef<%s>;", fieldKeyName, fieldTsType)
 	}
 	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
@@ -104,7 +111,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 				fieldKeyName = field.Name()
 			}
 
-			c.writeBoxedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
+			c.writeVarRefedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
 
 			if i < numFields-1 {
 				c.tsw.WriteLine(",")
@@ -121,9 +128,25 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("")
 
 	// Generate the clone method
-	c.tsw.WriteLinef("public clone(): %s {", className)
+	cloneReturnType := className
+	if a.TypeParams != nil && len(a.TypeParams.List) > 0 {
+		cloneReturnType += "<"
+		first := true
+		for _, field := range a.TypeParams.List {
+			for _, name := range field.Names {
+				if !first {
+					cloneReturnType += ", "
+				}
+				first = false
+				cloneReturnType += name.Name
+			}
+		}
+		cloneReturnType += ">"
+	}
+
+	c.tsw.WriteLinef("public clone(): %s {", cloneReturnType)
 	c.tsw.Indent(1)
-	c.tsw.WriteLinef("const cloned = new %s()", className)
+	c.tsw.WriteLinef("const cloned = new %s()", cloneReturnType)
 	c.tsw.WriteLine("cloned._fields = {")
 	c.tsw.Indent(1)
 
@@ -164,7 +187,18 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			if starExpr, ok := recvType.(*ast.StarExpr); ok {
 				recvType = starExpr.X
 			}
-			if ident, ok := recvType.(*ast.Ident); ok && ident.Name == className {
+
+			// Check for both simple identifiers (Pair) and generic types (Pair[T])
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = ident.Name
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = ident.Name
+				}
+			}
+
+			if recvTypeName == className {
 				c.tsw.WriteLine("")
 				if err := c.WriteFuncDeclAsMethod(funcDecl); err != nil {
 					return err
@@ -292,21 +326,21 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 					}
 					c.tsw.WriteLiterally(paramName)
 					c.tsw.WriteLiterally(": ")
-					c.WriteGoType(param.Type())
+					c.WriteGoType(param.Type(), GoTypeContextGeneral)
 				}
 				c.tsw.WriteLiterally(")")
 				results := sig.Results()
 				if results.Len() > 0 {
 					c.tsw.WriteLiterally(": ")
 					if results.Len() == 1 {
-						c.WriteGoType(results.At(0).Type())
+						c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn)
 					} else {
 						c.tsw.WriteLiterally("[")
 						for j := 0; j < results.Len(); j++ {
 							if j > 0 {
 								c.tsw.WriteLiterally(", ")
 							}
-							c.WriteGoType(results.At(j).Type())
+							c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn)
 						}
 						c.tsw.WriteLiterally("]")
 					}
@@ -380,3 +414,100 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("}")
 	return nil
 }
+
+// generateFlattenedInitTypeString generates a TypeScript type string for the
+// initialization object passed to a Go struct's constructor (`_init` method in TypeScript).
+// The generated type is a `Partial`-like structure, `"{ Field1?: Type1, Field2?: Type2, ... }"`,
+// including all direct and promoted fields of the `structType`.
+//   - It iterates through the direct fields of the `structType`. Exported fields
+//     are included with their TypeScript types (obtained via `WriteGoType`).
+//   - For anonymous (embedded) fields, it generates a type like `EmbeddedName?: ConstructorParameters<typeof EmbeddedName>[0]`,
+//     allowing initialization of the embedded struct's fields directly within the outer struct's initializer.
+//   - It then uses `types.NewMethodSet` and checks for `types.Var` objects that are fields
+//     to find promoted fields from embedded structs, adding them to the type string if not already present.
+//
+// The resulting string is sorted by field name for deterministic output and represents
+// the shape of the object expected by the struct's TypeScript constructor.
+func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named) string {
+	if structType == nil {
+		return "{}"
+	}
+
+	// Use a map to collect unique field names and their types
+	fieldMap := make(map[string]string)
+	embeddedTypeMap := make(map[string]string) // Stores TS type string for embedded struct initializers
+
+	underlying, ok := structType.Underlying().(*types.Struct)
+	if !ok {
+		return "{}"
+	}
+
+	// First add the direct fields and track embedded types
+	for i := 0; i < underlying.NumFields(); i++ {
+		field := underlying.Field(i)
+		fieldName := field.Name()
+
+		if !field.Exported() && field.Pkg() != c.pkg.Types {
+			continue
+		}
+
+		if field.Anonymous() {
+			fieldType := field.Type()
+			isPtr := false
+			if ptr, ok := fieldType.(*types.Pointer); ok {
+				fieldType = ptr.Elem()
+				isPtr = true
+			}
+
+			if named, ok := fieldType.(*types.Named); ok {
+				embeddedName := named.Obj().Name()
+				// For embedded structs, the init type should allow providing fields of the embedded struct,
+				// or the embedded struct itself.
+				// We generate Partial<EmbeddedStructFields> | EmbeddedStructType
+				// This is complex. For now, let's use ConstructorParameters as before for simplicity,
+				// or allow the embedded struct type itself.
+				// The example `Person?: ConstructorParameters<typeof Person>[0]` is for the fields.
+				// Let's try to generate a type that allows either the embedded struct instance or its fields.
+				// This might be: `Partial<FlattenedInitType<EmbeddedName>> | EmbeddedName`
+				// For now, stick to the simpler `ConstructorParameters<typeof %s>[0]` which implies field-based init.
+				// Or, more simply, the type of the embedded struct itself if it's a pointer.
+				if isPtr {
+					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type()) // MyEmbeddedType | null
+				} else {
+					// For value-type embedded structs, allow initializing with its fields.
+					// This requires getting the flattened init type for the embedded struct.
+					// This could lead to recursion if not handled carefully.
+					// A simpler approach for now: use the embedded struct's own type.
+					// embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type())
+					// Or, using ConstructorParameters to allow field-based initialization:
+					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = fmt.Sprintf("Partial<ConstructorParameters<typeof %s>[0]>", embeddedName)
+				}
+			}
+			continue
+		}
+		fieldMap[fieldName] = c.getTypeString(field.Type())
+	}
+
+	// Promoted fields (handled by Go's embedding, init should use direct/embedded names)
+	// The current logic for `generateFlattenedInitTypeString` seems to focus on top-level
+	// settable properties in the constructor. Promoted fields are accessed via `this.promotedField`,
+	// not typically set directly in `init?` unless the embedded struct itself is named in `init?`.
+
+	// Add embedded types to the field map (these are the names of the embedded structs themselves)
+	for embeddedName, embeddedTSType := range embeddedTypeMap {
+		fieldMap[embeddedName] = embeddedTSType
+	}
+
+	var fieldNames []string
+	for name := range fieldMap {
+		fieldNames = append(fieldNames, name)
+	}
+	sort.Strings(fieldNames)
+
+	var fieldDefs []string
+	for _, fieldName := range fieldNames {
+		fieldDefs = append(fieldDefs, fmt.Sprintf("%s?: %s", fieldName, fieldMap[fieldName]))
+	}
+
+	return "{" + strings.Join(fieldDefs, ", ") + "}"
+}

package/compiler/spec-value.go

@@ -1,10 +1,10 @@
 package compiler
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
-
-	"github.com/pkg/errors"
+	"go/types"
 )
 
 // WriteValueSpec translates a Go value specification (`ast.ValueSpec`),
@@ -12,13 +12,12 @@ import (
 // declarations.
 //
 // For single variable declarations (`var x T = val` or `var x = val` or `var x T`):
-//   - It determines if the variable `x` needs to be boxed (e.g., if its address is taken)
-//     using `c.analysis.NeedsBoxed(obj)`.
-//   - If boxed: `let x: $.Box<T_ts> = $.box(initializer_ts_or_zero_ts);`
-//     The type annotation is `$.Box<T_ts>`, and the initializer is wrapped in `$.box()`.
-//   - If not boxed: `let x: T_ts = initializer_ts_or_zero_ts;`
-//     The type annotation is `T_ts`. If the initializer is `&unboxedVar`, it becomes `$.box(unboxedVar_ts)`.
-//     If the RHS is a struct value, `.clone()` is applied to maintain Go's value semantics.
+//   - It determines if the variable `x` needs to be varrefed (e.g., if its address is taken)
+//     using `c.analysis.NeedsVarRef(obj)`.
+//   - If variable referenced: `let x: $.VarRef<T_ts> = $.varRef(initializer_ts_or_zero_ts);`
+//     The type annotation is `$.VarRef<T_ts>`, and the initializer is wrapped in `$.varRef()`.
+//   - If not variable referenced: `let x: T_ts = initializer_ts_or_zero_ts;`
+//     The type annotation is `T_ts`. If the initializer is `&unvarrefedVar`, it becomes `$.varRef(unvarrefedVar_ts)`.
 //   - If no initializer is provided, the TypeScript zero value (from `WriteZeroValueForType`)
 //     is used.
 //   - Type `T` (or `T_ts`) is obtained from `obj.Type()` and translated via `WriteGoType`.
@@ -44,36 +43,114 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		name := a.Names[0]
 		obj := c.pkg.TypesInfo.Defs[name]
 		if obj == nil {
-			return errors.Errorf("could not resolve type: %v", name)
+			return fmt.Errorf("could not resolve type: %v", name)
 		}
 
 		goType := obj.Type()
-		needsBox := c.analysis.NeedsBoxed(obj) // Check if address is taken
+		needsVarRef := c.analysis.NeedsVarRef(obj) // Check if address is taken
+
+		hasInitializer := len(a.Values) > 0
+		var initializerExpr ast.Expr
+		if hasInitializer {
+			initializerExpr = a.Values[0]
+		}
+
+		// Check if the initializer will result in an $.arrayToSlice call in TypeScript
+		isSliceConversion := false
+		if hasInitializer {
+			// Case 1: Direct call to $.arrayToSlice in Go source (less common for typical array literals)
+			if callExpr, isCallExpr := initializerExpr.(*ast.CallExpr); isCallExpr {
+				if selExpr, isSelExpr := callExpr.Fun.(*ast.SelectorExpr); isSelExpr {
+					if pkgIdent, isPkgIdent := selExpr.X.(*ast.Ident); isPkgIdent && pkgIdent.Name == "$" {
+						if selExpr.Sel.Name == "arrayToSlice" {
+							isSliceConversion = true
+						}
+					}
+				}
+			}
+
+			// Case 2: Go array or slice literal, which will be compiled to $.arrayToSlice
+			// We also check if the original Go type is actually a slice or array.
+			if !isSliceConversion { // Only check if not already determined by Case 1
+				if _, isCompositeLit := initializerExpr.(*ast.CompositeLit); isCompositeLit {
+					switch goType.Underlying().(type) {
+					case *types.Slice, *types.Array:
+						isSliceConversion = true
+					}
+				}
+			}
+		}
 
 		// Start declaration
 		c.tsw.WriteLiterally("let ")
 		c.tsw.WriteLiterally(name.Name)
-		c.tsw.WriteLiterally(": ")
-
-		// Write type annotation
-		if needsBox {
-			// If boxed, the variable holds Box<OriginalGoType>
-			c.tsw.WriteLiterally("$.Box<")
-			c.WriteGoType(goType) // Write the original Go type T
-			c.tsw.WriteLiterally(">")
-		} else {
-			// If not boxed, the variable holds the translated Go type directly
-			c.WriteGoType(goType)
+
+		// Write type annotation if:
+		// 1. Not a slice conversion (normal case), OR
+		// 2. Is a slice conversion but needs varRefing (we need explicit type for $.varRef())
+		if !isSliceConversion || needsVarRef {
+			c.tsw.WriteLiterally(": ")
+			// Write type annotation
+			if needsVarRef {
+				// If varrefed, the variable holds VarRef<OriginalGoType>
+				c.tsw.WriteLiterally("$.VarRef<")
+
+				// Special case: if this is a slice conversion from an array type,
+				// we should use the slice type instead of the array type
+				if isSliceConversion {
+					if arrayType, isArray := goType.Underlying().(*types.Array); isArray {
+						// Convert [N]T to $.Slice<T>
+						c.tsw.WriteLiterally("$.Slice<")
+						c.WriteGoType(arrayType.Elem(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(">")
+					} else {
+						// For slice types, write as-is (already $.Slice<T>)
+						c.WriteGoType(goType, GoTypeContextGeneral)
+					}
+				} else {
+						c.WriteGoType(goType, GoTypeContextGeneral) // Write the original Go type T
+				}
+				c.tsw.WriteLiterally(">")
+			} else {
+				// If not varrefed, the variable holds the translated Go type directly
+				// Custom logic for non-var-ref'd pointers to structs/interfaces.
+				if ptrType, isPtr := goType.(*types.Pointer); isPtr {
+					elemType := ptrType.Elem()
+					actualElemType := elemType.Underlying() // Get the true underlying type (e.g., struct, interface, basic)
+
+					isStruct := false
+					if _, ok := actualElemType.(*types.Struct); ok {
+						isStruct = true
+					}
+
+					isInterface := false
+					if _, ok := actualElemType.(*types.Interface); ok {
+						isInterface = true
+					}
+
+					if isStruct || isInterface {
+						// For non-var-ref'd pointers to structs or interfaces,
+						// the type is T | null, not $.VarRef<T> | null.
+						c.WriteGoType(elemType, GoTypeContextGeneral) // Write the element type itself (e.g., MyStruct)
+						c.tsw.WriteLiterally(" | null")
+					} else {
+						// For other pointer types (e.g., *int, *string, *[]int, **MyStruct),
+						// or pointers to types that are not structs/interfaces,
+						// use the standard pointer type translation.
+						c.WriteGoType(goType, GoTypeContextGeneral)
+					}
+				} else {
+					// Not a pointer type, write as is.
+					c.WriteGoType(goType, GoTypeContextGeneral)
+				}
+			}
 		}
 
 		// Write initializer
 		c.tsw.WriteLiterally(" = ")
-		hasInitializer := len(a.Values) > 0
-		var initializerExpr ast.Expr
-		if hasInitializer {
-			initializerExpr = a.Values[0]
 
-			// Special case for nil pointer to struct type: (*struct{})(nil)
+		// Special case for nil pointer to struct type: (*struct{})(nil)
+		if hasInitializer {
 			if callExpr, isCallExpr := initializerExpr.(*ast.CallExpr); isCallExpr {
 				if starExpr, isStarExpr := callExpr.Fun.(*ast.StarExpr); isStarExpr {
 					if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
@@ -81,6 +158,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 						if len(callExpr.Args) == 1 {
 							if nilIdent, isIdent := callExpr.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
 								c.tsw.WriteLiterally("null")
+								c.tsw.WriteLine("") // Ensure newline after null
 								return nil
 							}
 						}
@@ -89,41 +167,41 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			}
 		}
 
-		if needsBox {
-			// Boxed variable: let v: Box<T> = $.box(init_or_zero);
-			c.tsw.WriteLiterally("$.box(")
+		if needsVarRef {
+			// VarRef variable: let v: VarRef<T> = $.varRef(init_or_zero);
+			c.tsw.WriteLiterally("$.varRef(")
 			if hasInitializer {
 				// Write the compiled initializer expression normally
 				if err := c.WriteValueExpr(initializerExpr); err != nil {
 					return err
 				}
 			} else {
-				// No initializer, box the zero value
+				// No initializer, varRef the zero value
 				c.WriteZeroValueForType(goType)
 			}
 			c.tsw.WriteLiterally(")")
 		} else {
-			// Unboxed variable: let v: T = init_or_zero;
+			// Unvarrefed variable: let v: T = init_or_zero;
 			if hasInitializer {
-				// Handle &v initializer specifically for unboxed variables
+				// Handle &v initializer specifically for unvarrefed variables
 				if unaryExpr, isUnary := initializerExpr.(*ast.UnaryExpr); isUnary && unaryExpr.Op == token.AND {
 					// Initializer is &v
-					// Check if v is boxed
-					needsBoxOperand := false
+					// Check if v is varrefed
+					needsVarRefOperand := false
 					unaryExprXIdent, ok := unaryExpr.X.(*ast.Ident)
 					if ok {
 						innerObj := c.pkg.TypesInfo.Uses[unaryExprXIdent]
-						needsBoxOperand = innerObj != nil && c.analysis.NeedsBoxed(innerObj)
+						needsVarRefOperand = innerObj != nil && c.analysis.NeedsVarRef(innerObj)
 					}
 
-					// If v is boxed, assign the box itself (v)
-					// If v is not boxed, assign $.box(v)
-					if needsBoxOperand {
+					// If v is varrefed, assign the varRef itself (v)
+					// If v is not varrefed, assign $.varRef(v)
+					if needsVarRefOperand {
 						// special handling: do not write .value here.
 						c.WriteIdent(unaryExprXIdent, false)
 					} else {
-						// &unboxedVar -> $.box(unboxedVar)
-						c.tsw.WriteLiterally("$.box(")
+						// &unvarrefedVar -> $.varRef(unvarrefedVar)
+						c.tsw.WriteLiterally("$.varRef(")
 						if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Write 'v'
 							return err
 						}

package/compiler/spec.go

@@ -78,9 +78,9 @@ func (c *GoToTSCompiler) writeGetterSetter(fieldName string, fieldType types.Typ
 	c.tsw.WriteLine("")
 }
 
-func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
+func (c *GoToTSCompiler) writeVarRefedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
 	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.box(")
+	c.tsw.WriteLiterally(": $.varRef(")
 
 	if isEmbedded {
 		if _, isPtr := fieldType.(*types.Pointer); isPtr {
@@ -112,7 +112,7 @@ func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType
 
 func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
 	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.box(")
+	c.tsw.WriteLiterally(": $.varRef(")
 
 	if isEmbedded {
 		isPointerToStruct := false
@@ -183,6 +183,12 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err
 	}
+
+	// Write type parameters if present (for generics)
+	if a.TypeParams != nil {
+		c.WriteTypeParameters(a.TypeParams)
+	}
+
 	c.tsw.WriteLiterally(" = ")
 	// Get the types.Interface from the ast.InterfaceType.
 	// For an interface definition like `type MyInterface interface { M() }`,
@@ -253,11 +259,20 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 		impName = a.Name.Name
 	}
 
-	importPath := translateGoPathToTypescriptPath(goPath)
+	// All Go package imports are mapped to the @goscript/ scope.
+	// The TypeScript compiler will resolve these using tsconfig paths to either
+	// handwritten versions (in .goscript-assets) or transpiled versions (in goscript).
+	var tsImportPath string
+	if goPath == "github.com/aperturerobotics/goscript/builtin" {
+		tsImportPath = "@goscript/builtin/builtin.js"
+	} else {
+		tsImportPath = "@goscript/" + goPath
+	}
+
 	c.analysis.Imports[impName] = &fileImport{
-		importPath: importPath,
+		importPath: tsImportPath,
 		importVars: make(map[string]struct{}),
 	}
 
-	c.tsw.WriteImport(impName, importPath+"/index.js")
+	c.tsw.WriteImport(impName, tsImportPath+"/index.js")
 }

package/compiler/stmt-assign.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"strings"
 
 	"github.com/pkg/errors"
 )
@@ -32,7 +33,7 @@ import (
 //   - Uses `writeAssignmentCore` which handles:
 //   - Blank identifier `_` on LHS (evaluates RHS for side effects).
 //   - Assignment to dereferenced pointer `*p = val` -> `p_ts!.value = val_ts`.
-//   - Short declaration `x := y`: `let x = y_ts;`. If `x` is boxed, `let x: $.Box<T> = $.box(y_ts);`.
+//   - Short declaration `x := y`: `let x = y_ts;`. If `x` is variable referenced, `let x: $.VarRef<T> = $.varRef(y_ts);`.
 //   - Regular assignment `x = y`, including compound assignments like `x += y`.
 //   - Assignment to map index `m[k] = v` using `$.mapSet`.
 //   - Struct value assignment `s1 = s2` becomes `s1 = s2.clone()` if `s2` is a struct.
@@ -43,7 +44,7 @@ import (
 // The function ensures that the number of LHS and RHS expressions matches for
 // most cases, erroring if they don't, except for specifically handled patterns
 // like multi-assign from single call or discarded channel receive.
-// It correctly applies `let` for `:=` (define) tokens and handles boxing and
+// It correctly applies `let` for `:=` (define) tokens and handles varRefing and
 // cloning semantics based on type information and analysis.
 func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	// writeMultiVarAssignFromCall handles multi-variable assignment from a single function call.
@@ -130,7 +131,7 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 						// Add type annotation if we have type information
 						if i < len(resultTypes) {
 							c.tsw.WriteLiterally(": ")
-							c.WriteGoType(resultTypes[i].Type())
+							c.WriteGoType(resultTypes[i].Type(), GoTypeContextGeneral)
 						}
 
 						c.tsw.WriteLine("")
@@ -146,6 +147,10 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				hasSelectors = true
 				break
 			}
+			if _, ok := lhsExpr.(*ast.StarExpr); ok {
+				hasSelectors = true
+				break
+			}
 		}
 
 		// If we have selector expressions, we need to ensure variables are initialized
@@ -175,6 +180,21 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 					if err := c.WriteValueExpr(selectorExpr); err != nil {
 						return fmt.Errorf("failed to write selector expression in LHS: %w", err)
 					}
+				} else if starExpr, ok := lhsExpr.(*ast.StarExpr); ok {
+					// Handle pointer dereference assignment: *p = value becomes p!.value = value
+					// Write the pointer variable directly without using WriteValueExpr
+					// because we don't want automatic .value access here
+					switch operand := starExpr.X.(type) {
+					case *ast.Ident:
+						// Write identifier without .value access
+						c.WriteIdent(operand, false)
+					default:
+						// For other expressions, use WriteValueExpr
+						if err := c.WriteValueExpr(starExpr.X); err != nil {
+							return fmt.Errorf("failed to write star expression X in LHS: %w", err)
+						}
+					}
+					c.tsw.WriteLiterally("!.value")
 				} else {
 					return errors.Errorf("unhandled LHS expression in assignment: %T", lhsExpr)
 				}
@@ -210,6 +230,21 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				if err := c.WriteValueExpr(selectorExpr); err != nil {
 					return fmt.Errorf("failed to write selector expression in LHS: %w", err)
 				}
+			} else if starExpr, ok := lhsExpr.(*ast.StarExpr); ok {
+				// Handle pointer dereference in destructuring: *p becomes p!.value
+				// Write the pointer variable directly without using WriteValueExpr
+				// because we don't want automatic .value access here
+				switch operand := starExpr.X.(type) {
+				case *ast.Ident:
+					// Write identifier without .value access
+					c.WriteIdent(operand, false)
+				default:
+					// For other expressions, use WriteValueExpr
+					if err := c.WriteValueExpr(starExpr.X); err != nil {
+						return fmt.Errorf("failed to write star expression X in destructuring: %w", err)
+					}
+				}
+				c.tsw.WriteLiterally("!.value")
 			} else {
 				// Should not happen for valid Go code in this context, but handle defensively
 				return errors.Errorf("unhandled LHS expression in destructuring: %T", lhsExpr)
@@ -392,6 +427,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		if err := c.writeAssignmentCore(exp.Lhs, exp.Rhs, exp.Tok, false); err != nil {
 			return err
 		}
+		// Handle potential inline comment for multi-variable assignment
+		c.writeInlineComment(exp)
 		c.tsw.WriteLine("") // Add newline after the statement
 		return nil
 	}
@@ -402,6 +439,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		if err := c.writeAssignmentCore(exp.Lhs, exp.Rhs, exp.Tok, addDeclaration); err != nil {
 			return err
 		}
+		// Handle potential inline comment for single assignment
+		c.writeInlineComment(exp)
 		c.tsw.WriteLine("") // Add newline after the statement
 		return nil
 	}
@@ -409,3 +448,26 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	// Should not reach here if LHS/RHS counts are valid and handled
 	return fmt.Errorf("unhandled assignment case")
 }
+
+// writeInlineComment checks for and writes any inline comments associated with the given AST node.
+// It is intended to be called immediately after writing the main statement/expression.
+func (c *GoToTSCompiler) writeInlineComment(node ast.Node) {
+	if c.pkg == nil || c.pkg.Fset == nil || !node.End().IsValid() {
+		return
+	}
+
+	file := c.pkg.Fset.File(node.End())
+	if file == nil {
+		return
+	}
+
+	endLine := file.Line(node.End())
+	// Check comments associated *directly* with the node
+	for _, cg := range c.analysis.Cmap[node] {
+		if cg.Pos().IsValid() && file.Line(cg.Pos()) == endLine && cg.Pos() > node.End() {
+			commentText := strings.TrimSpace(strings.TrimPrefix(cg.Text(), "//"))
+			c.tsw.WriteLiterally(" // " + commentText)
+			return // Only write the first inline comment found
+		}
+	}
+}

package/compiler/stmt-for.go

@@ -105,6 +105,17 @@ func (c *GoToTSCompiler) WriteStmtForInit(stmt ast.Stmt) error {
 	case *ast.ExprStmt:
 		// Handle expression statement in init
 		return c.WriteValueExpr(s.X)
+	case *ast.IncDecStmt:
+		// Handle increment/decrement in init (e.g., for i++; ...)
+		if err := c.WriteValueExpr(s.X); err != nil { // The expression (e.g., i)
+			return err
+		}
+		tokStr, ok := TokenToTs(s.Tok)
+		if !ok {
+			return errors.Errorf("unknown incdec token: %v", s.Tok)
+		}
+		c.tsw.WriteLiterally(tokStr) // The token (e.g., ++)
+		return nil
 	default:
 		return errors.Errorf("unhandled for loop init statement: %T", stmt)
 	}