goscript 0.0.22 → 0.0.24

package/compiler/expr-star.go

@@ -1,89 +1,81 @@
 package compiler
 
 import (
-	"fmt"
 	"go/ast"
+	"go/types"
 )
 
 // 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.
+// and TypeScript's varRefing mechanism for emulating pointer semantics.
 //
-// The translation depends on whether the pointer variable `p` itself is boxed and
+// The translation depends on whether the pointer variable `p` itself is varrefed 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!`.
+//  1. If `p` is not varrefed and points to a primitive or another pointer: `*p` -> `p!.value`.
+//     (`p` holds a varRef, so dereference accesses its `value` field).
+//  2. If `p` is not varrefed 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).
+//  3. If `p` is variable referenced (i.e., `p` is `$.VarRef<PointerType>`) and points to a primitive/pointer:
+//     `p.value!.value` (access the variable reference, then dereference the pointer)
+//  4. If `p` is varrefed and points to a struct: `p.value!`.
+//     (First `.value` unvarRefes `p` to get the struct instance).
 //
-// `WriteValueExpr(operand)` handles the initial unboxing of `p` if `p` itself is a boxed variable.
+// `WriteValueExpr(operand)` handles the initial unvarRefing of `p` if `p` itself is a varrefed 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`).
+// The function determines if `.value` access is needed by checking what the Go pointer operand points to.
+//
+// For multi-level dereferences like `***p`, this function is called recursively, with each level
+// adding the appropriate `!.value` suffix.
+//
+// Examples:
+//   - Simple pointer to primitive: `p!.value` (where p is *int)
+//   - Variable referenced pointer to primitive: `p.value!.value` (where p is VarRef<*int>)
+//     Example: let p = $.varRef(x) (where x is another variable reference) => p.value!.value
+//   - Pointer to struct: `p!` (where p is *MyStruct)
+//     Example: let p = $.varRef(new MyStruct()) => p.value!
+//   - Variable referenced pointer to struct: `p.value!` (where p is VarRef<*MyStruct>)
+//   - Triple pointer: `p3!.value!.value!.value` (where p3 is VarRef<VarRef<VarRef<number> | null> | null> | null)
 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)
+	// Check if the operand is an identifier that is varrefed
+	isVarrefedIdent := false
+	if ident, ok := exp.X.(*ast.Ident); ok {
+		if obj := c.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+			isVarrefedIdent = c.analysis.NeedsVarRef(obj)
 		}
-
-		// 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)
+	// Write the operand
+	if isVarrefedIdent {
+		// For varrefed identifiers, we need to access the value first
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+	} else {
+		// For non-varrefed identifiers and other expressions
+		switch operand := exp.X.(type) {
+		case *ast.Ident:
+			// Write identifier without .value access
+			c.WriteIdent(operand, false)
+		default:
+			// For other expressions (like nested star expressions), use WriteValueExpr
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return err
+			}
+		}
 	}
 
-	// Add ! for null assertion - all pointers can be null in TypeScript
+	// Add non-null assertion for pointer safety
 	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")
+	// Check what the operand points to (not what the result is)
+	operandType := c.pkg.TypesInfo.TypeOf(exp.X)
+	if ptrType, isPtr := operandType.(*types.Pointer); isPtr {
+		elemType := ptrType.Elem()
+		// Only add .value if NOT pointing to a struct
+		if _, isStruct := elemType.Underlying().(*types.Struct); !isStruct {
+			c.tsw.WriteLiterally(".value")
+		}
+		// If pointing to a struct, don't add .value (structs are reference types in TS)
 	}
 
 	return nil

package/compiler/expr-type.go

