goscript 0.0.10 → 0.0.13

package/compiler/compile_expr.go

@@ -108,6 +108,43 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 		}
 		c.tsw.WriteLiterally("]")
 		return nil
+	case *ast.SliceExpr:
+		// Translate Go slice expression to goscript.slice(x, low, high, max)
+		c.tsw.WriteLiterally("goscript.slice(")
+		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:
 		// Translate (X) to (X)
 		c.tsw.WriteLiterally("(")
@@ -278,13 +315,14 @@ func (c *GoToTSCompiler) WriteInterfaceType(exp *ast.InterfaceType) {
 
 	// If there are embedded interfaces, write the extends clause
 	if len(embeddedInterfaces) > 0 {
-		c.tsw.WriteLiterally(" extends ")
+		c.tsw.WriteLiterally("extends ")
 		c.tsw.WriteLiterally(strings.Join(embeddedInterfaces, ", "))
+		c.tsw.WriteLiterally(" ")
 	}
 
 	// Write the interface body on the same line
-	c.tsw.WriteLiterally("{") // Removed leading space
-	c.tsw.WriteLine("")       // Newline after opening brace
+	c.tsw.WriteLiterally("{")
+	c.tsw.WriteLine("") // Newline after opening brace
 	c.tsw.Indent(1)
 
 	// Write named methods
@@ -340,6 +378,28 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 	expFun := exp.Fun
 
+	// Handle array type conversions like []rune(string)
+	if arrayType, isArrayType := expFun.(*ast.ArrayType); isArrayType {
+		// Check if it's a []rune type
+		if ident, isIdent := arrayType.Elt.(*ast.Ident); isIdent && ident.Name == "rune" {
+			// Check if the argument is a string
+			if len(exp.Args) == 1 {
+				arg := exp.Args[0]
+				if tv, ok := c.pkg.TypesInfo.Types[arg]; ok && tv.Type != nil {
+					if basic, isBasic := tv.Type.Underlying().(*gtypes.Basic); isBasic && basic.Kind() == gtypes.String {
+						// Translate []rune(stringValue) to goscript.stringToRunes(stringValue)
+						c.tsw.WriteLiterally("goscript.stringToRunes(")
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for []rune(string) conversion: %w", err)
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled []rune(string)
+					}
+				}
+			}
+		}
+	}
+
 	if funIdent, funIsIdent := expFun.(*ast.Ident); funIsIdent {
 		switch funIdent.String() {
 		case "println":
@@ -433,7 +493,20 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 				// Handle slice creation
 				if _, ok := exp.Args[0].(*ast.ArrayType); ok {
-					c.tsw.WriteLiterally("goscript.makeSlice(")
+					// Get the slice type information
+					sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
+					if sliceType == nil {
+						return errors.New("could not get type information for slice in make call")
+					}
+					goElemType, ok := sliceType.Underlying().(*gtypes.Slice)
+					if !ok {
+						return errors.New("expected slice type for make call")
+					}
+
+					c.tsw.WriteLiterally("goscript.makeSlice<")
+					c.WriteGoType(goElemType.Elem()) // Write the element type
+					c.tsw.WriteLiterally(">(")
+
 					if len(exp.Args) >= 2 {
 						if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 							return err
@@ -457,10 +530,18 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			// Fallthrough for unhandled make calls (e.g., channels)
 			return errors.New("unhandled make call")
 		case "string":
-			// Handle string() conversion, specifically for rune to string
+			// Handle string() conversion
 			if len(exp.Args) == 1 {
-				// Check if the argument is a rune (int32) or a call to rune()
 				arg := exp.Args[0]
+
+				// Case 1: Argument is a string literal string("...")
+				if basicLit, isBasicLit := arg.(*ast.BasicLit); isBasicLit && basicLit.Kind == token.STRING {
+					// Translate string("...") to "..." (no-op)
+					c.WriteBasicLitValue(basicLit)
+					return nil // Handled string literal conversion
+				}
+
+				// Case 2: Argument is a rune (int32) or a call to rune()
 				innerCall, isCallExpr := arg.(*ast.CallExpr)
 
 				if isCallExpr {
@@ -490,6 +571,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 						c.tsw.WriteLiterally(")")
 						return nil // Handled string(int32)
 					}
+
+					// Case 3: Argument is a slice of runes string([]rune{...})
+					if sliceType, isSlice := tv.Type.Underlying().(*gtypes.Slice); isSlice {
+						if basic, isBasic := sliceType.Elem().Underlying().(*gtypes.Basic); isBasic && basic.Kind() == gtypes.Int32 {
+							// Translate string([]rune) to goscript.runesToString(...)
+							c.tsw.WriteLiterally("goscript.runesToString(")
+							if err := c.WriteValueExpr(arg); err != nil {
+								return fmt.Errorf("failed to write argument for string([]rune) conversion: %w", err)
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled string([]rune)
+						}
+					}
 				}
 			}
 			// Return error for other unhandled string conversions
@@ -617,6 +711,17 @@ func (c *GoToTSCompiler) WriteBinaryExprValue(exp *ast.BinaryExpr) error {
 		return nil
 	}
 
+	// Check if the operator is a bitwise operator
+	isBitwise := false
+	switch exp.Op {
+	case token.AND, token.OR, token.XOR, token.SHL, token.SHR, token.AND_NOT:
+		isBitwise = true
+	}
+
+	if isBitwise {
+		c.tsw.WriteLiterally("(") // Add opening parenthesis for bitwise operations
+	}
+
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write binary expression left operand: %w", err)
 	}
@@ -632,6 +737,11 @@ func (c *GoToTSCompiler) WriteBinaryExprValue(exp *ast.BinaryExpr) error {
 	if err := c.WriteValueExpr(exp.Y); err != nil {
 		return fmt.Errorf("failed to write binary expression right operand: %w", err)
 	}
+
+	if isBitwise {
+		c.tsw.WriteLiterally(")") // Add closing parenthesis for bitwise operations
+	}
+
 	return nil
 }
 
@@ -692,6 +802,16 @@ func (c *GoToTSCompiler) WriteCompositeLitValue(exp *ast.CompositeLit) error {
 
 		// Handle array literals
 		if arrType, isArrayType := exp.Type.(*ast.ArrayType); isArrayType {
+			// Special case: empty slice literal
+			if len(exp.Elts) == 0 {
+				// Generate: ([] as ElementType[])
+				c.tsw.WriteLiterally("([] as ")
+				// Write the element type using the existing function
+				c.WriteTypeExpr(arrType.Elt)
+				c.tsw.WriteLiterally("[])") // Close the type assertion
+				return nil                  // Handled empty slice literal
+			}
+
 			c.tsw.WriteLiterally("[")
 			// Use type info to get array length and element type
 			var arrayLen int
@@ -779,7 +899,7 @@ func (c *GoToTSCompiler) WriteCompositeLitValue(exp *ast.CompositeLit) error {
 			// Typed literal, likely a struct: new Type({...})
 			c.tsw.WriteLiterally("new ")
 			c.WriteTypeExpr(exp.Type)
-			c.tsw.WriteLiterally("({ ")
+			c.tsw.WriteLiterally("({")
 			for i, elm := range exp.Elts {
 				if i != 0 {
 					c.tsw.WriteLiterally(", ")
@@ -788,7 +908,7 @@ func (c *GoToTSCompiler) WriteCompositeLitValue(exp *ast.CompositeLit) error {
 					return fmt.Errorf("failed to write struct literal field: %w", err)
 				}
 			}
-			c.tsw.WriteLiterally(" })")
+			c.tsw.WriteLiterally("})")
 			return nil
 		}
 	}
@@ -886,10 +1006,17 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 
 	c.tsw.WriteLiterally(" => ")
 
+	// Save previous async state and set current state based on isAsync
+	previousAsyncState := c.inAsyncFunction
+	c.inAsyncFunction = isAsync
+
 	// Write function body
 	if err := c.WriteStmt(exp.Body); err != nil {
+		c.inAsyncFunction = previousAsyncState // Restore state before returning error
 		return fmt.Errorf("failed to write function literal body: %w", err)
 	}
 
+	// Restore previous async state
+	c.inAsyncFunction = previousAsyncState
 	return nil
 }

package/compiler/compile_field.go

@@ -3,6 +3,7 @@ package compiler
 import (
 	"fmt"
 	"go/ast"
+	gtypes "go/types"
 )
 
 // WriteFieldList writes a field list.
@@ -50,6 +51,7 @@ func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
 			c.WriteDoc(field.Comment)
 		}
 	}
+
 	for _, name := range field.Names {
 		isExported := name.IsExported()
 
@@ -68,14 +70,33 @@ func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
 			c.tsw.WriteLiterally(name.Name)
 		}
 
+		// Check if field type is an interface
+		isInterface := false
+		if c.pkg != nil && c.pkg.TypesInfo != nil {
+			if tv, ok := c.pkg.TypesInfo.Types[field.Type]; ok && tv.Type != nil {
+				_, isInterface = tv.Type.Underlying().(*gtypes.Interface)
+			}
+		}
+
 		// write type for struct fields (not arguments)
 		c.tsw.WriteLiterally(": ")
 		c.WriteTypeExpr(field.Type) // Use WriteTypeExpr for field type
 
+		// Append "| null" for interface fields
+		if !isArguments && isInterface {
+			c.tsw.WriteLiterally(" | null")
+		}
+
 		if !isArguments {
 			// write initializer with zero value for struct fields
 			c.tsw.WriteLiterally(" = ")
-			c.WriteZeroValueForType(field.Type)
+
+			// Special initialization for interface fields
+			if isInterface {
+				c.tsw.WriteLiterally("null")
+			} else {
+				c.WriteZeroValueForType(field.Type)
+			}
 
 			// write tag comment if any for struct fields
 			if field.Tag != nil {

package/compiler/compile_spec.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
+	gtypes "go/types"
 	"sort"
 	"strings"
 )
@@ -57,6 +58,20 @@ func (c *GoToTSCompiler) collectMethodNames(structName string) string {
 	return strings.Join(methodNames, ", ")
 }
 
+// getTypeExprName returns a string representation of a type expression.
+func (c *GoToTSCompiler) getTypeExprName(expr ast.Expr) string {
+	switch t := expr.(type) {
+	case *ast.Ident:
+		return t.Name
+	case *ast.SelectorExpr:
+		return fmt.Sprintf("%s.%s", c.getTypeExprName(t.X), t.Sel.Name)
+	case *ast.StarExpr:
+		return c.getTypeExprName(t.X) // Unwrap pointer type
+	default:
+		return "embedded" // Fallback for complex type expressions
+	}
+}
+
 // collectInterfaceMethods returns a comma-separated string of method names for an interface
 func (c *GoToTSCompiler) collectInterfaceMethods(interfaceType *ast.InterfaceType) string {
 	// Use a map to ensure uniqueness of method names
@@ -120,12 +135,32 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 
 	switch t := a.Type.(type) {
 	case *ast.StructType:
-		// write the class definition
+		// Detect embedded struct (anonymous field) to support Go struct embedding.
+		var embeddedExpr ast.Expr
+		for _, f := range t.Fields.List {
+			if len(f.Names) == 0 { // anonymous field ⇒ embedded type
+				embeddedExpr = f.Type
+				break // only the first embedded struct is supported for now
+			}
+		}
+		// Write the class header, adding "extends Embedded" when an embedded struct is present.
 		c.tsw.WriteLiterally("class ")
 		if err := c.WriteValueExpr(a.Name); err != nil { // Class name is a value identifier
 			return err
 		}
-		c.tsw.WriteLine(" {")
+		c.tsw.WriteLiterally(" ")
+
+		if embeddedExpr != nil {
+			// For pointer embedding (*T) unwrap the star so we extend T, not (T|null)
+			if star, ok := embeddedExpr.(*ast.StarExpr); ok {
+				embeddedExpr = star.X
+			}
+			c.tsw.WriteLiterally("extends ")
+			c.WriteTypeExpr(embeddedExpr) // Embedded type name
+			c.tsw.WriteLiterally(" ")
+		}
+
+		c.tsw.WriteLine("{")
 		c.tsw.Indent(1)
 
 		// className is the name of the class type
@@ -164,7 +199,38 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 
 		// constructor and clone using Object.assign for compactness
 		c.tsw.WriteLine("")
-		c.tsw.WriteLinef("constructor(init?: Partial<%s>) { if (init) Object.assign(this, init as any); }", className)
+		if embeddedExpr != nil {
+			// Determine the embedded type's identifier (strip any package prefix)
+			embeddedTypeNameFull := c.getTypeExprName(embeddedExpr)
+			propName := embeddedTypeNameFull
+			if idx := strings.LastIndex(propName, "."); idx != -1 {
+				propName = propName[idx+1:] // keep only the last segment for the property key
+			}
+
+			// The init parameter allows either flattened fields or a nested {Embedded: {...}} object
+			c.tsw.WriteLinef(
+				"constructor(init?: Partial<%s> & { %s?: Partial<%s> }) {",
+				className, propName, propName,
+			)
+			c.tsw.Indent(1)
+
+			// Pass either the nested embedded object or the full init directly to super()
+			c.tsw.WriteLinef("super(init?.%s || init);", propName)
+
+			// Copy fields that belong only to this derived class
+			c.tsw.WriteLine("if (init) {")
+			c.tsw.Indent(1)
+			c.tsw.WriteLinef("const { %s, ...rest } = init as any;", propName)
+			c.tsw.WriteLine("Object.assign(this, rest);")
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+		} else {
+			// For a base class without embedding, use simple constructor
+			c.tsw.WriteLinef("constructor(init?: Partial<%s>) { if (init) Object.assign(this, init as any); }", className)
+		}
 		c.tsw.WriteLinef("public clone(): %s { return Object.assign(Object.create(%s.prototype) as %s, this); }", className, className, className)
 
 		// Add code to register the type with the runtime system
@@ -219,8 +285,17 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 		c.WriteDoc(decl.Doc)
 	}
 
+	// Determine if method is async by checking for async operations in the body
+	isAsync := c.containsAsyncOperations(decl.Body)
+
 	// Methods are typically public in the TS output
 	c.tsw.WriteLiterally("public ")
+
+	// Add async modifier if needed
+	if isAsync {
+		c.tsw.WriteLiterally("async ")
+	}
+
 	// Keep original Go casing for method names
 	if err := c.WriteValueExpr(decl.Name); err != nil { // Method name is a value identifier
 		return err
@@ -238,6 +313,9 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 	// Handle return type
 	if funcType.Results != nil && len(funcType.Results.List) > 0 {
 		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
 		if len(funcType.Results.List) == 1 {
 			// Single return value
 			resultType := funcType.Results.List[0].Type
@@ -253,12 +331,27 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 			}
 			c.tsw.WriteLiterally("]")
 		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
 	} else {
 		// No return value -> void
-		c.tsw.WriteLiterally(": void")
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
 	}
 
 	c.tsw.WriteLiterally(" ")
+
+	// Check if function body has defer statements
+	c.nextBlockNeedsDefer = c.scanForDefer(decl.Body)
+
+	// Save previous async state and set current state based on isAsync
+	previousAsyncState := c.inAsyncFunction
+	c.inAsyncFunction = isAsync
+
 	// Bind receiver name to this
 	if recvField := decl.Recv.List[0]; len(recvField.Names) > 0 {
 		recvName := recvField.Names[0].Name
@@ -266,21 +359,40 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 			c.tsw.WriteLine("{")
 			c.tsw.Indent(1)
 			c.tsw.WriteLinef("const %s = this", recvName)
+
+			// Add using statement if needed
+			if c.nextBlockNeedsDefer {
+				if c.inAsyncFunction {
+					c.tsw.WriteLine("await using __defer = new goscript.AsyncDisposableStack();")
+				} else {
+					c.tsw.WriteLine("using cleanup = new goscript.DisposableStack();")
+				}
+				c.nextBlockNeedsDefer = false
+			}
+
 			// write method body without outer braces
 			for _, stmt := range decl.Body.List {
 				if err := c.WriteStmt(stmt); err != nil {
+					c.inAsyncFunction = previousAsyncState // Restore state before returning error
 					return fmt.Errorf("failed to write statement in function body: %w", err)
 				}
 			}
 			c.tsw.Indent(-1)
 			c.tsw.WriteLine("}")
+
+			// Restore previous async state
+			c.inAsyncFunction = previousAsyncState
 			return nil
 		}
 	}
 	// no named receiver, write whole body
 	if err := c.WriteStmt(decl.Body); err != nil {
+		c.inAsyncFunction = previousAsyncState // Restore state before returning error
 		return fmt.Errorf("failed to write function body: %w", err)
 	}
+
+	// Restore previous async state
+	c.inAsyncFunction = previousAsyncState
 	return nil
 }
 
@@ -296,13 +408,30 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 	if len(a.Names) == 1 {
 		name := a.Names[0]
 		c.tsw.WriteLiterally(name.Name)
+
+		// Check if it's an interface type
+		isInterface := false
+		if c.pkg != nil && c.pkg.TypesInfo != nil && a.Type != nil {
+			if tv, ok := c.pkg.TypesInfo.Types[a.Type]; ok && tv.Type != nil {
+				_, isInterface = tv.Type.Underlying().(*gtypes.Interface)
+			}
+		}
+
 		if a.Type != nil {
 			c.tsw.WriteLiterally(": ")
 			c.WriteTypeExpr(a.Type) // Variable type annotation
 
+			// Append "| null" for interface types
+			if isInterface {
+				c.tsw.WriteLiterally(" | null")
+			}
+
 			// Check if it's an array type declaration without an initial value
 			if _, isArrayType := a.Type.(*ast.ArrayType); isArrayType && len(a.Values) == 0 {
 				c.tsw.WriteLiterally(" = []")
+			} else if isInterface && len(a.Values) == 0 {
+				// Interface with no initialization value, initialize to null
+				c.tsw.WriteLiterally(" = null")
 			}
 		}
 		if len(a.Values) > 0 {
@@ -366,6 +495,14 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 
 // WriteInterfaceMethodSignature writes a TypeScript interface method signature from a Go ast.Field.
 func (c *GoToTSCompiler) WriteInterfaceMethodSignature(field *ast.Field) error {
+	// Include comments
+	if field.Doc != nil {
+		c.WriteDoc(field.Doc)
+	}
+	if field.Comment != nil {
+		c.WriteDoc(field.Comment)
+	}
+
 	if len(field.Names) == 0 {
 		// Should not happen for named methods in an interface, but handle defensively
 		return fmt.Errorf("interface method field has no name")