goscript 0.0.7 → 0.0.10

package/README.md

@@ -463,11 +463,19 @@ Code is compiled with `GOARCH=js` and uses a 32-bit environment similar to wasm.
 All Go import paths are prefixed with `@go/` and can be imported in TypeScript:
 
 ```typescript
-import { MyFunction, MyStruct } from '@go/github.com/myorg/mypackage';
-
-MyFunction();
-let myThing = new MyStruct();
-myThing.DoSometing();
+import { MyAsyncFunction, MyStruct } from '@go/github.com/myorg/mypackage';
+
+// Example of importing and using a compiled Go async function
+async function runGoCode() {
+  // Call an async function compiled from Go
+  const result = await MyAsyncFunction("input data");
+  console.log("Result from Go async function:", result);
+
+  // You can still use synchronous types and functions
+  let myThing = new MyStruct();
+  myThing.GetMyString();
+  runGoCode();
+}
 ```
 
 ## License

package/builtin/builtin.ts

@@ -46,6 +46,13 @@ export const cap = <T>(slice: Array<T> & { __capacity?: number }): number => {
   return slice.__capacity !== undefined ? slice.__capacity : slice.length
 }
 
+/**
+ * Represents the Go error type (interface).
+ */
+export type Error = {
+  Error(): string;
+} | null;
+
 /**
  * Converts a string to an array of Unicode code points (runes).
  * @param str The input string.
@@ -111,6 +118,179 @@ export const append = <T>(slice: Array<T>, ...elements: T[]): Array<T> => {
   return slice
 }
 
+/**
+ * Represents the kinds of Go types that can be registered at runtime.
+ */
+export enum TypeKind {
+  Struct = "struct",
+  Interface = "interface",
+  Basic = "basic",
+  Pointer = "pointer",
+  Slice = "slice",
+  Map = "map",
+  Channel = "channel",
+  Function = "function",
+}
+
+/**
+ * Represents type information for a Go type in the runtime.
+ */
+export interface TypeInfo {
+  name: string;
+  kind: TypeKind;
+  zeroValue: any;
+  // For interfaces, the set of methods
+  methods?: Set<string>;
+  // For structs, the constructor
+  constructor?: new (...args: any[]) => any;
+}
+
+// Registry to store runtime type information
+const typeRegistry = new Map<string, TypeInfo>();
+
+/**
+ * Registers a type with the runtime type system.
+ * 
+ * @param name The name of the type.
+ * @param kind The kind of the type.
+ * @param zeroValue The zero value for the type.
+ * @param methods Optional set of method names for interfaces.
+ * @param constructor Optional constructor for structs.
+ * @returns The type information object for chaining.
+ */
+export const registerType = (
+  name: string,
+  kind: TypeKind,
+  zeroValue: any,
+  methods?: Set<string>,
+  constructor?: new (...args: any[]) => any
+): TypeInfo => {
+  const typeInfo: TypeInfo = {
+    name,
+    kind,
+    zeroValue,
+    methods,
+    constructor,
+  };
+  typeRegistry.set(name, typeInfo);
+  return typeInfo;
+};
+
+/**
+ * Represents the result of a type assertion.
+ */
+export interface TypeAssertResult<T> {
+  value: T;
+  ok: boolean;
+}
+
+/**
+ * Performs a type assertion at runtime.
+ * 
+ * @param value The value to assert.
+ * @param typeName The name of the target type.
+ * @returns An object with the asserted value and whether the assertion succeeded.
+ */
+export function typeAssert<T>(value: any, typeName: string): TypeAssertResult<T> {
+  // Get the type information from the registry
+  const typeInfo = typeRegistry.get(typeName);
+  if (!typeInfo) {
+    console.warn(`Type information for '${typeName}' not found in registry.`);
+    return { value: null as unknown as T, ok: false };
+  }
+
+  // If value is null or undefined, assertion fails
+  if (value === null || value === undefined) {
+    return { value: typeInfo.zeroValue as T, ok: false };
+  }
+
+  // Check based on the kind of the target type
+  switch (typeInfo.kind) {
+    case TypeKind.Struct:
+      // For structs, use instanceof with the constructor
+      if (typeInfo.constructor && value instanceof typeInfo.constructor) {
+        return { value: value as T, ok: true };
+      }
+      break;
+      
+    case TypeKind.Interface:
+      // For interfaces, check if the value has all the required methods
+      if (typeInfo.methods && typeof value === 'object') {
+        const allMethodsPresent = Array.from(typeInfo.methods).every(
+          (method) => typeof (value as any)[method] === 'function'
+        );
+        if (allMethodsPresent) {
+          return { value: value as T, ok: true };
+        }
+      }
+      break;
+      
+    case TypeKind.Basic:
+      // For basic types, check if the value matches the expected JavaScript type
+      // This is a simple check for common basic types
+      const basicType = typeof value;
+      if (
+        basicType === 'string' || 
+        basicType === 'number' || 
+        basicType === 'boolean'
+      ) {
+        return { value: value as T, ok: true };
+      }
+      break;
+      
+    case TypeKind.Pointer:
+      // For pointers, check if value is not null or undefined
+      // In Go, pointers can be nil which we represent as null/undefined in TS
+      if (value !== null && value !== undefined) {
+        return { value: value as T, ok: true };
+      }
+      break;
+      
+    case TypeKind.Slice:
+      // For slices, check if the value is an array
+      if (Array.isArray(value)) {
+        return { value: value as T, ok: true };
+      }
+      break;
+      
+    case TypeKind.Map:
+      // For maps, check if the value is a Map
+      if (value instanceof Map) {
+        return { value: value as T, ok: true };
+      }
+      break;
+      
+    case TypeKind.Channel:
+      // For channels, check if the value has the required Channel interface methods
+      if (
+        typeof value === 'object' && 
+        value !== null &&
+        'send' in value && 
+        'receive' in value && 
+        'close' in value &&
+        typeof value.send === 'function' &&
+        typeof value.receive === 'function' &&
+        typeof value.close === 'function'
+      ) {
+        return { value: value as T, ok: true };
+      }
+      break;
+      
+    case TypeKind.Function:
+      // For functions, check if the value is a function
+      if (typeof value === 'function') {
+        return { value: value as T, ok: true };
+      }
+      break;
+      
+    default:
+      console.warn(`Type assertion for kind '${typeInfo.kind}' not implemented.`);
+  }
+
+  // Assertion failed
+  return { value: typeInfo.zeroValue as T, ok: false };
+}
+
 /**
  * Represents the result of a channel receive operation with 'ok' value
  */

