goscript 0.0.21 → 0.0.23

package/compiler/spec-value.go

@@ -0,0 +1,226 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+)
+
+// WriteValueSpec translates a Go value specification (`ast.ValueSpec`),
+// which represents `var` or `const` declarations, into TypeScript `let`
+// 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.
+//   - 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`.
+//
+// For multiple variable declarations (`var a, b = val1, val2` or `a, b := val1, val2`):
+//   - It uses TypeScript array destructuring: `let [a, b] = [val1_ts, val2_ts];`.
+//   - If initialized from a single multi-return function call (`a, b := func()`),
+//     it becomes `let [a, b] = func_ts();`.
+//   - If no initializers are provided, it defaults to `let [a,b] = []` (with a TODO
+//     to assign correct individual zero values).
+//
+// Documentation comments associated with the `ValueSpec` are preserved.
+func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
+	if a.Doc != nil {
+		c.WriteDoc(a.Doc)
+	}
+	if a.Comment != nil {
+		c.WriteDoc(a.Comment)
+	}
+
+	// Handle single variable declaration
+	if len(a.Names) == 1 {
+		name := a.Names[0]
+		obj := c.pkg.TypesInfo.Defs[name]
+		if obj == nil {
+			return fmt.Errorf("could not resolve type: %v", name)
+		}
+
+		goType := obj.Type()
+		needsBox := c.analysis.NeedsBoxed(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)
+
+		if !isSliceConversion {
+			c.tsw.WriteLiterally(": ")
+			// Write type annotation
+			if needsBox {
+				// If boxed, the variable holds Box<OriginalGoType>
+				c.tsw.WriteLiterally("$.Box<")
+				c.WriteGoType(goType, GoTypeContextGeneral) // Write the original Go type T
+				c.tsw.WriteLiterally(">")
+			} else {
+				// If not boxed, the variable holds the translated Go type directly
+				c.WriteGoType(goType, GoTypeContextGeneral)
+			}
+		}
+
+		// Write initializer
+		c.tsw.WriteLiterally(" = ")
+
+		// 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 {
+						// Check if the argument is nil
+						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
+							}
+						}
+					}
+				}
+			}
+		}
+
+		if needsBox {
+			// Boxed variable: let v: Box<T> = $.box(init_or_zero);
+			c.tsw.WriteLiterally("$.box(")
+			if hasInitializer {
+				// Write the compiled initializer expression normally
+				if err := c.WriteValueExpr(initializerExpr); err != nil {
+					return err
+				}
+			} else {
+				// No initializer, box the zero value
+				c.WriteZeroValueForType(goType)
+			}
+			c.tsw.WriteLiterally(")")
+		} else {
+			// Unboxed variable: let v: T = init_or_zero;
+			if hasInitializer {
+				// Handle &v initializer specifically for unboxed variables
+				if unaryExpr, isUnary := initializerExpr.(*ast.UnaryExpr); isUnary && unaryExpr.Op == token.AND {
+					// Initializer is &v
+					// Check if v is boxed
+					needsBoxOperand := false
+					unaryExprXIdent, ok := unaryExpr.X.(*ast.Ident)
+					if ok {
+						innerObj := c.pkg.TypesInfo.Uses[unaryExprXIdent]
+						needsBoxOperand = innerObj != nil && c.analysis.NeedsBoxed(innerObj)
+					}
+
+					// If v is boxed, assign the box itself (v)
+					// If v is not boxed, assign $.box(v)
+					if needsBoxOperand {
+						// special handling: do not write .value here.
+						c.WriteIdent(unaryExprXIdent, false)
+					} else {
+						// &unboxedVar -> $.box(unboxedVar)
+						c.tsw.WriteLiterally("$.box(")
+						if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Write 'v'
+							return err
+						}
+						c.tsw.WriteLiterally(")")
+					}
+				} else {
+					// Regular initializer, clone if needed
+					if shouldApplyClone(c.pkg, initializerExpr) {
+						if err := c.WriteValueExpr(initializerExpr); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(".clone()")
+					} else {
+						if err := c.WriteValueExpr(initializerExpr); err != nil {
+							return err
+						}
+					}
+				}
+			} else {
+				// No initializer, use the zero value directly
+				c.WriteZeroValueForType(goType)
+			}
+		}
+		c.tsw.WriteLine("") // Finish the declaration line
+		return nil
+	}
+
+	// --- Multi-variable declaration (existing logic seems okay, but less common for pointers) ---
+	c.tsw.WriteLiterally("let ")
+	c.tsw.WriteLiterally("[") // Use array destructuring for multi-assign
+	for i, name := range a.Names {
+		if i != 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.tsw.WriteLiterally(name.Name)
+		// TODO: Add type annotations for multi-var declarations if possible/needed
+	}
+	c.tsw.WriteLiterally("]")
+	if len(a.Values) > 0 {
+		// TODO: handle other kinds of assignment += -= etc.
+		c.tsw.WriteLiterally(" = ")
+		if len(a.Values) == 1 && len(a.Names) > 1 {
+			// Assign from a single multi-return value
+			if err := c.WriteValueExpr(a.Values[0]); err != nil {
+				return err
+			}
+		} else {
+			// Assign from multiple values
+			c.tsw.WriteLiterally("[")
+			for i, val := range a.Values {
+				if i != 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteValueExpr(val); err != nil { // Initializers are values
+					return err
+				}
+			}
+			c.tsw.WriteLiterally("]")
+		}
+	} else {
+		// No initializer, assign default values (complex for multi-assign)
+		// For simplicity, assign default array based on context (needs improvement)
+		c.tsw.WriteLiterally(" = []") // Placeholder
+		// TODO: Assign correct zero values based on types
+	}
+	c.tsw.WriteLine("") // Use WriteLine instead of WriteLine(";")
+	return nil
+}

