goscript 0.0.57 → 0.0.59

package/compiler/decl.go

@@ -3,7 +3,9 @@ package compiler
 import (
 	"fmt"
 	"go/ast"
+	"go/token"
 	"go/types"
+	"sort"
 )
 
 // WriteDecls iterates through a slice of Go top-level declarations (`ast.Decl`)
@@ -17,33 +19,442 @@ import (
 //     variables, or type definitions: It iterates through `d.Specs` and calls
 //     `WriteSpec` for each specification.
 //
+// Type declarations are sorted by dependencies to ensure referenced types are
+// defined before types that reference them, avoiding initialization order issues.
 // A newline is added after each processed declaration or spec group for readability.
 // Unknown declaration types result in a printed diagnostic message.
 func (c *GoToTSCompiler) WriteDecls(decls []ast.Decl) error {
+	// Separate type declarations from other declarations for dependency sorting
+	var typeSpecs []*ast.TypeSpec
+	var varSpecs []*ast.ValueSpec
+	var otherDecls []ast.Decl
+	var otherSpecs []ast.Spec
+
 	for _, decl := range decls {
 		switch d := decl.(type) {
 		case *ast.FuncDecl:
 			// Only handle top-level functions here. Methods are handled within WriteTypeSpec.
 			if d.Recv == nil {
-				if err := c.WriteFuncDeclAsFunction(d); err != nil {
-					return err
-				}
-				c.tsw.WriteLine("") // Add space after function
+				otherDecls = append(otherDecls, d)
 			}
 		case *ast.GenDecl:
 			for _, spec := range d.Specs {
-				if err := c.WriteSpec(spec); err != nil {
-					return err
+				if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+					typeSpecs = append(typeSpecs, typeSpec)
+				} else if varSpec, ok := spec.(*ast.ValueSpec); ok && d.Tok == token.VAR {
+					varSpecs = append(varSpecs, varSpec)
+				} else {
+					otherSpecs = append(otherSpecs, spec)
 				}
-				c.tsw.WriteLine("") // Add space after spec
 			}
+		default:
+			otherDecls = append(otherDecls, d)
+		}
+	}
+
+	// Sort type declarations by dependencies
+	sortedTypeSpecs, err := c.sortTypeSpecsByDependencies(typeSpecs)
+	if err != nil {
+		// Surface the error instead of silently falling back
+		return fmt.Errorf("circular dependency detected sorting type declarations: %w", err)
+	}
+
+	// Sort variable declarations by type dependencies
+	sortedVarSpecs, err := c.sortVarSpecsByTypeDependencies(varSpecs, typeSpecs)
+	if err != nil {
+		return fmt.Errorf("failed to sort variable declarations: %w", err)
+	}
+
+	// Write non-type, non-var declarations first (imports, constants)
+	for _, spec := range otherSpecs {
+		if err := c.WriteSpec(spec); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("") // Add space after spec
+	}
+
+	// Write sorted type declarations
+	for _, typeSpec := range sortedTypeSpecs {
+		if err := c.WriteSpec(typeSpec); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("") // Add space after spec
+	}
+
+	// Write sorted variable declarations
+	for _, varSpec := range sortedVarSpecs {
+		if err := c.WriteSpec(varSpec); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("") // Add space after spec
+	}
+
+	// Write function declarations last
+	for _, decl := range otherDecls {
+		switch d := decl.(type) {
+		case *ast.FuncDecl:
+			if err := c.WriteFuncDeclAsFunction(d); err != nil {
+				return err
+			}
+			c.tsw.WriteLine("") // Add space after function
 		default:
 			return fmt.Errorf("unknown decl: %#v", decl)
 		}
 	}
+
 	return nil
 }
 
+// sortTypeSpecsByDependencies performs a topological sort of type specifications
+// based on their dependencies to ensure referenced types are defined before
+// types that reference them.
+func (c *GoToTSCompiler) sortTypeSpecsByDependencies(typeSpecs []*ast.TypeSpec) ([]*ast.TypeSpec, error) {
+	if len(typeSpecs) <= 1 {
+		return typeSpecs, nil
+	}
+
+	// Build dependency graph
+	dependencies := make(map[string][]string) // typeName -> list of types it depends on
+	typeSpecMap := make(map[string]*ast.TypeSpec)
+
+	// First pass: collect all type names
+	for _, typeSpec := range typeSpecs {
+		typeName := typeSpec.Name.Name
+		typeSpecMap[typeName] = typeSpec
+		dependencies[typeName] = []string{}
+	}
+
+	// Second pass: analyze dependencies
+	for _, typeSpec := range typeSpecs {
+		typeName := typeSpec.Name.Name
+		deps := c.extractTypeDependencies(typeSpec.Type, typeSpecMap)
+		dependencies[typeName] = deps
+	}
+
+	// Perform topological sort
+	sorted, err := c.topologicalSort(dependencies)
+	if err != nil {
+		return nil, err
+	}
+
+	// Build result in sorted order
+	var result []*ast.TypeSpec
+	for _, typeName := range sorted {
+		if typeSpec, exists := typeSpecMap[typeName]; exists {
+			result = append(result, typeSpec)
+		}
+	}
+
+	return result, nil
+}
+
+// extractTypeDependencies extracts only the dependencies that cause TypeScript initialization order issues.
+// These are dependencies where the constructor of one type directly instantiates another type.
+//
+// TRUE dependencies (cause initialization issues):
+// - Direct struct fields (non-pointer): type A struct { b B } -> A constructor calls new B()
+// - Embedded struct fields: type A struct { B } -> A constructor calls new B()
+// - Direct type aliases: type A B -> A directly wraps B
+// - Array/slice of structs: type A []B -> needs B for default values
+//
+// FALSE dependencies (don't cause initialization issues):
+// - Pointer fields: type A struct { b *B } -> just stores reference, no constructor call
+// - Interface fields: type A struct { b SomeInterface } -> stores interface, no concrete instantiation
+// - Map types: type A map[K]V -> map initialized empty, no constructor calls
+// - Array/slice of pointers: type A []*B -> array of pointers, no constructor calls
+func (c *GoToTSCompiler) extractTypeDependencies(typeExpr ast.Expr, typeSpecMap map[string]*ast.TypeSpec) []string {
+	var deps []string
+
+	switch t := typeExpr.(type) {
+	case *ast.Ident:
+		// Direct type reference (e.g., type MyType OtherType)
+		if _, isLocalType := typeSpecMap[t.Name]; isLocalType {
+			deps = append(deps, t.Name)
+		}
+
+	case *ast.StructType:
+		// Struct type - check field types, but be more selective
+		if t.Fields != nil {
+			for _, field := range t.Fields.List {
+				fieldDeps := c.extractStructFieldDependencies(field.Type, typeSpecMap)
+				deps = append(deps, fieldDeps...)
+			}
+		}
+
+	case *ast.ArrayType:
+		// Array/slice type - only depends on element type if element is a struct (not pointer)
+		if !c.isPointerType(t.Elt) {
+			elemDeps := c.extractTypeDependencies(t.Elt, typeSpecMap)
+			deps = append(deps, elemDeps...)
+		}
+		// Arrays of pointers don't create initialization dependencies
+
+	case *ast.StarExpr:
+		// Pointer types don't create initialization dependencies
+		// The pointed-to type doesn't need to be initialized when creating a pointer field
+
+	case *ast.MapType:
+		// Map types don't create initialization dependencies
+		// Maps are initialized empty, no constructor calls needed
+
+	case *ast.InterfaceType:
+		// Interface types don't create initialization dependencies
+
+	case *ast.FuncType:
+		// Function types don't create initialization dependencies
+
+	case *ast.SelectorExpr:
+		// External package types don't create local dependencies
+
+		// Add other type expressions as needed
+	}
+
+	// Sort dependencies for deterministic output
+	sort.Strings(deps)
+	return deps
+}
+
+// extractStructFieldDependencies extracts dependencies from struct field types
+func (c *GoToTSCompiler) extractStructFieldDependencies(fieldType ast.Expr, typeSpecMap map[string]*ast.TypeSpec) []string {
+	var deps []string
+
+	switch t := fieldType.(type) {
+	case *ast.Ident:
+		// Direct field type: struct { b B } - this requires B to be initialized
+		if _, isLocalType := typeSpecMap[t.Name]; isLocalType {
+			deps = append(deps, t.Name)
+		}
+
+	case *ast.StarExpr:
+		// Pointer field: struct { b *B } - this doesn't require B initialization
+		// Pointers are just references, no constructor call needed
+
+	case *ast.ArrayType:
+		// Array field: struct { b []B } or struct { b [5]B }
+		// Only create dependency if element type is not a pointer
+		if !c.isPointerType(t.Elt) {
+			elemDeps := c.extractTypeDependencies(t.Elt, typeSpecMap)
+			deps = append(deps, elemDeps...)
+		}
+
+	case *ast.MapType:
+		// Map field: struct { b map[K]V } - maps don't require initialization dependencies
+
+	case *ast.InterfaceType:
+		// Interface field: struct { b SomeInterface } - no concrete type dependency
+
+	case *ast.FuncType:
+		// Function field: struct { b func() } - no dependency
+
+		// Handle other field types as needed
+	}
+
+	return deps
+}
+
+// sortVarSpecsByTypeDependencies sorts variable declarations based on their type dependencies
+func (c *GoToTSCompiler) sortVarSpecsByTypeDependencies(varSpecs []*ast.ValueSpec, typeSpecs []*ast.TypeSpec) ([]*ast.ValueSpec, error) {
+	if len(varSpecs) <= 1 {
+		return varSpecs, nil
+	}
+
+	// Build type name map
+	typeSpecMap := make(map[string]*ast.TypeSpec)
+	for _, typeSpec := range typeSpecs {
+		typeSpecMap[typeSpec.Name.Name] = typeSpec
+	}
+
+	// Group variables by dependency status with names for sorting
+	type namedVarSpec struct {
+		spec *ast.ValueSpec
+		name string
+	}
+
+	var independentVars []namedVarSpec
+	var dependentVars []namedVarSpec
+
+	for _, varSpec := range varSpecs {
+		// Get variable name for sorting
+		varName := ""
+		if len(varSpec.Names) > 0 {
+			varName = varSpec.Names[0].Name
+		}
+
+		hasDependency := false
+
+		// Check type annotation
+		if varSpec.Type != nil {
+			deps := c.extractTypeDependencies(varSpec.Type, typeSpecMap)
+			if len(deps) > 0 {
+				hasDependency = true
+			}
+		}
+
+		// Check initializer expressions for type usage
+		if !hasDependency {
+			for _, value := range varSpec.Values {
+				if c.hasTypeReferences(value, typeSpecMap) {
+					hasDependency = true
+					break
+				}
+			}
+		}
+
+		namedVar := namedVarSpec{spec: varSpec, name: varName}
+		if hasDependency {
+			dependentVars = append(dependentVars, namedVar)
+		} else {
+			independentVars = append(independentVars, namedVar)
+		}
+	}
+
+	// Sort both groups by name for deterministic output
+	sort.Slice(independentVars, func(i, j int) bool {
+		return independentVars[i].name < independentVars[j].name
+	})
+	sort.Slice(dependentVars, func(i, j int) bool {
+		return dependentVars[i].name < dependentVars[j].name
+	})
+
+	// Return independent variables first, then dependent ones
+	result := make([]*ast.ValueSpec, 0, len(varSpecs))
+	for _, namedVar := range independentVars {
+		result = append(result, namedVar.spec)
+	}
+	for _, namedVar := range dependentVars {
+		result = append(result, namedVar.spec)
+	}
+
+	return result, nil
+}
+
+// hasTypeReferences checks if an expression contains references to local types
+func (c *GoToTSCompiler) hasTypeReferences(expr ast.Expr, typeSpecMap map[string]*ast.TypeSpec) bool {
+	hasRef := false
+
+	ast.Inspect(expr, func(n ast.Node) bool {
+		switch t := n.(type) {
+		case *ast.CallExpr:
+			// Check function calls like new Message(), makeChannel<Message>()
+			if ident, ok := t.Fun.(*ast.Ident); ok {
+				if _, isLocalType := typeSpecMap[ident.Name]; isLocalType {
+					hasRef = true
+					return false
+				}
+			}
+			// Check type arguments in generic calls
+			if funcType, ok := t.Fun.(*ast.IndexExpr); ok {
+				if c.hasTypeReferences(funcType.Index, typeSpecMap) {
+					hasRef = true
+					return false
+				}
+			}
+		case *ast.CompositeLit:
+			// Check composite literals like Message{...}
+			if ident, ok := t.Type.(*ast.Ident); ok {
+				if _, isLocalType := typeSpecMap[ident.Name]; isLocalType {
+					hasRef = true
+					return false
+				}
+			}
+		case *ast.Ident:
+			// Check direct type references
+			if _, isLocalType := typeSpecMap[t.Name]; isLocalType {
+				hasRef = true
+				return false
+			}
+		}
+		return !hasRef // Stop walking if we found a reference
+	})
+
+	return hasRef
+}
+
+// topologicalSort performs a topological sort of the dependency graph
+func (c *GoToTSCompiler) topologicalSort(dependencies map[string][]string) ([]string, error) {
+	// Kahn's algorithm for topological sorting with deterministic ordering
+	inDegree := make(map[string]int)
+	graph := make(map[string][]string)
+
+	// Initialize in-degree counts and reverse graph
+	for node := range dependencies {
+		inDegree[node] = 0
+		graph[node] = []string{}
+	}
+
+	// Build reverse graph and count in-degrees
+	for node, deps := range dependencies {
+		// Sort dependencies for consistent output
+		sortedDeps := make([]string, len(deps))
+		copy(sortedDeps, deps)
+		sort.Strings(sortedDeps)
+
+		for _, dep := range sortedDeps {
+			if _, exists := inDegree[dep]; exists {
+				graph[dep] = append(graph[dep], node)
+				inDegree[node]++
+			}
+		}
+	}
+
+	// Sort neighbors in graph for consistency
+	for node := range graph {
+		sort.Strings(graph[node])
+	}
+
+	// Find nodes with no incoming edges and sort them
+	var queue []string
+	for node, degree := range inDegree {
+		if degree == 0 {
+			queue = append(queue, node)
+		}
+	}
+	sort.Strings(queue) // Sort initial queue for deterministic output
+
+	var result []string
+
+	for len(queue) > 0 {
+		// Remove node from queue (already sorted)
+		current := queue[0]
+		queue = queue[1:]
+		result = append(result, current)
+
+		// Collect new zero-degree nodes
+		var newZeroNodes []string
+		for _, neighbor := range graph[current] {
+			inDegree[neighbor]--
+			if inDegree[neighbor] == 0 {
+				newZeroNodes = append(newZeroNodes, neighbor)
+			}
+		}
+
+		// Sort new zero-degree nodes and add to queue
+		sort.Strings(newZeroNodes)
+		queue = append(queue, newZeroNodes...)
+	}
+
+	// Check for cycles
+	if len(result) != len(dependencies) {
+		// Find the remaining nodes to help debug the circular dependency
+		processed := make(map[string]bool)
+		for _, name := range result {
+			processed[name] = true
+		}
+
+		var remaining []string
+		for name := range dependencies {
+			if !processed[name] {
+				remaining = append(remaining, name)
+			}
+		}
+		sort.Strings(remaining)
+
+		return nil, fmt.Errorf("circular dependency detected in type declarations. Remaining types: %v", remaining)
+	}
+
+	return result, nil
+}
+
 // WriteFuncDeclAsFunction translates a Go function declaration (`ast.FuncDecl`)
 // that does not have a receiver (i.e., it's a regular function, not a method)
 // into a TypeScript function.

package/compiler/expr-call-async.go

@@ -6,17 +6,13 @@ import (
 	"strings"
 )
 
-// writeAsyncCallIfNeeded writes the await prefix for async function or method calls
-// Returns true if await was written, false otherwise
-func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
+// isCallExprAsync determines if a CallExpr represents an async function/method call
+func (c *GoToTSCompiler) isCallExprAsync(exp *ast.CallExpr) bool {
 	switch fun := exp.Fun.(type) {
 	case *ast.Ident:
 		// Function call (e.g., func())
-		if obj := c.pkg.TypesInfo.Uses[fun]; obj != nil {
-			if c.analysis.IsAsyncFunc(obj) {
-				c.tsw.WriteLiterally("await ")
-				return true
-			}
+		if obj := c.objectOfIdent(fun); obj != nil {
+			return c.analysis.IsAsyncFunc(obj)
 		}
 		return false
 
@@ -29,13 +25,13 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 		switch x := fun.X.(type) {
 		case *ast.Ident:
 			// Direct identifier: obj.method()
-			obj = c.pkg.TypesInfo.Uses[x]
+			obj = c.objectOfIdent(x)
 			objOk = obj != nil
 
 		case *ast.StarExpr:
 			// Pointer dereference: (*p).method() or p.method() where p is a pointer
 			if id, isIdent := x.X.(*ast.Ident); isIdent {
-				obj = c.pkg.TypesInfo.Uses[id]
+				obj = c.objectOfIdent(id)
 				objOk = obj != nil
 			}
 
@@ -43,8 +39,6 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 			// Field access: obj.field.method()
 			// Get the type of the field access expression
 			if fieldType := c.pkg.TypesInfo.TypeOf(x); fieldType != nil {
-				// For field access, we create a synthetic object representing the field type
-				// We'll handle this case below when we determine the method's type
 				objOk = true
 			}
 
@@ -61,13 +55,7 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 			if pkgName, isPkg := obj.(*types.PkgName); isPkg {
 				methodName := fun.Sel.Name
 				pkgPath := pkgName.Imported().Path()
-
-				// Check if this package-level function is async (empty TypeName)
-				if c.analysis.IsMethodAsync(pkgPath, "", methodName) {
-					c.tsw.WriteLiterally("await ")
-					return true
-				}
-				return false
+				return c.analysis.IsMethodAsync(pkgPath, "", methodName)
 			}
 		}
 
@@ -83,7 +71,6 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 			}
 		} else {
 			// Field access case: obj.field.method()
-			// Get the type of the field access expression
 			targetType = c.pkg.TypesInfo.TypeOf(fun.X)
 			if targetType == nil {
 				return false
@@ -94,12 +81,7 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 
 		// Check if target type is an interface
 		if interfaceType, isInterface := targetType.Underlying().(*types.Interface); isInterface {
-			// Interface method call: use interface method async analysis
-			if c.analysis.IsInterfaceMethodAsync(interfaceType, methodName) {
-				c.tsw.WriteLiterally("await ")
-				return true
-			}
-			return false
+			return c.analysis.IsInterfaceMethodAsync(interfaceType, methodName)
 		}
 
 		// Get the named type from the target type
@@ -128,22 +110,26 @@ func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
 		if typePkg != nil {
 			pkgPath = typePkg.Path()
 		} else {
-			// Fallback to current package
 			pkgPath = c.pkg.Types.Path()
 		}
 
-		// Check if this method is async using unified analysis
-		if c.analysis.IsMethodAsync(pkgPath, typeName, methodName) {
-			c.tsw.WriteLiterally("await ")
-			return true
-		}
-		return false
+		return c.analysis.IsMethodAsync(pkgPath, typeName, methodName)
 
 	default:
 		return false
 	}
 }
 
+// writeAsyncCallIfNeeded writes the await prefix for async function or method calls
+// Returns true if await was written, false otherwise
+func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
+	if c.isCallExprAsync(exp) {
+		c.tsw.WriteLiterally("await ")
+		return true
+	}
+	return false
+}
+
 // addNonNullAssertion adds ! for function calls that might return null
 func (c *GoToTSCompiler) addNonNullAssertion(expFun ast.Expr) {
 	if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
@@ -151,7 +137,7 @@ func (c *GoToTSCompiler) addNonNullAssertion(expFun ast.Expr) {
 			// Check if this is a function parameter identifier that needs not-null assertion
 			if ident, isIdent := expFun.(*ast.Ident); isIdent {
 				// Check if this identifier is a function parameter
-				if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+				if obj := c.objectOfIdent(ident); obj != nil {
 					if _, isVar := obj.(*types.Var); isVar {
 						// This is a variable (including function parameters)
 						// Function parameters that are function types need ! assertion

package/compiler/expr-call-builtins.go

@@ -8,6 +8,25 @@ import (
 	"github.com/pkg/errors"
 )
 
+// builtinFunctions is the definitive list of Go builtin functions handled by the compiler
+var builtinFunctions = map[string]bool{
+	"len":     true,
+	"cap":     true,
+	"make":    true,
+	"new":     true,
+	"append":  true,
+	"copy":    true,
+	"delete":  true,
+	"complex": true,
+	"real":    true,
+	"imag":    true,
+	"close":   true,
+	"panic":   true,
+	"recover": true,
+	"print":   true,
+	"println": true,
+}
+
 // writeBuiltinFunction handles built-in Go functions
 func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string) (handled bool, err error) {
 	switch funName {

package/compiler/expr-call-helpers.go

@@ -7,34 +7,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-// isByteSliceType checks if a type is []byte (slice of uint8)
-func (c *GoToTSCompiler) isByteSliceType(t types.Type) bool {
-	if sliceType, isSlice := t.Underlying().(*types.Slice); isSlice {
-		if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-			return true
-		}
-	}
-	return false
-}
-
-// isRuneSliceType checks if a type is []rune (slice of int32)
-func (c *GoToTSCompiler) isRuneSliceType(t types.Type) bool {
-	if sliceType, isSlice := t.Underlying().(*types.Slice); isSlice {
-		if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Int32 {
-			return true
-		}
-	}
-	return false
-}
-
-// isStringType checks if a type is string
-func (c *GoToTSCompiler) isStringType(t types.Type) bool {
-	if basic, isBasic := t.Underlying().(*types.Basic); isBasic {
-		return basic.Kind() == types.String || basic.Kind() == types.UntypedString
-	}
-	return false
-}
-
 // writeByteSliceCreation handles the creation of []byte slices with proper Uint8Array handling
 func (c *GoToTSCompiler) writeByteSliceCreation(lengthArg, capacityArg interface{}) error {
 	return c.writeSliceCreationForType(lengthArg, capacityArg, true)