goscript 0.0.78 → 0.0.79

package/compiler/analysis.go

@@ -2756,23 +2756,25 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 	// Topologically sort methods by their dependencies
 	sorted, cycles := v.topologicalSortMethods(methodCalls)
 
-	// Mark methods in cycles - check if they contain async operations
-	// We can't rely on the call graph for methods in cycles (circular dependency),
-	// but we can still detect if they call async external methods
-	//
-	// We need to iterate multiple times because methods in cycles can call each other,
-	// and we need to propagate async status until no changes occur
+	// Analyze methods in dependency order (dependencies analyzed before dependents)
+	for _, methodKey := range sorted {
+		v.analyzeMethodAsyncTopological(methodKey, methodCalls[methodKey])
+	}
+
+	// Analyze methods in cycles after the acyclic portion of the graph is known.
+	// This lets recursive methods observe async callees outside the cycle while
+	// still converging over recursive edges inside the cycle.
 	maxIterations := 10
 	for range maxIterations {
 		changed := false
 
 		for _, methodKey := range cycles {
-			// For methods in cycles, we need to check their body directly for async operations
 			pkg := v.analysis.AllPackages[methodKey.PackagePath]
 			if pkg == nil && methodKey.PackagePath == v.pkg.Types.Path() {
 				pkg = v.pkg
 			}
 
+			isAsync := false
 			if pkg != nil {
 				var funcDecl *ast.FuncDecl
 				if methodKey.ReceiverType == "" {
@@ -2782,37 +2784,29 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 				}
 
 				if funcDecl != nil && funcDecl.Body != nil {
-					// Check if the method contains async operations (including calls to async external methods)
-					isAsync := v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
-
-					// Check if status changed
-					if oldStatus, exists := v.analysis.MethodAsyncStatus[methodKey]; !exists || oldStatus != isAsync {
-						changed = true
+					isAsync = v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
+					if !isAsync {
+						for _, callee := range methodCalls[methodKey] {
+							if calleeAsync, exists := v.analysis.MethodAsyncStatus[callee]; exists && calleeAsync {
+								isAsync = true
+								break
+							}
+						}
 					}
-
-					v.analysis.MethodAsyncStatus[methodKey] = isAsync
-					continue
 				}
 			}
 
-			// Fallback: mark as sync if we can't analyze the body
-			if _, exists := v.analysis.MethodAsyncStatus[methodKey]; !exists {
-				v.analysis.MethodAsyncStatus[methodKey] = false
+			if oldStatus, exists := v.analysis.MethodAsyncStatus[methodKey]; !exists || oldStatus != isAsync {
 				changed = true
 			}
+			v.analysis.MethodAsyncStatus[methodKey] = isAsync
 		}
 
-		// If no changes in this iteration, we're done
 		if !changed {
 			break
 		}
 	}
 
-	// Analyze methods in dependency order (dependencies analyzed before dependents)
-	for _, methodKey := range sorted {
-		v.analyzeMethodAsyncTopological(methodKey, methodCalls[methodKey])
-	}
-
 	// Track async-returning variables BEFORE analyzing function literals
 	// This detects variables assigned from higher-order functions with async function literal args
 	// e.g., indirect := sync.OnceValue(asyncFunc)
@@ -3259,6 +3253,11 @@ func (v *analysisVisitor) containsAsyncOperationsComplete(node ast.Node, pkg *pa
 		if n == nil {
 			return false
 		}
+		if n != node {
+			if _, ok := n.(*ast.FuncLit); ok {
+				return false
+			}
+		}
 
 		switch s := n.(type) {
 		case *ast.SendStmt:

package/compiler/decl.go

@@ -1,7 +1,6 @@
 package compiler
 
 import (
-	"bytes"
 	"fmt"
 	"go/ast"
 	"go/token"
@@ -678,14 +677,6 @@ 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 ")
 
@@ -753,31 +744,6 @@ 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

@@ -513,7 +513,8 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 }
 
 // WriteNamedStructTypeSpec generates a TypeScript class for a named type whose
-// underlying type is a struct defined elsewhere.
+// underlying type is another named struct. The emitted class copies the field
+// layout without inheriting the underlying named type's prototype methods.
 func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.Named) error {
 	isInsideFunction := false
 	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
@@ -531,8 +532,6 @@ func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.
 		c.WriteTypeParameters(a.TypeParams)
 	}
 
-	c.tsw.WriteLiterally(" extends ")
-	c.WriteTypeExpr(a.Type)
 	c.tsw.WriteLiterally(" ")
 	c.tsw.WriteLine("{")
 	c.tsw.Indent(1)
@@ -543,16 +542,77 @@ func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.
 		return fmt.Errorf("underlying type of %s is not a struct", a.Name.Name)
 	}
 
-	c.tsw.WriteLine("constructor(init?: any) {")
+	underlyingType := c.pkg.TypesInfo.TypeOf(a.Type)
+	underlyingInitType := "{}"
+	if underlyingNamed, ok := underlyingType.(*types.Named); ok {
+		underlyingInitType = c.generateFlattenedInitTypeString(underlyingNamed, nil)
+	}
+	underlyingTypeName := c.getASTTypeString(a.Type, underlyingType)
+
+	for i := 0; i < underlyingStruct.NumFields(); i++ {
+		field := underlyingStruct.Field(i)
+		if field.Anonymous() {
+			continue
+		}
+		if !field.Exported() && field.Pkg() != c.pkg.Types {
+			continue
+		}
+		c.writeGetterSetter(field.Name(), field.Type(), nil, nil, nil)
+	}
+
+	for field := range underlyingStruct.Fields() {
+		if field.Anonymous() {
+			fieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
+			c.writeGetterSetter(fieldKeyName, field.Type(), nil, nil, nil)
+		}
+	}
+
+	c.tsw.WriteLiterally("public _fields: {")
 	c.tsw.Indent(1)
-	c.tsw.WriteLine("super(init)")
+	c.tsw.WriteLine("")
+	for i := 0; i < underlyingStruct.NumFields(); i++ {
+		field := underlyingStruct.Field(i)
+		fieldKeyName := field.Name()
+		if field.Anonymous() {
+			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+		}
+		if fieldKeyName == "_" {
+			continue
+		}
+		c.tsw.WriteLinef("%s: $.VarRef<%s>;", fieldKeyName, c.getTypeString(field.Type()))
+	}
 	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
 	c.tsw.WriteLine("")
 
-	c.tsw.WriteLinef("public clone(): %s {", className)
+	c.tsw.WriteLinef("constructor(init?: Partial<%s>) {", underlyingInitType)
+	c.tsw.Indent(1)
+	c.tsw.WriteLinef("const base = new %s(init)", underlyingTypeName)
+	c.tsw.WriteLine("this._fields = base._fields")
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+
+	var cloneReturnType strings.Builder
+	cloneReturnType.WriteString(className)
+	if a.TypeParams != nil && len(a.TypeParams.List) > 0 {
+		cloneReturnType.WriteString("<")
+		first := true
+		for _, field := range a.TypeParams.List {
+			for _, name := range field.Names {
+				if !first {
+					cloneReturnType.WriteString(", ")
+				}
+				first = false
+				cloneReturnType.WriteString(name.Name)
+			}
+		}
+		cloneReturnType.WriteString(">")
+	}
+
+	c.tsw.WriteLinef("public clone(): %s {", cloneReturnType.String())
 	c.tsw.Indent(1)
-	c.tsw.WriteLinef("const cloned = new %s()", className)
+	c.tsw.WriteLinef("const cloned = new %s()", cloneReturnType.String())
 	c.tsw.WriteLine("cloned._fields = {")
 	c.tsw.Indent(1)
 
@@ -560,11 +620,9 @@ func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.
 	for i := 0; i < underlyingStruct.NumFields(); i++ {
 		field := underlyingStruct.Field(i)
 		fieldType := field.Type()
-		var fieldKeyName string
+		fieldKeyName := field.Name()
 		if field.Anonymous() {
 			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		} else {
-			fieldKeyName = field.Name()
 		}
 		if fieldKeyName == "_" {
 			continue
@@ -615,6 +673,174 @@ func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.
 		}
 	}
 
+	seenPromotedFields := make(map[string]bool)
+	directMethods := make(map[string]bool)
+	for method := range named.Methods() {
+		sig := method.Type().(*types.Signature)
+		if sig.Recv() != nil {
+			recvType := sig.Recv().Type()
+			if namedRecv, ok := recvType.(*types.Named); ok && namedRecv.Obj() == named.Obj() {
+				directMethods[method.Name()] = true
+			} else if ptrRecv, ok := recvType.(*types.Pointer); ok {
+				if namedElem, ok := ptrRecv.Elem().(*types.Named); ok && namedElem.Obj() == named.Obj() {
+					directMethods[method.Name()] = true
+				}
+			}
+		}
+	}
+
+	for field := range underlyingStruct.Fields() {
+		if !field.Anonymous() {
+			continue
+		}
+
+		embeddedFieldType := field.Type()
+		embeddedFieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
+
+		trueEmbeddedType := embeddedFieldType
+		if ptr, isPtr := trueEmbeddedType.(*types.Pointer); isPtr {
+			trueEmbeddedType = ptr.Elem()
+		}
+		if _, isNamed := trueEmbeddedType.(*types.Named); !isNamed {
+			continue
+		}
+
+		if namedEmbedded, ok := trueEmbeddedType.(*types.Named); ok {
+			if underlyingEmbeddedStruct, ok := namedEmbedded.Underlying().(*types.Struct); ok {
+				for promotedField := range underlyingEmbeddedStruct.Fields() {
+					if !promotedField.Exported() && promotedField.Pkg() != c.pkg.Types {
+						continue
+					}
+					promotedFieldName := promotedField.Name()
+					if seenPromotedFields[promotedFieldName] {
+						continue
+					}
+					conflict := false
+					for field := range underlyingStruct.Fields() {
+						if !field.Anonymous() && field.Name() == promotedFieldName {
+							conflict = true
+							break
+						}
+					}
+					if conflict {
+						continue
+					}
+
+					seenPromotedFields[promotedFieldName] = true
+					tsPromotedFieldType := c.getTypeString(promotedField.Type())
+					c.tsw.WriteLine("")
+					c.tsw.WriteLinef("public get %s(): %s {", promotedFieldName, tsPromotedFieldType)
+					c.tsw.Indent(1)
+					embeddedFieldTypeUnderlying := embeddedFieldType
+					if ptr, isPtr := embeddedFieldTypeUnderlying.(*types.Pointer); isPtr {
+						embeddedFieldTypeUnderlying = ptr.Elem()
+					}
+					if named, isNamed := embeddedFieldTypeUnderlying.(*types.Named); isNamed {
+						embeddedFieldTypeUnderlying = named.Underlying()
+					}
+					if _, isInterface := embeddedFieldTypeUnderlying.(*types.Interface); isInterface {
+						c.tsw.WriteLinef("return this.%s!.%s", embeddedFieldKeyName, promotedFieldName)
+					} else {
+						c.tsw.WriteLinef("return this.%s.%s", embeddedFieldKeyName, promotedFieldName)
+					}
+					c.tsw.Indent(-1)
+					c.tsw.WriteLine("}")
+					c.tsw.WriteLinef("public set %s(value: %s) {", promotedFieldName, tsPromotedFieldType)
+					c.tsw.Indent(1)
+					if _, isInterface := embeddedFieldTypeUnderlying.(*types.Interface); isInterface {
+						c.tsw.WriteLinef("this.%s!.%s = value", embeddedFieldKeyName, promotedFieldName)
+					} else {
+						c.tsw.WriteLinef("this.%s.%s = value", embeddedFieldKeyName, promotedFieldName)
+					}
+					c.tsw.Indent(-1)
+					c.tsw.WriteLine("}")
+				}
+			}
+		}
+
+		methodSetType := embeddedFieldType
+		if _, isPtr := embeddedFieldType.(*types.Pointer); !isPtr {
+			if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); !isInterface {
+				methodSetType = types.NewPointer(embeddedFieldType)
+			}
+		}
+		embeddedMethodSet := types.NewMethodSet(methodSetType)
+		for methodSelection := range embeddedMethodSet.Methods() {
+			method := methodSelection.Obj().(*types.Func)
+			methodName := method.Name()
+
+			if len(methodSelection.Index()) == 1 && !directMethods[methodName] && !seenPromotedFields[methodName] {
+				conflictWithField := false
+				for field := range underlyingStruct.Fields() {
+					if !field.Anonymous() && field.Name() == methodName {
+						conflictWithField = true
+						break
+					}
+				}
+				if conflictWithField {
+					continue
+				}
+
+				seenPromotedFields[methodName] = true
+				sig := method.Type().(*types.Signature)
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("public ")
+				c.tsw.WriteLiterally(methodName)
+				c.tsw.WriteLiterally("(")
+				params := sig.Params()
+				paramNames := make([]string, params.Len())
+				for j := 0; j < params.Len(); j++ {
+					param := params.At(j)
+					paramName := param.Name()
+					if paramName == "" || paramName == "_" {
+						paramName = fmt.Sprintf("_p%d", j)
+					}
+					paramNames[j] = paramName
+					if j > 0 {
+						c.tsw.WriteLiterally(", ")
+					}
+					c.tsw.WriteLiterally(paramName)
+					c.tsw.WriteLiterally(": ")
+					c.WriteGoType(param.Type(), GoTypeContextGeneral)
+				}
+				c.tsw.WriteLiterally(")")
+				results := sig.Results()
+				if results.Len() > 0 {
+					c.tsw.WriteLiterally(": ")
+					if results.Len() == 1 {
+						c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn)
+					} else {
+						c.tsw.WriteLiterally("[")
+						for j := 0; j < results.Len(); j++ {
+							if j > 0 {
+								c.tsw.WriteLiterally(", ")
+							}
+							c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn)
+						}
+						c.tsw.WriteLiterally("]")
+					}
+				} else {
+					c.tsw.WriteLiterally(": void")
+				}
+				c.tsw.WriteLine(" {")
+				c.tsw.Indent(1)
+				if results.Len() > 0 {
+					c.tsw.WriteLiterally("return ")
+				}
+
+				assertionPrefix := "this.%s"
+				if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); isInterface {
+					assertionPrefix = "this.%s!"
+				}
+				c.tsw.WriteLiterallyf(assertionPrefix+".%s(%s)", embeddedFieldKeyName, methodName, strings.Join(paramNames, ", "))
+
+				c.tsw.WriteLine("")
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}")
+			}
+		}
+	}
+
 	c.tsw.WriteLine("")
 	c.tsw.WriteLine("// Register this type with the runtime type system")
 
@@ -652,11 +878,9 @@ func (c *GoToTSCompiler) WriteNamedStructTypeSpec(a *ast.TypeSpec, named *types.
 	firstField := true
 	for i := 0; i < underlyingStruct.NumFields(); i++ {
 		field := underlyingStruct.Field(i)
-		var fieldKeyName string
+		fieldKeyName := field.Name()
 		if field.Anonymous() {
 			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		} else {
-			fieldKeyName = field.Name()
 		}
 		if fieldKeyName == "_" {
 			continue

package/compiler/spec.go

@@ -370,13 +370,6 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 				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 ")
 				}

package/package.json

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