goscript 0.0.20 → 0.0.22

package/compiler/expr-selector.go

@@ -0,0 +1,105 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/types"
+)
+
+// WriteSelectorExpr translates a Go selector expression (`ast.SelectorExpr`)
+// used as a value (e.g., `obj.Field`, `pkg.Variable`, `structVar.Method()`)
+// into its TypeScript equivalent.
+// It distinguishes between package selectors (e.g., `time.Now`) and field/method
+// access on an object or struct.
+//   - For package selectors, it writes `PackageName.IdentifierName`. The `IdentifierName`
+//     is written using `WriteIdent` which handles potential `.value` access if the
+//     package-level variable is boxed.
+//   - For field or method access on an object (`exp.X`), it first writes the base
+//     expression (`exp.X`) using `WriteValueExpr` (which handles its own boxing).
+//     Then, it writes a dot (`.`) followed by the selected identifier (`exp.Sel`)
+//     using `WriteIdent`, which appends `.value` if the field itself is boxed
+//     (e.g., accessing a field of primitive type through a pointer to a struct
+//     where the field's address might have been taken).
+//
+// This function aims to correctly navigate Go's automatic dereferencing and
+// TypeScript's explicit boxing model.
+func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
+	// Check if this is a package selector (e.g., time.Now)
+	if pkgIdent, isPkgIdent := exp.X.(*ast.Ident); isPkgIdent {
+		if obj := c.pkg.TypesInfo.ObjectOf(pkgIdent); obj != nil {
+			if _, isPkg := obj.(*types.PkgName); isPkg {
+				// Package selectors should never use .value on the package name
+				c.tsw.WriteLiterally(pkgIdent.Name)
+				c.tsw.WriteLiterally(".")
+				// Write the selected identifier, allowing .value if it's a boxed package variable
+				c.WriteIdent(exp.Sel, true)
+				return nil
+			}
+		}
+	}
+
+	// --- Special case for dereferenced pointer to struct with field access: (*p).field ---
+	var baseExpr ast.Expr = exp.X
+	// Look inside parentheses if present
+	if parenExpr, isParen := exp.X.(*ast.ParenExpr); isParen {
+		baseExpr = parenExpr.X
+	}
+
+	if starExpr, isStarExpr := baseExpr.(*ast.StarExpr); isStarExpr {
+		// Get the type of the pointer being dereferenced (e.g., type of 'p' in *p)
+		ptrType := c.pkg.TypesInfo.TypeOf(starExpr.X)
+		if ptrType != nil {
+			if ptrTypeUnwrapped, ok := ptrType.(*types.Pointer); ok {
+				elemType := ptrTypeUnwrapped.Elem()
+				if elemType != nil {
+					// If it's a pointer to a struct, handle field access specially
+					if _, isStruct := elemType.Underlying().(*types.Struct); isStruct {
+						// Get the object for the pointer variable itself (e.g., 'p')
+						var ptrObj types.Object
+						if ptrIdent, isIdent := starExpr.X.(*ast.Ident); isIdent {
+							ptrObj = c.pkg.TypesInfo.ObjectOf(ptrIdent)
+						}
+
+						// Write the pointer expression (e.g., p or p.value if p is boxed)
+						if err := c.WriteValueExpr(starExpr.X); err != nil {
+							return fmt.Errorf("failed to write pointer expression for (*p).field: %w", err)
+						}
+
+						// Add ! for non-null assertion
+						c.tsw.WriteLiterally("!")
+
+						// Add .value ONLY if the pointer variable itself needs boxed access
+						// This handles the case where 'p' points to a boxed struct (e.g., p = s where s is Box<MyStruct>)
+						if ptrObj != nil && c.analysis.NeedsBoxedAccess(ptrObj) {
+							c.tsw.WriteLiterally(".value")
+						}
+
+						// Add .field
+						c.tsw.WriteLiterally(".")
+						c.WriteIdent(exp.Sel, false) // Don't add .value to the field itself
+						return nil
+					}
+				}
+			}
+		}
+	}
+	// --- End Special Case ---
+
+	// Fallback / Normal Case (e.g., obj.Field, pkg.Var, method calls)
+	// WriteValueExpr handles adding .value for the base variable itself if it's boxed.
+	if err := c.WriteValueExpr(exp.X); err != nil {
+		return fmt.Errorf("failed to write selector base expression: %w", err)
+	}
+
+	// Add .
+	c.tsw.WriteLiterally(".")
+
+	// Write the field/method name.
+	// Pass 'true' to WriteIdent to potentially add '.value' if the field itself
+	// needs boxed access (e.g., accessing a primitive field via pointer where
+	// the field's address might have been taken elsewhere - less common but possible).
+	// For simple struct field access like p.Val or (*p).Val, WriteIdent(..., true)
+	// relies on NeedsBoxedAccess for the field 'Val', which should typically be false.
+	c.WriteIdent(exp.Sel, true)
+	return nil
+}

