goscript 0.0.77 → 0.0.78

package/compiler/decl.go

@@ -1,6 +1,7 @@
 package compiler
 
 import (
+	"bytes"
 	"fmt"
 	"go/ast"
 	"go/token"
@@ -677,6 +678,14 @@ func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error)
 		}
 	}
 
+	if !isAsync {
+		bodyNeedsAsync, err := c.funcBodyNeedsAsync(decl, true)
+		if err != nil {
+			return false, err
+		}
+		isAsync = bodyNeedsAsync
+	}
+
 	// Methods are typically public in the TS output
 	c.tsw.WriteLiterally("public ")
 
@@ -744,6 +753,31 @@ func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error)
 	return isAsync, nil
 }
 
+// funcBodyNeedsAsync checks whether emitting a function body would generate await.
+func (c *GoToTSCompiler) funcBodyNeedsAsync(decl *ast.FuncDecl, isMethod bool) (bool, error) {
+	if decl.Body == nil {
+		return false, nil
+	}
+
+	var body strings.Builder
+	writer := NewTSCodeWriter(&body)
+	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis, c.currentFilePath)
+
+	if isMethod {
+		if err := tempCompiler.writeMethodBodyWithReceiverBinding(decl, "this"); err != nil {
+			return false, err
+		}
+	} else {
+		for _, stmt := range decl.Body.List {
+			if err := tempCompiler.WriteStmt(stmt); err != nil {
+				return false, err
+			}
+		}
+	}
+
+	return bytes.Contains([]byte(body.String()), []byte("await")), nil
+}
+
 // writeMethodBodyWithReceiverBinding writes the method body with optional receiver binding
 // receiverTarget should be "this" for struct methods or "this._value" for named type methods
 func (c *GoToTSCompiler) writeMethodBodyWithReceiverBinding(decl *ast.FuncDecl, receiverTarget string) error {

package/compiler/spec-struct.go

@@ -512,6 +512,179 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	return nil
 }
 
+// WriteNamedStructTypeSpec generates a TypeScript class for a named type whose
+// underlying type is a struct defined elsewhere.
+func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.Named) error {
+	isInsideFunction := false
+	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+		isInsideFunction = nodeInfo.IsInsideFunction
+	}
+	if !isInsideFunction {
+		c.tsw.WriteLiterally("export ")
+	}
+	c.tsw.WriteLiterally("class ")
+	if err := c.WriteValueExpr(a.Name); err != nil {
+		return err
+	}
+
+	if a.TypeParams != nil {
+		c.WriteTypeParameters(a.TypeParams)
+	}
+
+	c.tsw.WriteLiterally(" extends ")
+	c.WriteTypeExpr(a.Type)
+	c.tsw.WriteLiterally(" ")
+	c.tsw.WriteLine("{")
+	c.tsw.Indent(1)
+
+	className := sanitizeIdentifier(a.Name.Name)
+	underlyingStruct, ok := named.Underlying().(*types.Struct)
+	if !ok {
+		return fmt.Errorf("underlying type of %s is not a struct", a.Name.Name)
+	}
+
+	c.tsw.WriteLine("constructor(init?: any) {")
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("super(init)")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+
+	c.tsw.WriteLinef("public clone(): %s {", className)
+	c.tsw.Indent(1)
+	c.tsw.WriteLinef("const cloned = new %s()", className)
+	c.tsw.WriteLine("cloned._fields = {")
+	c.tsw.Indent(1)
+
+	firstFieldWritten := false
+	for i := 0; i < underlyingStruct.NumFields(); i++ {
+		field := underlyingStruct.Field(i)
+		fieldType := field.Type()
+		var fieldKeyName string
+		if field.Anonymous() {
+			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+		} else {
+			fieldKeyName = field.Name()
+		}
+		if fieldKeyName == "_" {
+			continue
+		}
+
+		if firstFieldWritten {
+			c.tsw.WriteLine(",")
+		}
+		c.writeClonedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
+		firstFieldWritten = true
+	}
+	if firstFieldWritten {
+		c.tsw.WriteLine("")
+	}
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("return cloned")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	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
+			}
+			recvType := funcDecl.Recv.List[0].Type
+			if starExpr, ok := recvType.(*ast.StarExpr); ok {
+				recvType = starExpr.X
+			}
+
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = sanitizeIdentifier(ident.Name)
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = sanitizeIdentifier(ident.Name)
+				}
+			}
+
+			if recvTypeName == className {
+				c.tsw.WriteLine("")
+				if err := c.WriteFuncDeclAsMethod(funcDecl); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	c.tsw.WriteLine("")
+	c.tsw.WriteLine("// Register this type with the runtime type system")
+
+	structName := className
+	pkgPath := c.pkg.Types.Path()
+	pkgName := c.pkg.Types.Name()
+	if pkgPath != "" && pkgName != "main" {
+		structName = pkgPath + "." + className
+	} else if pkgName == "main" {
+		structName = "main." + className
+	}
+
+	c.tsw.WriteLine("static __typeInfo = $.registerStructType(")
+	c.tsw.WriteLinef("  %q,", structName)
+	c.tsw.WriteLinef("  new %s(),", className)
+	c.tsw.WriteLiterally("  [")
+
+	var structMethods []*types.Func
+	for method := range named.Methods() {
+		sig := method.Type().(*types.Signature)
+		recv := sig.Recv().Type()
+		if ptr, ok := recv.(*types.Pointer); ok {
+			recv = ptr.Elem()
+		}
+		if namedRecv, ok := recv.(*types.Named); ok && namedRecv.Obj() == named.Obj() {
+			structMethods = append(structMethods, method)
+		}
+	}
+	c.writeMethodSignatures(structMethods)
+	c.tsw.WriteLiterally("],")
+	c.tsw.WriteLine("")
+
+	c.tsw.WriteLinef("  %s,", className)
+	c.tsw.WriteLiterally("  {")
+	firstField := true
+	for i := 0; i < underlyingStruct.NumFields(); i++ {
+		field := underlyingStruct.Field(i)
+		var fieldKeyName string
+		if field.Anonymous() {
+			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+		} else {
+			fieldKeyName = field.Name()
+		}
+		if fieldKeyName == "_" {
+			continue
+		}
+		if !firstField {
+			c.tsw.WriteLiterally(", ")
+		}
+		firstField = false
+		c.tsw.WriteLiterallyf("%q: ", fieldKeyName)
+
+		tag := underlyingStruct.Tag(i)
+		if tag != "" {
+			c.tsw.WriteLiterally("{ type: ")
+			c.writeTypeInfoObject(field.Type())
+			c.tsw.WriteLiterallyf(", tag: %q }", tag)
+		} else {
+			c.writeTypeInfoObject(field.Type())
+		}
+	}
+	c.tsw.WriteLiterally("}")
+	c.tsw.WriteLine("")
+	c.tsw.WriteLine(");")
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	return nil
+}
+
 // generateFlattenedInitTypeString generates a TypeScript type string for the
 // initialization object passed to a Go struct's constructor (`_init` method in TypeScript).
 // The generated type is a `Partial`-like structure, `"{ Field1?: Type1, Field2?: Type2, ... }"`,

