goscript 0.0.77 → 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/spec-struct.go

@@ -512,6 +512,403 @@ 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 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 {
+		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(" ")
+	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)
+	}
+
+	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("")
+	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("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()", cloneReturnType.String())
+	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()
+		fieldKeyName := field.Name()
+		if field.Anonymous() {
+			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+		}
+		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
+				}
+			}
+		}
+	}
+
+	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")
+
+	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)
+		fieldKeyName := field.Name()
+		if field.Anonymous() {
+			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+		}
+		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,13 @@ 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 {
+					c.tsw.WriteLiterally("async ")
+				}
 				c.tsw.WriteLiterally(className)
 				c.tsw.WriteLiterally("_")
 				c.tsw.WriteLiterally(funcDecl.Name.Name)
@@ -403,6 +410,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 +434,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 +493,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.79",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",