package/compiler/expr-star.go

@@ -0,0 +1,90 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+)
+
+// WriteStarExpr translates a Go pointer dereference expression (`ast.StarExpr`, e.g., `*p`)
+// into its TypeScript equivalent. This involves careful handling of Go's pointers
+// and TypeScript's boxing mechanism for emulating pointer semantics.
+//
+// The translation depends on whether the pointer variable `p` itself is boxed and
+// what type of value it points to:
+//  1. If `p` is not boxed and points to a primitive or another pointer: `*p` -> `p!.value`.
+//     (`p` holds a box, so dereference accesses its `value` field).
+//  2. If `p` is not boxed and points to a struct: `*p` -> `p!`.
+//     (`p` holds the struct instance directly; structs are reference types in TS).
+//  3. If `p` is boxed (i.e., `p` is `$.Box<PointerType>`) and points to a primitive/pointer:
+//     `*p` -> `p.value!.value`.
+//     (First `.value` unboxes `p`, then `!.value` dereferences the inner pointer).
+//  4. If `p` is boxed and points to a struct: `*p` -> `p.value!`.
+//     (First `.value` unboxes `p` to get the struct instance).
+//
+// `WriteValueExpr(operand)` handles the initial unboxing of `p` if `p` itself is a boxed variable.
+// A non-null assertion `!` is always added as pointers can be nil.
+// `c.analysis.NeedsBoxedDeref(ptrType)` determines if an additional `.value` is needed
+// based on whether the dereferenced type is a primitive/pointer (requires `.value`) or
+// a struct (does not require `.value`).
+func (c *GoToTSCompiler) WriteStarExpr(exp *ast.StarExpr) error {
+	// Generate code for a pointer dereference expression (*p).
+	//
+	// IMPORTANT: Pointer dereferencing in TypeScript requires careful handling of the box/unbox state:
+	//
+	// 1. p!.value - when p is not boxed and points to a primitive/pointer
+	//    Example: let p = x (where x is a box) => p!.value
+	//
+	// 2. p!       - when p is not boxed and points to a struct
+	//    Example: let p = new MyStruct() => p! (structs are reference types)
+	//
+	// 3. p.value!.value - when p is boxed and points to a primitive/pointer
+	//    Example: let p = $.box(x) (where x is another box) => p.value!.value
+	//
+	// 4. p.value! - when p is boxed and points to a struct
+	//    Example: let p = $.box(new MyStruct()) => p.value!
+	//
+	// Critical bug fix: We must handle each case correctly to avoid over-dereferencing
+	// (adding too many .value) or under-dereferencing (missing .value where needed)
+	//
+	// NOTE: This logic aligns with design/BOXES_POINTERS.md.
+
+	// Get the operand expression and its type information
+	operand := exp.X
+
+	// Get the type of the operand (the pointer being dereferenced)
+	ptrType := c.pkg.TypesInfo.TypeOf(operand)
+
+	// Special case for handling multi-level dereferencing:
+	// Check if the operand is itself a StarExpr (e.g., **p or ***p)
+	// We need to handle these specially to correctly generate nested .value accesses
+	if starExpr, isStarExpr := operand.(*ast.StarExpr); isStarExpr {
+		// First, write the inner star expression
+		if err := c.WriteStarExpr(starExpr); err != nil {
+			return fmt.Errorf("failed to write inner star expression: %w", err)
+		}
+
+		// Always add .value for multi-level dereferences
+		// For expressions like **p, each * adds a .value
+		c.tsw.WriteLiterally("!.value")
+		return nil
+	}
+
+	// Standard case: single-level dereference
+	// Write the pointer expression, which will access .value if the variable is boxed
+	// WriteValueExpr will add .value if the variable itself is boxed (p.value)
+	if err := c.WriteValueExpr(operand); err != nil {
+		return fmt.Errorf("failed to write star expression operand: %w", err)
+	}
+
+	// Add ! for null assertion - all pointers can be null in TypeScript
+	c.tsw.WriteLiterally("!")
+
+	// Add .value only if we need boxed dereferencing for this type of pointer
+	// This depends on whether we're dereferencing to a primitive (needs .value)
+	// or to a struct (no .value needed)
+	if c.analysis.NeedsBoxedDeref(ptrType) {
+		c.tsw.WriteLiterally(".value")
+	}
+
+	return nil
+}