package/compiler/spec.go

@@ -366,6 +366,20 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 
 			if recvTypeName == className {
 				c.tsw.WriteLiterally("export function ")
+				var isAsync bool
+				if obj := c.pkg.TypesInfo.Defs[funcDecl.Name]; obj != nil {
+					isAsync = c.analysis.IsAsyncFunc(obj)
+				}
+				if !isAsync {
+					bodyNeedsAsync, err := c.funcBodyNeedsAsync(funcDecl, false)
+					if err != nil {
+						return err
+					}
+					isAsync = bodyNeedsAsync
+				}
+				if isAsync {
+					c.tsw.WriteLiterally("async ")
+				}
 				c.tsw.WriteLiterally(className)
 				c.tsw.WriteLiterally("_")
 				c.tsw.WriteLiterally(funcDecl.Name.Name)
@@ -403,6 +417,9 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 				// Add return type
 				if funcDecl.Type.Results != nil && len(funcDecl.Type.Results.List) > 0 {
 					c.tsw.WriteLiterally(": ")
+					if isAsync {
+						c.tsw.WriteLiterally("Promise<")
+					}
 					if len(funcDecl.Type.Results.List) == 1 {
 						c.WriteTypeExpr(funcDecl.Type.Results.List[0].Type)
 					} else {
@@ -424,8 +441,15 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 						}
 						c.tsw.WriteLiterally("]")
 					}
+					if isAsync {
+						c.tsw.WriteLiterally(">")
+					}
 				} else {
-					c.tsw.WriteLiterally(": void")
+					if isAsync {
+						c.tsw.WriteLiterally(": Promise<void>")
+					} else {
+						c.tsw.WriteLiterally(": void")
+					}
 				}
 
 				c.tsw.WriteLine(" {")
@@ -476,6 +500,11 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	default:
 		// Check if this type has receiver methods
 		if c.hasReceiverMethods(a.Name.Name) {
+			if named, ok := c.pkg.TypesInfo.Defs[a.Name].Type().(*types.Named); ok {
+				if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+					return c.WriteNamedStructTypeSpec(a, named)
+				}
+			}
 			return c.WriteNamedTypeWithMethods(a)
 		}
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.77",
+  "version": "0.0.78",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",