@@ -11,7 +11,7 @@ import (
 // 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`
+// - Pointer types (`*T`) -> `$.VarRef<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>`
@@ -22,13 +22,59 @@ import (
 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)
+	c.WriteGoType(typ, GoTypeContextGeneral)
 }
 
 // writeTypeDescription writes the TypeInfo for a type expr.
 func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 	switch t := typeExpr.(type) {
 	case *ast.Ident:
+		// Resolve the identifier to its type
+		goType := c.pkg.TypesInfo.TypeOf(t)
+		if goType != nil {
+			if namedType, isNamed := goType.(*types.Named); isNamed {
+				if sig, isFuncSig := namedType.Underlying().(*types.Signature); isFuncSig {
+					// It's a named function type (e.g. type MyFunc func())
+					c.tsw.WriteLiterally("{")
+					c.tsw.WriteLiterally("kind: $.TypeKind.Function, ")
+					c.tsw.WriteLiterallyf("name: '%s'", namedType.Obj().Name()) // Use the original defined name
+
+					// Add params if present
+					if sig.Params() != nil && sig.Params().Len() > 0 {
+						c.tsw.WriteLiterally(", params: [")
+						for i := 0; i < sig.Params().Len(); i++ {
+							if i > 0 {
+								c.tsw.WriteLiterally(", ")
+							}
+							paramVar := sig.Params().At(i)
+							c.writeTypeInfoObject(paramVar.Type())
+						}
+						c.tsw.WriteLiterally("]")
+					} else {
+						c.tsw.WriteLiterally(", params: []")
+					}
+
+					// Add results if present
+					if sig.Results() != nil && sig.Results().Len() > 0 {
+						c.tsw.WriteLiterally(", results: [")
+						for i := 0; i < sig.Results().Len(); i++ {
+							if i > 0 {
+								c.tsw.WriteLiterally(", ")
+							}
+							resultVar := sig.Results().At(i)
+							c.writeTypeInfoObject(resultVar.Type())
+						}
+						c.tsw.WriteLiterally("]")
+					} else {
+						c.tsw.WriteLiterally(", results: []")
+					}
+
+					c.tsw.WriteLiterally("}")
+					return
+				}
+			}
+		}
+
 		if isPrimitiveType(t.Name) {
 			if tsType, ok := GoBuiltinToTypescript(t.Name); ok {
 				c.tsw.WriteLiterally("{")
@@ -112,9 +158,16 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 		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())
+		// For an anonymous ast.FuncType, typeExpr is the ast.FuncType itself.
+		// We need to check if the type information associated with this AST node
+		// points to a *types.Named type.
+		resolvedGoType := c.pkg.TypesInfo.TypeOf(typeExpr)
+		if resolvedGoType != nil {
+			if named, ok := resolvedGoType.(*types.Named); ok {
+				// Ensure it's actually a function type that's named
+				if _, isFuncSig := named.Underlying().(*types.Signature); isFuncSig {
+					c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
+				}
 			}
 		}
 
@@ -174,6 +227,80 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 			c.tsw.WriteLiterally("'both'")
 		}
 
+		c.tsw.WriteLiterally("}")
+	case *ast.InterfaceType:
+		// Handle inline interface types like interface{ Method() string }
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Interface, ")
+		c.tsw.WriteLiterally("methods: [")
+
+		// Add method signatures for each method in the interface
+		if t.Methods != nil && t.Methods.List != nil {
+			hasMethod := false
+			for _, field := range t.Methods.List {
+				// Only process method declarations (not embedded interfaces)
+				if len(field.Names) > 0 {
+					for _, methodName := range field.Names {
+						if hasMethod {
+							c.tsw.WriteLiterally(", ")
+						}
+						hasMethod = true
+
+						// Write method signature in the same format as writeMethodSignatures
+						c.tsw.WriteLiterallyf("{ name: '%s', args: [", methodName.Name)
+
+						// Get the function type for this method
+						if funcType, ok := field.Type.(*ast.FuncType); ok {
+							// Add parameters
+							if funcType.Params != nil && funcType.Params.List != nil {
+								paramIndex := 0
+								for _, param := range funcType.Params.List {
+									// Each parameter field can declare multiple variables of the same type
+									if len(param.Names) > 0 {
+										for _, paramName := range param.Names {
+											if paramIndex > 0 {
+												c.tsw.WriteLiterally(", ")
+											}
+											c.tsw.WriteLiterallyf("{ name: '%s', type: ", paramName.Name)
+											c.writeTypeDescription(param.Type)
+											c.tsw.WriteLiterally(" }")
+											paramIndex++
+										}
+									} else {
+										// No names, create a generic parameter name
+										if paramIndex > 0 {
+											c.tsw.WriteLiterally(", ")
+										}
+										c.tsw.WriteLiterallyf("{ name: '_p%d', type: ", paramIndex)
+										c.writeTypeDescription(param.Type)
+										c.tsw.WriteLiterally(" }")
+										paramIndex++
+									}
+								}
+							}
+
+							c.tsw.WriteLiterally("], returns: [")
+
+							// Add return types
+							if funcType.Results != nil && funcType.Results.List != nil {
+								for i, result := range funcType.Results.List {
+									if i > 0 {
+										c.tsw.WriteLiterally(", ")
+									}
+									c.tsw.WriteLiterally("{ type: ")
+									c.writeTypeDescription(result.Type)
+									c.tsw.WriteLiterally(" }")
+								}
+							}
+
+							c.tsw.WriteLiterally("] }")
+						}
+					}
+				}
+			}
+		}
+
+		c.tsw.WriteLiterally("]")
 		c.tsw.WriteLiterally("}")
 	default:
 		// For other types, use the string representation

package/compiler/expr-value.go

@@ -1,11 +1,13 @@
 package compiler
 
-import "go/ast"
+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.
+// - Identifiers (`ast.Ident`): Delegates to `WriteIdent`, potentially adding `.value` for varrefed 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`.
@@ -50,43 +52,11 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 		return c.WriteTypeAssertExpr(exp)
 	case *ast.IndexExpr:
 		return c.WriteIndexExpr(exp)
+	case *ast.IndexListExpr:
+		// Handle generic function instantiation: f[T1, T2](args) -> f<T1, T2>(args)
+		return c.WriteIndexListExpr(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
+		return c.WriteSliceExpr(exp)
 	case *ast.ParenExpr:
 		// Check if this is a nil pointer to struct type cast: (*struct{})(nil)
 		if starExpr, isStarExpr := exp.X.(*ast.StarExpr); isStarExpr {