package/compiler/compile_expr.go

@@ -7,6 +7,7 @@ import (
 	"go/token"
 	gtypes "go/types"
 	"strconv"
+	"strings"
 
 	gstypes "github.com/paralin/goscript/compiler/types"
 )
@@ -72,6 +73,9 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 		return c.WriteCompositeLitValue(exp)
 	case *ast.KeyValueExpr:
 		return c.WriteKeyValueExprValue(exp)
+	case *ast.TypeAssertExpr:
+		// Handle type assertion in an expression context
+		return c.WriteTypeAssertExpr(exp)
 	case *ast.IndexExpr:
 		// Handle map access: use Map.get() instead of brackets for reading values
 		if tv, ok := c.pkg.TypesInfo.Types[exp.X]; ok {
@@ -121,11 +125,51 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 	}
 }
 
+// WriteTypeAssertExpr writes a type assertion expression.
+func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
+	// Get the type name string for the asserted type
+	typeName := c.getTypeNameString(exp.Type)
+
+	// Generate a call to goscript.typeAssert
+	c.tsw.WriteLiterally("goscript.typeAssert<")
+	c.WriteTypeExpr(exp.Type) // Write the asserted type for the generic
+	c.tsw.WriteLiterally(">(")
+	if err := c.WriteValueExpr(exp.X); err != nil { // The interface expression
+		return fmt.Errorf("failed to write interface expression in type assertion expression: %w", err)
+	}
+	c.tsw.WriteLiterally(", ")
+	c.tsw.WriteLiterally(fmt.Sprintf("'%s'", typeName))
+	c.tsw.WriteLiterally(").value") // Access the value field directly in expression context
+	return nil
+}
+
+// getTypeNameString returns the string representation of a type name
+func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
+	switch t := typeExpr.(type) {
+	case *ast.Ident:
+		return t.Name
+	case *ast.SelectorExpr:
+		// For imported types like pkg.Type
+		if ident, ok := t.X.(*ast.Ident); ok {
+			return fmt.Sprintf("%s.%s", ident.Name, t.Sel.Name)
+		}
+	}
+	// Default case, use a placeholder for complex types
+	return "unknown"
+}
+
 // --- Exported Node-Specific Writers ---
 
 // WriteIdentType writes an identifier used as a type.
 func (c *GoToTSCompiler) WriteIdentType(exp *ast.Ident) {
 	name := exp.Name
+
+	// Special case for the built-in error interface
+	if name == "error" {
+		c.tsw.WriteLiterally("goscript.Error")
+		return
+	}
+
 	if tsname, ok := gstypes.GoBuiltinToTypescript(name); ok {
 		name = tsname
 	} else {
@@ -150,9 +194,13 @@ func (c *GoToTSCompiler) WriteIdentType(exp *ast.Ident) {
 	c.tsw.WriteLiterally(name)
 }
 
-// WriteIdentValue writes an identifier used as a value (variable, function name).
+// WriteIdentValue writes an identifier used as a value (variable, function name, nil).
 func (c *GoToTSCompiler) WriteIdentValue(exp *ast.Ident) {
-	c.tsw.WriteLiterally(exp.Name)
+	if exp.Name == "nil" {
+		c.tsw.WriteLiterally("null")
+	} else {
+		c.tsw.WriteLiterally(exp.Name)
+	}
 }
 
 // WriteSelectorExprType writes a selector expression used as a type (e.g., pkg.Type).
@@ -205,32 +253,47 @@ func (c *GoToTSCompiler) WriteStructType(exp *ast.StructType) {
 
 // WriteInterfaceType writes an interface type definition.
 func (c *GoToTSCompiler) WriteInterfaceType(exp *ast.InterfaceType) {
-	if exp.Methods == nil || exp.Methods.NumFields() == 0 {
-		c.tsw.WriteLiterally("{}")
-		return
-	}
-	c.tsw.WriteLine("{")
-	c.tsw.Indent(1)
-	for _, method := range exp.Methods.List {
-		if len(method.Names) > 0 {
-			// Keep original Go casing for method names
-			methodName := method.Names[0]
-			c.WriteIdentValue(methodName)
-
-			// Method signature is a FuncType
-			if funcType, ok := method.Type.(*ast.FuncType); ok {
-				c.WriteFuncType(funcType, false) // Interface method signatures are not async
+	var embeddedInterfaces []string
+	var methods []*ast.Field
+
+	if exp.Methods != nil {
+		for _, method := range exp.Methods.List {
+			if len(method.Names) > 0 {
+				// Named method
+				methods = append(methods, method)
 			} else {
-				// Should not happen for valid interfaces, but handle defensively
-				c.tsw.WriteCommentInline("unexpected method type")
+				// Embedded interface - collect the type name using type info
+				if tv, ok := c.pkg.TypesInfo.Types[method.Type]; ok && tv.Type != nil {
+					if namedType, ok := tv.Type.(*gtypes.Named); ok {
+						embeddedInterfaces = append(embeddedInterfaces, namedType.Obj().Name())
+					} else {
+						c.tsw.WriteCommentLine(fmt.Sprintf("// Unhandled embedded interface type: %T", tv.Type))
+					}
+				} else {
+					c.tsw.WriteCommentLine("// Could not resolve embedded interface type")
+				}
 			}
-			c.tsw.WriteLine(";")
-		} else {
-			// Embedded interface - write the type name
-			c.WriteTypeExpr(method.Type)
-			c.tsw.WriteLine("; // Embedded interface - requires manual merging or mixin in TS")
 		}
 	}
+
+	// If there are embedded interfaces, write the extends clause
+	if len(embeddedInterfaces) > 0 {
+		c.tsw.WriteLiterally(" extends ")
+		c.tsw.WriteLiterally(strings.Join(embeddedInterfaces, ", "))
+	}
+
+	// Write the interface body on the same line
+	c.tsw.WriteLiterally("{") // Removed leading space
+	c.tsw.WriteLine("")       // Newline after opening brace
+	c.tsw.Indent(1)
+
+	// Write named methods
+	for _, method := range methods {
+		if err := c.WriteInterfaceMethodSignature(method); err != nil {
+			c.tsw.WriteCommentInline(fmt.Sprintf("error writing interface method signature: %v", err))
+		}
+	}
+
 	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
 }
@@ -790,7 +853,38 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 	// Write arrow function: (params) => { body }
 	c.tsw.WriteLiterally("(")
 	c.WriteFieldList(exp.Type.Params, true) // true = arguments
-	c.tsw.WriteLiterally(") => ")
+	c.tsw.WriteLiterally(")")
+
+	// Handle return type for function literals
+	if exp.Type.Results != nil && len(exp.Type.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
+		if len(exp.Type.Results.List) == 1 && len(exp.Type.Results.List[0].Names) == 0 {
+			c.WriteTypeExpr(exp.Type.Results.List[0].Type)
+		} else {
+			c.tsw.WriteLiterally("[")
+			for i, field := range exp.Type.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(field.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
+	} else {
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
+	}
+
+	c.tsw.WriteLiterally(" => ")
 
 	// Write function body
 	if err := c.WriteStmt(exp.Body); err != nil {

package/compiler/compile_spec.go

@@ -3,6 +3,9 @@ package compiler
 import (
 	"fmt"
 	"go/ast"
+	"go/types"
+	"sort"
+	"strings"
 )
 
 // WriteSpec writes a specification to the output.
@@ -24,6 +27,88 @@ func (c *GoToTSCompiler) WriteSpec(a ast.Spec) error {
 	return nil
 }
 
+// collectMethodNames returns a comma-separated string of method names for a struct
+func (c *GoToTSCompiler) collectMethodNames(structName string) string {
+	var methodNames []string
+
+	for _, fileSyntax := range c.pkg.Syntax {
+		for _, decl := range fileSyntax.Decls {
+			funcDecl, isFunc := decl.(*ast.FuncDecl)
+			if !isFunc || funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
+				continue // Skip non-functions or functions without receivers
+			}
+
+			// Check if the receiver type matches the struct name
+			recvField := funcDecl.Recv.List[0]
+			recvType := recvField.Type
+			// Handle pointer receivers (*MyStruct) and value receivers (MyStruct)
+			if starExpr, ok := recvType.(*ast.StarExpr); ok {
+				recvType = starExpr.X // Get the type being pointed to
+			}
+
+			// Check if the receiver identifier name matches the struct name
+			if ident, ok := recvType.(*ast.Ident); ok && ident.Name == structName {
+				// Found a method for this struct
+				methodNames = append(methodNames, fmt.Sprintf("'%s'", funcDecl.Name.Name))
+			}
+		}
+	}
+
+	return strings.Join(methodNames, ", ")
+}
+
+// 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
+	methodNamesMap := make(map[string]struct{})
+
+	if interfaceType.Methods != nil {
+		for _, method := range interfaceType.Methods.List {
+			if len(method.Names) > 0 {
+				// Named method
+				methodNamesMap[method.Names[0].Name] = struct{}{}
+			} else {
+				// Embedded interface - resolve it and collect its methods
+				embeddedType := method.Type
+
+				// Resolve the embedded interface using type information
+				if tv, ok := c.pkg.TypesInfo.Types[embeddedType]; ok && tv.Type != nil {
+					// Get the underlying interface type
+					var ifaceType *types.Interface
+					if named, ok := tv.Type.(*types.Named); ok {
+						if underlying, ok := named.Underlying().(*types.Interface); ok {
+							ifaceType = underlying
+						}
+					} else if underlying, ok := tv.Type.(*types.Interface); ok {
+						ifaceType = underlying
+					}
+
+					// Collect methods from the interface
+					if ifaceType != nil {
+						for i := 0; i < ifaceType.NumMethods(); i++ {
+							methodNamesMap[ifaceType.Method(i).Name()] = struct{}{}
+						}
+					}
+				} else {
+					// Couldn't resolve the embedded interface
+					c.tsw.WriteCommentLine("// Note: Some embedded interface methods may not be fully resolved")
+				}
+			}
+		}
+	}
+
+	// Convert the map to a slice for a deterministic output order
+	var methodNames []string
+	for name := range methodNamesMap {
+		methodNames = append(methodNames, fmt.Sprintf("'%s'", name))
+	}
+
+	// Sort for deterministic output
+	sort.Strings(methodNames)
+
+	return strings.Join(methodNames, ", ")
+}
+
 // WriteTypeSpec writes the type specification to the output.
 func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	if a.Doc != nil {
@@ -81,6 +166,18 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 		c.tsw.WriteLine("")
 		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
+		c.tsw.WriteLine("")
+		c.tsw.WriteLinef("// Register this type with the runtime type system")
+		c.tsw.WriteLinef("static __typeInfo = goscript.registerType(")
+		c.tsw.WriteLinef("  '%s',", className)
+		c.tsw.WriteLinef("  goscript.TypeKind.Struct,")
+		c.tsw.WriteLinef("  new %s(),", className)
+		c.tsw.WriteLinef("  new Set([%s]),", c.collectMethodNames(className))
+		c.tsw.WriteLinef("  %s", className)
+		c.tsw.WriteLinef(");")
+
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("}")
 	case *ast.InterfaceType:
@@ -88,8 +185,20 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 		if err := c.WriteValueExpr(a.Name); err != nil { // Interface name is a value identifier
 			return err
 		}
-		c.tsw.WriteLine(" ")
-		c.WriteTypeExpr(a.Type) // The interface definition itself is a type
+		c.tsw.WriteLiterally(" ") // Changed from WriteLine to WriteLiterally
+		c.WriteTypeExpr(a.Type)   // The interface definition itself is a type
+
+		// Add code to register the interface with the runtime system
+		interfaceName := a.Name.Name
+		c.tsw.WriteLine("")
+		c.tsw.WriteLinef("// Register this interface with the runtime type system")
+		c.tsw.WriteLinef("const %s__typeInfo = goscript.registerType(", interfaceName)
+		c.tsw.WriteLinef("  '%s',", interfaceName)
+		c.tsw.WriteLinef("  goscript.TypeKind.Interface,")
+		c.tsw.WriteLinef("  null,") // Zero value for interface is null
+		c.tsw.WriteLinef("  new Set([%s]),", c.collectInterfaceMethods(t))
+		c.tsw.WriteLinef("  undefined")
+		c.tsw.WriteLinef(");")
 	default:
 		// type alias
 		c.tsw.WriteLiterally("type ")
@@ -254,3 +363,67 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 
 	c.tsw.WriteImport(impName, importPath)
 }
+
+// WriteInterfaceMethodSignature writes a TypeScript interface method signature from a Go ast.Field.
+func (c *GoToTSCompiler) WriteInterfaceMethodSignature(field *ast.Field) error {
+	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")
+	}
+
+	methodName := field.Names[0]
+	funcType, ok := field.Type.(*ast.FuncType)
+	if !ok {
+		// Should not happen for valid interface methods, but handle defensively
+		c.tsw.WriteCommentInline("unexpected interface method type")
+		return fmt.Errorf("interface method type is not a FuncType")
+	}
+
+	// Write method name
+	c.WriteIdentValue(methodName)
+
+	// Write parameter list (name: type)
+	c.tsw.WriteLiterally("(")
+	if funcType.Params != nil {
+		for i, param := range funcType.Params.List {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			// Determine parameter name
+			paramName := fmt.Sprintf("_p%d", i) // Default placeholder
+			if len(param.Names) > 0 && param.Names[0].Name != "" && param.Names[0].Name != "_" {
+				paramName = param.Names[0].Name
+			}
+			c.tsw.WriteLiterally(paramName)
+			c.tsw.WriteLiterally(": ")
+			c.WriteTypeExpr(param.Type)
+		}
+	}
+	c.tsw.WriteLiterally(")")
+
+	// Write return type
+	// Use WriteFuncType's logic for return types, but without the async handling
+	if funcType.Results != nil && len(funcType.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if len(funcType.Results.List) == 1 && len(funcType.Results.List[0].Names) == 0 {
+			// Single unnamed return type
+			c.WriteTypeExpr(funcType.Results.List[0].Type)
+		} else {
+			// Multiple or named return types -> tuple
+			c.tsw.WriteLiterally("[")
+			for i, result := range funcType.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(result.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+	} else {
+		// No return value -> void
+		c.tsw.WriteLiterally(": void")
+	}
+
+	c.tsw.WriteLine(";") // Semicolon at the end of the method signature
+	return nil
+}