package/compiler/spec.go

@@ -0,0 +1,272 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/types"
+	"strings"
+
+	// types provides type information for Go types.
+	"github.com/pkg/errors"
+)
+
+// WriteSpec is a dispatcher function that translates a Go specification node
+// (`ast.Spec`) into its TypeScript equivalent. It handles different types of
+// specifications found within `GenDecl` (general declarations):
+// - `ast.ImportSpec` (import declarations): Delegates to `WriteImportSpec`.
+// - `ast.ValueSpec` (variable or constant declarations): Delegates to `WriteValueSpec`.
+// - `ast.TypeSpec` (type definitions like structs, interfaces): Delegates to `WriteTypeSpec`.
+// If an unknown specification type is encountered, it returns an error.
+func (c *GoToTSCompiler) WriteSpec(a ast.Spec) error {
+	switch d := a.(type) {
+	case *ast.ImportSpec:
+		c.WriteImportSpec(d)
+	case *ast.ValueSpec:
+		if err := c.WriteValueSpec(d); err != nil {
+			return err
+		}
+	case *ast.TypeSpec:
+		if err := c.WriteTypeSpec(d); err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("unknown spec type: %T", a)
+	}
+	return nil
+}
+
+func (c *GoToTSCompiler) getEmbeddedFieldKeyName(fieldType types.Type) string {
+	trueType := fieldType
+	if ptr, isPtr := trueType.(*types.Pointer); isPtr {
+		trueType = ptr.Elem()
+	}
+
+	if named, isNamed := trueType.(*types.Named); isNamed {
+		return named.Obj().Name()
+	} else {
+		// Fallback for unnamed embedded types, though less common for structs
+		fieldKeyName := strings.Title(trueType.String()) // Simple heuristic
+		if dotIndex := strings.LastIndex(fieldKeyName, "."); dotIndex != -1 {
+			fieldKeyName = fieldKeyName[dotIndex+1:]
+		}
+		return fieldKeyName
+	}
+}
+
+func (c *GoToTSCompiler) writeGetterSetter(fieldName string, fieldType types.Type, doc, comment *ast.CommentGroup) {
+	fieldTypeStr := c.getTypeString(fieldType)
+
+	// Generate getter
+	if doc != nil {
+		c.WriteDoc(doc)
+	}
+	if comment != nil {
+		c.WriteDoc(comment)
+	}
+	c.tsw.WriteLinef("public get %s(): %s {", fieldName, fieldTypeStr)
+	c.tsw.Indent(1)
+	c.tsw.WriteLinef("return this._fields.%s.value", fieldName)
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	// Generate setter (no comments)
+	c.tsw.WriteLinef("public set %s(value: %s) {", fieldName, fieldTypeStr)
+	c.tsw.Indent(1)
+	c.tsw.WriteLinef("this._fields.%s.value = value", fieldName)
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+}
+
+func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
+	c.tsw.WriteLiterally(fieldName)
+	c.tsw.WriteLiterally(": $.box(")
+
+	if isEmbedded {
+		if _, isPtr := fieldType.(*types.Pointer); isPtr {
+			c.tsw.WriteLiterallyf("init?.%s ?? null", fieldName)
+		} else {
+			typeForNew := fieldName
+			c.tsw.WriteLiterallyf("new %s(init?.%s)", typeForNew, fieldName)
+		}
+	} else {
+		isStructValueType := false
+		var structTypeNameForClone string
+		if named, ok := fieldType.(*types.Named); ok {
+			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+				isStructValueType = true
+				structTypeNameForClone = named.Obj().Name()
+			}
+		}
+
+		if isStructValueType {
+			c.tsw.WriteLiterallyf("init?.%s?.clone() ?? new %s()", fieldName, structTypeNameForClone)
+		} else {
+			c.tsw.WriteLiterallyf("init?.%s ?? ", fieldName)
+			c.WriteZeroValueForType(fieldType)
+		}
+	}
+
+	c.tsw.WriteLiterally(")")
+}
+
+func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
+	c.tsw.WriteLiterally(fieldName)
+	c.tsw.WriteLiterally(": $.box(")
+
+	if isEmbedded {
+		isPointerToStruct := false
+		trueType := fieldType
+		if ptr, isPtr := trueType.(*types.Pointer); isPtr {
+			trueType = ptr.Elem()
+			isPointerToStruct = true
+		}
+
+		if named, isNamed := trueType.(*types.Named); isNamed {
+			_, isUnderlyingStruct := named.Underlying().(*types.Struct)
+			if isUnderlyingStruct && !isPointerToStruct { // Is a value struct
+				c.tsw.WriteLiterallyf("this._fields.%s.value.clone()", fieldName)
+			} else { // Is a pointer to a struct, or not a struct
+				c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+			}
+		} else {
+			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+		}
+	} else {
+		isValueTypeStruct := false
+		if named, ok := fieldType.(*types.Named); ok {
+			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+				isValueTypeStruct = true
+			}
+		}
+
+		if isValueTypeStruct {
+			c.tsw.WriteLiterallyf("this._fields.%s.value?.clone() ?? null", fieldName)
+		} else {
+			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+		}
+	}
+
+	c.tsw.WriteLiterally(")")
+}
+
+// WriteTypeSpec writes the type specification to the output.
+func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
+	if a.Doc != nil {
+		c.WriteDoc(a.Doc)
+	}
+	if a.Comment != nil {
+		c.WriteDoc(a.Comment)
+	}
+
+	switch t := a.Type.(type) {
+	case *ast.StructType:
+		return c.WriteStructTypeSpec(a, t)
+	case *ast.InterfaceType:
+		return c.WriteInterfaceTypeSpec(a, t)
+	default:
+		// type alias
+		c.tsw.WriteLiterally("type ")
+		if err := c.WriteValueExpr(a.Name); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(" = ")
+		c.WriteTypeExpr(a.Type) // The aliased type
+		c.tsw.WriteLine(";")
+	}
+	return nil
+}
+
+// WriteInterfaceTypeSpec writes the TypeScript type for a Go interface type.
+func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.InterfaceType) error {
+	c.tsw.WriteLiterally("type ")
+	if err := c.WriteValueExpr(a.Name); err != nil {
+		return err
+	}
+	c.tsw.WriteLiterally(" = ")
+	// Get the types.Interface from the ast.InterfaceType.
+	// For an interface definition like `type MyInterface interface { M() }`,
+	// 't' is the *ast.InterfaceType representing `interface { M() }`.
+	// TypesInfo.TypeOf(t) will give the *types.Interface.
+	goType := c.pkg.TypesInfo.TypeOf(t)
+	if goType == nil {
+		return errors.Errorf("could not get type for interface AST node for %s", a.Name.Name)
+	}
+	ifaceType, ok := goType.(*types.Interface)
+	if !ok {
+		return errors.Errorf("expected *types.Interface, got %T for %s when processing interface literal", goType, a.Name.Name)
+	}
+	c.WriteInterfaceType(ifaceType, t) // Pass the *ast.InterfaceType for comment fetching
+	c.tsw.WriteLine("")
+
+	// Add code to register the interface with the runtime system
+	interfaceName := a.Name.Name
+	c.tsw.WriteLine("")
+	c.tsw.WriteLinef("$.registerInterfaceType(")
+	c.tsw.WriteLinef("  '%s',", interfaceName)
+	c.tsw.WriteLinef("  null, // Zero value for interface is null")
+
+	// Collect methods for the interface type
+	var interfaceMethods []*types.Func
+	if ifaceType != nil { // ifaceType is *types.Interface
+		for i := range ifaceType.NumExplicitMethods() {
+			interfaceMethods = append(interfaceMethods, ifaceType.ExplicitMethod(i))
+		}
+		// TODO: Handle embedded interface methods if necessary for full signature collection.
+		// For now, explicit methods are covered.
+	}
+	c.tsw.WriteLiterally("  [")
+	c.writeMethodSignatures(interfaceMethods)
+	c.tsw.WriteLiterally("]")
+	c.tsw.WriteLine("")
+
+	c.tsw.WriteLinef(");")
+
+	return nil
+}
+
+// WriteImportSpec translates a Go import specification (`ast.ImportSpec`)
+// into a TypeScript import statement.
+//
+// It extracts the Go import path (e.g., `"path/to/pkg"`) and determines the
+// import alias/name for TypeScript. If the Go import has an explicit name
+// (e.g., `alias "path/to/pkg"`), that alias is used. Otherwise, the package
+// name is derived from the Go path.
+//
+// The Go path is then translated to a TypeScript module path using
+// `translateGoPathToTypescriptPath`.
+//
+// Finally, it writes a TypeScript import statement like `import * as alias from "typescript/path/to/pkg";`
+// and records the import details in `c.analysis.Imports` for later use (e.g.,
+// resolving qualified identifiers).
+func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
+	if a.Doc != nil {
+		c.WriteDoc(a.Doc)
+	}
+	if a.Comment != nil {
+		c.WriteDoc(a.Comment)
+	}
+
+	goPath := a.Path.Value[1 : len(a.Path.Value)-1]
+	impName := packageNameFromGoPath(goPath)
+	if a.Name != nil && a.Name.Name != "" {
+		impName = a.Name.Name
+	}
+
+	// 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: tsImportPath,
+		importVars: make(map[string]struct{}),
+	}
+
+	c.tsw.WriteImport(impName, tsImportPath+"/index.js")
+}