package/compiler/expr-type.go

@@ -0,0 +1,182 @@
+package compiler
+
+import (
+	"go/ast"
+	"go/types"
+)
+
+// WriteTypeExpr translates a Go abstract syntax tree (AST) expression (`ast.Expr`)
+// that represents a type into its TypeScript type equivalent using type information.
+//
+// It handles various Go type expressions:
+// - Basic types (e.g., int, string, bool) -> TypeScript primitives (number, string, boolean)
+// - Named types -> TypeScript class/interface names
+// - Pointer types (`*T`) -> `$.Box<T_ts> | null`
+// - Slice types (`[]T`) -> `$.Slice<T_ts>`
+// - Array types (`[N]T`) -> `T_ts[]`
+// - Map types (`map[K]V`) -> `Map<K_ts, V_ts>`
+// - Channel types (`chan T`) -> `$.Channel<T_ts>`
+// - Struct types -> TypeScript object types or class names
+// - Interface types -> TypeScript interface types or "any"
+// - Function types -> TypeScript function signatures
+func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
+	// Get type information for the expression and use WriteGoType
+	typ := c.pkg.TypesInfo.TypeOf(a)
+	c.WriteGoType(typ)
+}
+
+// writeTypeDescription writes the TypeInfo for a type expr.
+func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
+	switch t := typeExpr.(type) {
+	case *ast.Ident:
+		if isPrimitiveType(t.Name) {
+			if tsType, ok := GoBuiltinToTypescript(t.Name); ok {
+				c.tsw.WriteLiterally("{")
+				c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
+				c.tsw.WriteLiterallyf("name: '%s'", tsType)
+				c.tsw.WriteLiterally("}")
+			} else {
+				// Fallback for other primitive types
+				c.tsw.WriteLiterally("{")
+				c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
+				c.tsw.WriteLiterallyf("name: '%s'", t.Name)
+				c.tsw.WriteLiterally("}")
+			}
+		} else {
+			// For named types, just use the name string
+			c.tsw.WriteLiterallyf("'%s'", t.Name)
+		}
+	case *ast.SelectorExpr:
+		if ident, ok := t.X.(*ast.Ident); ok {
+			c.tsw.WriteLiterallyf("'%s.%s'", ident.Name, t.Sel.Name)
+		}
+	case *ast.ArrayType:
+		typeKind := "$.TypeKind.Slice"
+		if t.Len != nil {
+			typeKind = "$.TypeKind.Array"
+		}
+
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterallyf("kind: %s, ", typeKind)
+		c.tsw.WriteLiterally("elemType: ")
+		c.writeTypeDescription(t.Elt)
+		c.tsw.WriteLiterally("}")
+	case *ast.StructType:
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Struct, ")
+
+		// Add field names and types to the struct type info
+		if t.Fields != nil && t.Fields.List != nil {
+			c.tsw.WriteLiterally("fields: {")
+
+			hasFields := false
+			for _, field := range t.Fields.List {
+				if len(field.Names) > 0 {
+					for _, name := range field.Names {
+						if hasFields {
+							c.tsw.WriteLiterally(", ")
+						}
+						c.tsw.WriteLiterallyf("'%s': ", name.Name)
+						c.writeTypeDescription(field.Type)
+						hasFields = true
+					}
+				}
+			}
+
+			c.tsw.WriteLiterally("}, ")
+		} else {
+			c.tsw.WriteLiterally("fields: {}, ")
+		}
+
+		c.tsw.WriteLiterally("methods: []")
+
+		c.tsw.WriteLiterally("}")
+	case *ast.MapType:
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Map, ")
+		c.tsw.WriteLiterally("keyType: ")
+		c.writeTypeDescription(t.Key)
+		c.tsw.WriteLiterally(", ")
+		c.tsw.WriteLiterally("elemType: ")
+		c.writeTypeDescription(t.Value)
+		c.tsw.WriteLiterally("}")
+	case *ast.StarExpr:
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Pointer, ")
+		c.tsw.WriteLiterally("elemType: ")
+		c.writeTypeDescription(t.X)
+		c.tsw.WriteLiterally("}")
+	case *ast.FuncType:
+		// For function types, create a type descriptor object with params and results
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Function")
+
+		// Add name if this is a named function type
+		if namedType := c.pkg.TypesInfo.TypeOf(typeExpr); namedType != nil {
+			if named, ok := namedType.(*types.Named); ok {
+				c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
+			}
+		}
+
+		// Add params if present
+		if t.Params != nil && len(t.Params.List) > 0 {
+			c.tsw.WriteLiterally(", params: [")
+			for i, param := range t.Params.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.writeTypeDescription(param.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+
+		// Add results if present
+		if t.Results != nil && len(t.Results.List) > 0 {
+			c.tsw.WriteLiterally(", results: [")
+			for i, result := range t.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.writeTypeDescription(result.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+
+		c.tsw.WriteLiterally("}")
+		return
+	case *ast.ChanType:
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Channel, ")
+		c.tsw.WriteLiterally("elemType: ")
+
+		// Add element type
+		if ident, ok := t.Value.(*ast.Ident); ok && isPrimitiveType(ident.Name) {
+			if tsType, ok := GoBuiltinToTypescript(ident.Name); ok {
+				c.tsw.WriteLiterallyf("'%s'", tsType)
+			} else {
+				c.tsw.WriteLiterallyf("'%s'", ident.Name) // Fallback
+			}
+		} else {
+			c.writeTypeDescription(t.Value)
+		}
+
+		// Add direction
+		c.tsw.WriteLiterally(", direction: ")
+		switch t.Dir {
+		case ast.SEND:
+			c.tsw.WriteLiterally("'send'")
+		case ast.RECV:
+			c.tsw.WriteLiterally("'receive'")
+		case ast.SEND | ast.RECV: // bidirectional
+			c.tsw.WriteLiterally("'both'")
+		default:
+			// This should not happen, but just in case
+			c.tsw.WriteLiterally("'both'")
+		}
+
+		c.tsw.WriteLiterally("}")
+	default:
+		// For other types, use the string representation
+		c.tsw.WriteLiterallyf("'%s'", c.getTypeNameString(typeExpr))
+	}
+}

package/compiler/expr-value.go

@@ -0,0 +1,119 @@
+package compiler
+
+import "go/ast"
+
+// WriteValueExpr translates a Go abstract syntax tree (AST) expression (`ast.Expr`)
+// that represents a value into its TypeScript value equivalent.
+// This is a central dispatch function for various expression types:
+// - Identifiers (`ast.Ident`): Delegates to `WriteIdent`, potentially adding `.value` for boxed variables.
+// - Selector expressions (`ast.SelectorExpr`, e.g., `obj.Field` or `pkg.Var`): Delegates to `WriteSelectorExpr`.
+// - Pointer dereferences (`ast.StarExpr`, e.g., `*ptr`): Delegates to `WriteStarExpr`.
+// - Function calls (`ast.CallExpr`): Delegates to `WriteCallExpr`.
+// - Unary operations (`ast.UnaryExpr`, e.g., `!cond`, `&val`): Delegates to `WriteUnaryExpr`.
+// - Binary operations (`ast.BinaryExpr`, e.g., `a + b`): Delegates to `WriteBinaryExpr`.
+// - Basic literals (`ast.BasicLit`, e.g., `123`, `"hello"`): Delegates to `WriteBasicLit`.
+// - Composite literals (`ast.CompositeLit`, e.g., `MyStruct{}`): Delegates to `WriteCompositeLit`.
+// - Key-value expressions (`ast.KeyValueExpr`): Delegates to `WriteKeyValueExpr`.
+// - Type assertions in expression context (`ast.TypeAssertExpr`, e.g., `val.(Type)`): Delegates to `WriteTypeAssertExpr`.
+// - Index expressions (`ast.IndexExpr`):
+//   - For maps: `myMap[key]` becomes `myMap.get(key) ?? zeroValue`.
+//   - For arrays/slices: `myArray[idx]` becomes `myArray![idx]`.
+//
+// - Slice expressions (`ast.SliceExpr`, e.g., `s[low:high:max]`): Translates to `$.slice(s, low, high, max)`.
+// - Parenthesized expressions (`ast.ParenExpr`): Translates `(X)` to `(X)`.
+// - Function literals (`ast.FuncLit`): Delegates to `WriteFuncLitValue`.
+// Unhandled value expressions result in a comment.
+func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
+	switch exp := a.(type) {
+	case *ast.Ident:
+		c.WriteIdent(exp, true) // adds .value accessor
+		return nil
+	case *ast.SelectorExpr:
+		return c.WriteSelectorExpr(exp)
+	case *ast.StarExpr:
+		return c.WriteStarExpr(exp)
+	case *ast.CallExpr:
+		return c.WriteCallExpr(exp)
+	case *ast.UnaryExpr:
+		return c.WriteUnaryExpr(exp)
+	case *ast.BinaryExpr:
+		return c.WriteBinaryExpr(exp)
+	case *ast.BasicLit:
+		c.WriteBasicLit(exp)
+		return nil
+	case *ast.CompositeLit:
+		return c.WriteCompositeLit(exp)
+	case *ast.KeyValueExpr:
+		return c.WriteKeyValueExpr(exp)
+	case *ast.TypeAssertExpr:
+		// Handle type assertion in an expression context
+		return c.WriteTypeAssertExpr(exp)
+	case *ast.IndexExpr:
+		return c.WriteIndexExpr(exp)
+	case *ast.SliceExpr:
+		// Translate Go slice expression to $.goSlice(x, low, high, max)
+		c.tsw.WriteLiterally("$.goSlice(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		// low argument
+		c.tsw.WriteLiterally(", ")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		// high argument
+		c.tsw.WriteLiterally(", ")
+		if exp.High != nil {
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		// max argument (only for full slice expressions)
+		if exp.Slice3 {
+			c.tsw.WriteLiterally(", ")
+			if exp.Max != nil {
+				if err := c.WriteValueExpr(exp.Max); err != nil {
+					return err
+				}
+			} else {
+				c.tsw.WriteLiterally("undefined")
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	case *ast.ParenExpr:
+		// Check if this is a nil pointer to struct type cast: (*struct{})(nil)
+		if starExpr, isStarExpr := exp.X.(*ast.StarExpr); isStarExpr {
+			if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
+				c.tsw.WriteLiterally("null")
+				return nil
+			}
+		}
+
+		// Check if this is a type cast with nil: (SomeType)(nil)
+		if ident, isIdent := exp.X.(*ast.Ident); isIdent && ident.Name == "nil" {
+			c.tsw.WriteLiterally("null")
+			return nil
+		}
+
+		// Translate (X) to (X)
+		// If we haven't written anything in this statement yet, prepend ;
+		c.tsw.WriteLiterally("(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	case *ast.FuncLit:
+		return c.WriteFuncLitValue(exp)
+	default:
+		c.tsw.WriteCommentLinef("unhandled value expr: %T", exp)
+		return nil
+	}
+}