goscript 0.0.37 → 0.0.39

package/compiler/analysis.go

@@ -43,12 +43,25 @@ type VariableUsageInfo struct {
 	Destinations []AssignmentInfo
 }
 
+// FunctionTypeInfo represents Go function type information for reflection
+type FunctionTypeInfo struct {
+	Params   []types.Type // Parameter types
+	Results  []types.Type // Return types
+	Variadic bool         // Whether the function is variadic
+}
+
 // FunctionInfo consolidates function-related tracking data.
 type FunctionInfo struct {
 	IsAsync      bool
 	NamedReturns []string
 }
 
+// ReflectedFunctionInfo tracks functions that need reflection support
+type ReflectedFunctionInfo struct {
+	FuncType     *types.Signature // The function's type signature
+	NeedsReflect bool             // Whether this function is used with reflection
+}
+
 // NodeInfo consolidates node-related tracking data.
 type NodeInfo struct {
 	NeedsDefer        bool
@@ -84,6 +97,12 @@ type Analysis struct {
 	// FuncLitData tracks function literal specific data since they don't have types.Object
 	FuncLitData map[*ast.FuncLit]*FunctionInfo
 
+	// ReflectedFunctions tracks functions that need reflection type metadata
+	ReflectedFunctions map[ast.Node]*ReflectedFunctionInfo
+
+	// FunctionAssignments tracks which function literals are assigned to which variables
+	FunctionAssignments map[types.Object]ast.Node
+
 	// PackageMetadata holds package-level metadata
 	PackageMetadata map[string]interface{}
 }
@@ -102,12 +121,14 @@ type PackageAnalysis struct {
 // NewAnalysis creates a new Analysis instance.
 func NewAnalysis() *Analysis {
 	return &Analysis{
-		VariableUsage:   make(map[types.Object]*VariableUsageInfo),
-		Imports:         make(map[string]*fileImport),
-		FunctionData:    make(map[types.Object]*FunctionInfo),
-		NodeData:        make(map[ast.Node]*NodeInfo),
-		FuncLitData:     make(map[*ast.FuncLit]*FunctionInfo),
-		PackageMetadata: make(map[string]interface{}),
+		VariableUsage:       make(map[types.Object]*VariableUsageInfo),
+		Imports:             make(map[string]*fileImport),
+		FunctionData:        make(map[types.Object]*FunctionInfo),
+		NodeData:            make(map[ast.Node]*NodeInfo),
+		FuncLitData:         make(map[*ast.FuncLit]*FunctionInfo),
+		ReflectedFunctions:  make(map[ast.Node]*ReflectedFunctionInfo),
+		FunctionAssignments: make(map[types.Object]ast.Node),
+		PackageMetadata:     make(map[string]interface{}),
 	}
 }
 
@@ -341,6 +362,10 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 								// Case: var lhs = rhs_ident
 								assignmentType = DirectAssignment
 								sourceObj = v.pkg.TypesInfo.ObjectOf(rhsIdent)
+							} else if funcLit, ok := rhsExpr.(*ast.FuncLit); ok {
+								// Case: var lhs = func(...) { ... }
+								// Track function literal assignment
+								v.analysis.FunctionAssignments[lhsObj] = funcLit
 							}
 
 							// --- Record Usage ---
@@ -578,6 +603,9 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 
+		// Check for reflect function calls that operate on functions
+		v.checkReflectUsage(n)
+
 		// Store async state for this call expression
 		if v.analysis.NodeData[n] == nil {
 			v.analysis.NodeData[n] = &NodeInfo{}
@@ -637,16 +665,21 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 					continue // Skip blank identifier assignments
 				}
 				lhsTrackedObj = v.pkg.TypesInfo.ObjectOf(lhsIdent)
+
+				// Check if RHS is a function literal and track the assignment
+				if funcLit, ok := currentRHSExpr.(*ast.FuncLit); ok {
+					v.analysis.FunctionAssignments[lhsTrackedObj] = funcLit
+				}
 			} else if selExpr, ok := currentLHSExpr.(*ast.SelectorExpr); ok {
 				// LHS is struct.field or package.Var
 				if selection := v.pkg.TypesInfo.Selections[selExpr]; selection != nil {
 					lhsTrackedObj = selection.Obj() // This is the field or selected var object
 				}
-			} else if _, ok := currentLHSExpr.(*ast.StarExpr); ok {
+			} /* else if _, ok := currentLHSExpr.(*ast.StarExpr); ok {
 				// LHS is *pointer.
 				// We don't try to get a types.Object for the dereferenced entity itself to store in VariableUsage.
 				// lhsTrackedObj remains nil. The effect on rhsSourceObj (if its address is taken) is handled below.
-			}
+			} */
 			// For other complex LHS (e.g., map_expr[key_expr]), lhsTrackedObj remains nil.
 
 			// --- Record Usage Information ---
@@ -1095,3 +1128,91 @@ func (a *Analysis) IsMethodAsync(pkgName, typeName, methodName string) bool {
 
 	return false
 }
+
+// NeedsReflectionMetadata returns whether the given function node needs reflection type metadata
+func (a *Analysis) NeedsReflectionMetadata(node ast.Node) bool {
+	if node == nil {
+		return false
+	}
+	reflectInfo := a.ReflectedFunctions[node]
+	return reflectInfo != nil && reflectInfo.NeedsReflect
+}
+
+// GetFunctionTypeInfo returns the function type information for reflection
+func (a *Analysis) GetFunctionTypeInfo(node ast.Node) *ReflectedFunctionInfo {
+	if node == nil {
+		return nil
+	}
+	return a.ReflectedFunctions[node]
+}
+
+// MarkFunctionForReflection marks a function node as needing reflection support
+func (a *Analysis) MarkFunctionForReflection(node ast.Node, funcType *types.Signature) {
+	if node == nil || funcType == nil {
+		return
+	}
+	a.ReflectedFunctions[node] = &ReflectedFunctionInfo{
+		FuncType:     funcType,
+		NeedsReflect: true,
+	}
+}
+
+// checkReflectUsage checks for reflect function calls that operate on functions
+func (v *analysisVisitor) checkReflectUsage(callExpr *ast.CallExpr) {
+	// Check if this is a reflect package function call
+	if selExpr, ok := callExpr.Fun.(*ast.SelectorExpr); ok {
+		// Check if the selector is from reflect package
+		if ident, ok := selExpr.X.(*ast.Ident); ok {
+			// Check if this is a reflect package call (reflect.TypeOf, reflect.ValueOf, etc.)
+			if obj := v.pkg.TypesInfo.Uses[ident]; obj != nil {
+				if pkgName, ok := obj.(*types.PkgName); ok && pkgName.Imported().Path() == "reflect" {
+					methodName := selExpr.Sel.Name
+
+					// Check for reflect.TypeOf and reflect.ValueOf calls
+					if methodName == "TypeOf" || methodName == "ValueOf" {
+						// Check if any argument is a function
+						for _, arg := range callExpr.Args {
+							v.checkReflectArgument(arg)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// checkReflectArgument checks if an argument to a reflect function is a function that needs metadata
+func (v *analysisVisitor) checkReflectArgument(arg ast.Expr) {
+	// Check if the argument is an identifier (variable)
+	if ident, ok := arg.(*ast.Ident); ok {
+		// Get the object this identifier refers to
+		if obj := v.pkg.TypesInfo.Uses[ident]; obj != nil {
+			// Check if this object has a function type
+			if funcType, ok := obj.Type().(*types.Signature); ok {
+				// This is a function variable being passed to reflect
+				// We need to find the original function definition/assignment
+				v.markFunctionVariable(ident, funcType)
+			}
+		}
+	} else if funcLit, ok := arg.(*ast.FuncLit); ok {
+		// This is a function literal being passed directly to reflect
+		if funcType := v.pkg.TypesInfo.Types[funcLit].Type.(*types.Signature); funcType != nil {
+			v.analysis.MarkFunctionForReflection(funcLit, funcType)
+		}
+	}
+}
+
+// markFunctionVariable finds the function definition/assignment for a variable and marks it for reflection
+func (v *analysisVisitor) markFunctionVariable(ident *ast.Ident, funcType *types.Signature) {
+	// Get the object for this identifier
+	obj := v.pkg.TypesInfo.Uses[ident]
+	if obj == nil {
+		return
+	}
+
+	// Check if we have a tracked function assignment for this variable
+	if funcNode := v.analysis.FunctionAssignments[obj]; funcNode != nil {
+		// Mark the function node for reflection
+		v.analysis.MarkFunctionForReflection(funcNode, funcType)
+	}
+}

package/compiler/compiler.go

@@ -453,7 +453,10 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 		if strings.HasSuffix(fileName, ".pb") {
 			// For protobuf files, add a simple re-export
 			pbTsFileName := fileName + ".ts"
-			if err := c.writeProtobufExports(indexFile, fileName, pbTsFileName); err != nil {
+			if err := func() error {
+				var _ string = pbTsFileName
+				return c.writeProtobufExports(indexFile, fileName)
+			}(); err != nil {
 				return err
 			}
 			continue

package/compiler/composite-lit.go

@@ -503,14 +503,12 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 		case *types.Pointer:
 			// Handle pointer to composite literal
 			ptrType := underlying.(*types.Pointer)
-			elemType := ptrType.Elem().Underlying()
-			switch elemType.(type) {
+			switch elemType := ptrType.Elem().Underlying().(type) {
 			case *types.Struct:
 				// This is an anonymous struct literal with inferred pointer type
 				// Just create the struct object directly - no var-refing needed
 				// Anonymous literals are not variables, so they don't get var-refed
-				structType := elemType.(*types.Struct)
-				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+				return c.writeUntypedStructLiteral(exp, elemType) // true = anonymous
 			default:
 				return fmt.Errorf("unhandled pointer composite literal element type: %T", elemType)
 			}

package/compiler/expr-call.go

@@ -132,6 +132,18 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				return errors.Errorf("unhandled delete call with incorrect number of arguments: %d != 2", len(exp.Args))
 			}
 			c.tsw.WriteLiterally("$.deleteMapEntry")
+		case "copy":
+			// Translate copy(dst, src) to $.copy(dst, src)
+			if len(exp.Args) != 2 {
+				return errors.Errorf("unhandled copy call with incorrect number of arguments: %d != 2", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("$.copy")
+		case "recover":
+			// Translate recover() to $.recover()
+			if len(exp.Args) != 0 {
+				return errors.Errorf("unhandled recover call with incorrect number of arguments: %d != 0", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("$.recover")
 		case "make":
 			// First check if we have a channel type
 			if typ := c.pkg.TypesInfo.TypeOf(exp.Args[0]); typ != nil {

package/compiler/lit.go

@@ -70,14 +70,25 @@ func (c *GoToTSCompiler) WriteBasicLit(exp *ast.BasicLit) {
 
 		// Check if this is a raw string literal (starts and ends with backticks)
 		if len(value) >= 2 && value[0] == '`' && value[len(value)-1] == '`' {
-			// This is a Go raw string - need to escape invalid \x sequences for JavaScript
+			// This is a Go raw string
 			content := value[1 : len(value)-1] // Remove surrounding backticks
 
-			// Escape invalid \x, \u, and \U sequences that would cause TS1125 errors
-			content = c.escapeInvalidEscapeSequences(content)
-
-			// Write as template literal with corrected content
-			c.tsw.WriteLiterallyf("`%s`", content)
+			// Check if the raw string contains backslashes that would be problematic in template literals
+			if strings.Contains(content, `\`) {
+				// Convert to a regular string literal with proper escaping
+				// Replace backslashes with double backslashes for TypeScript
+				content = strings.ReplaceAll(content, `\`, `\\`)
+				// Replace double quotes with escaped double quotes
+				content = strings.ReplaceAll(content, `"`, `\"`)
+				// Write as a regular string literal
+				c.tsw.WriteLiterallyf(`"%s"`, content)
+			} else {
+				// No backslashes, safe to use template literal
+				// Escape invalid \x, \u, and \U sequences that would cause TS1125 errors
+				content = c.escapeInvalidEscapeSequences(content)
+				// Write as template literal with corrected content
+				c.tsw.WriteLiterallyf("`%s`", content)
+			}
 		} else {
 			// Regular string literal (double quotes) - write as-is
 			c.tsw.WriteLiterally(value)
@@ -101,6 +112,17 @@ func (c *GoToTSCompiler) WriteBasicLit(exp *ast.BasicLit) {
 //   - Wrapped in `Promise<>` if `async`.
 //   - The function body (`exp.Body`) is translated using `WriteStmt`.
 func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
+	// Check if this function needs reflection metadata
+	needsReflection := c.analysis.NeedsReflectionMetadata(exp)
+
+	if needsReflection {
+		// Start IIFE to attach metadata
+		c.tsw.WriteLiterally("(() => {")
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		c.tsw.WriteLiterally("const fn = ")
+	}
+
 	// Determine if the function literal should be async
 	isAsync := c.analysis.IsFuncLitAsync(exp)
 
@@ -183,6 +205,78 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 		c.tsw.WriteLiterally("}")
 	}
 
+	// Add reflection metadata if needed
+	if needsReflection {
+		c.tsw.WriteLine("")
+
+		// Attach type metadata to the function
+		if err := c.writeReflectionMetadata(exp); err != nil {
+			return fmt.Errorf("failed to write reflection metadata: %w", err)
+		}
+
+		c.tsw.WriteLine("return fn")
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("})()")
+	}
+
+	return nil
+}
+
+// writeReflectionMetadata attaches function type information to a function for reflection support
+func (c *GoToTSCompiler) writeReflectionMetadata(exp *ast.FuncLit) error {
+	// Get the reflection info for this function
+	reflectInfo := c.analysis.GetFunctionTypeInfo(exp)
+	if reflectInfo == nil || reflectInfo.FuncType == nil {
+		return nil // No reflection info available
+	}
+
+	funcType := reflectInfo.FuncType
+
+	// Build FunctionTypeInfo metadata
+	c.tsw.WriteLiterally("fn.__typeInfo = {")
+	c.tsw.Indent(1)
+	c.tsw.WriteLine("")
+	c.tsw.WriteLiterally("kind: $.TypeKind.Function,")
+	c.tsw.WriteLine("")
+
+	// Add parameters
+	if funcType.Params() != nil && funcType.Params().Len() > 0 {
+		c.tsw.WriteLiterally("params: [")
+		for i := 0; i < funcType.Params().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			param := funcType.Params().At(i)
+			c.tsw.WriteLiterallyf("'%s'", param.Type().String())
+		}
+		c.tsw.WriteLiterally("],")
+		c.tsw.WriteLine("")
+	}
+
+	// Add results
+	if funcType.Results() != nil && funcType.Results().Len() > 0 {
+		c.tsw.WriteLiterally("results: [")
+		for i := 0; i < funcType.Results().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			result := funcType.Results().At(i)
+			c.tsw.WriteLiterallyf("'%s'", result.Type().String())
+		}
+		c.tsw.WriteLiterally("],")
+		c.tsw.WriteLine("")
+	}
+
+	// Add variadic flag
+	if funcType.Variadic() {
+		c.tsw.WriteLiterally("isVariadic: true,")
+		c.tsw.WriteLine("")
+	}
+
+	c.tsw.Indent(-1)
+	c.tsw.WriteLiterally("}")
+	c.tsw.WriteLine("")
+
 	return nil
 }
 

package/compiler/protobuf.go

@@ -118,7 +118,7 @@ func (c *PackageCompiler) copyProtobufTSFile(sourcePath, fileName string) error
 }
 
 // writeProtobufExports writes exports for a protobuf file to the index.ts file
-func (c *PackageCompiler) writeProtobufExports(indexFile *os.File, fileName, pbTsFileName string) error {
+func (c *PackageCompiler) writeProtobufExports(indexFile *os.File, fileName string) error {
 	// For protobuf files, we know they typically export message types
 	// For now, we'll use a simple heuristic: export all types that end with "Msg"
 	// In a full implementation, we would parse the .pb.ts file to extract actual exports
@@ -230,7 +230,7 @@ func (c *GoToTSCompiler) writeProtobufMarshalAssignment(lhs []ast.Expr, callExpr
 
 // writeProtobufUnmarshalAssignment handles: err = out.UnmarshalVT(data)
 // Generates: out = ExampleMsg.fromBinary(data); err = null;
-func (c *GoToTSCompiler) writeProtobufUnmarshalAssignment(lhs []ast.Expr, callExpr *ast.CallExpr, tok token.Token) error {
+func (c *GoToTSCompiler) writeProtobufUnmarshalAssignment(lhs []ast.Expr, callExpr *ast.CallExpr) error {
 	if len(lhs) != 1 {
 		return fmt.Errorf("protobuf unmarshal assignment requires exactly 1 LHS variable, got %d", len(lhs))
 	}

package/compiler/spec-value.go

@@ -233,14 +233,14 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 						if c.hasReceiverMethods(typeName) {
 							// Check if the initializer is a basic literal or simple value that needs wrapping
 							needsConstructor := false
-							switch initializerExpr.(type) {
+							switch expr := initializerExpr.(type) {
 							case *ast.BasicLit:
 								needsConstructor = true
 							case *ast.Ident:
 								// Check if it's a simple identifier (not a function call or complex expression)
-								if ident := initializerExpr.(*ast.Ident); ident.Name != "nil" {
+								if expr.Name != "nil" {
 									// Check if this identifier refers to a value of the underlying type
-									if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+									if obj := c.pkg.TypesInfo.Uses[expr]; obj != nil {
 										if objType := obj.Type(); objType != nil {
 											// If the identifier's type matches the underlying type, wrap it
 											if types.Identical(objType, namedType.Underlying()) {

package/compiler/spec.go

@@ -45,7 +45,10 @@ func (c *GoToTSCompiler) getEmbeddedFieldKeyName(fieldType types.Type) string {
 		return named.Obj().Name()
 	} else {
 		// Fallback for unnamed embedded types, though less common for structs
-		fieldKeyName := strings.Title(trueType.String()) // Simple heuristic
+		fieldKeyName := trueType.String()
+		if len(fieldKeyName) > 0 {
+			fieldKeyName = strings.ToUpper(fieldKeyName[:1]) + fieldKeyName[1:]
+		}
 		if dotIndex := strings.LastIndex(fieldKeyName, "."); dotIndex != -1 {
 			fieldKeyName = fieldKeyName[dotIndex+1:]
 		}
@@ -261,7 +264,7 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 
 			if recvTypeName == className {
 				c.tsw.WriteLine("")
-				if err := c.writeNamedTypeMethod(funcDecl, className); err != nil {
+				if err := c.writeNamedTypeMethod(funcDecl); err != nil {
 					return err
 				}
 			}
@@ -275,7 +278,7 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 }
 
 // writeNamedTypeMethod writes a method for a named type, handling receiver binding properly
-func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl, className string) error {
+func (c *GoToTSCompiler) writeNamedTypeMethod(decl *ast.FuncDecl) error {
 	if decl.Doc != nil {
 		c.WriteDoc(decl.Doc)
 	}

package/compiler/stmt-assign.go

@@ -469,7 +469,7 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		if callExpr, ok := exp.Rhs[0].(*ast.CallExpr); ok {
 			// Handle protobuf UnmarshalVT: err = out.UnmarshalVT(data)
 			if c.isProtobufMethodCall(callExpr, "UnmarshalVT") {
-				return c.writeProtobufUnmarshalAssignment(exp.Lhs, callExpr, exp.Tok)
+				return c.writeProtobufUnmarshalAssignment(exp.Lhs, callExpr)
 			}
 			// Handle protobuf UnmarshalJSON: err = out.UnmarshalJSON(data)
 			if c.isProtobufMethodCall(callExpr, "UnmarshalJSON") {

package/dist/gs/builtin/builtin.d.ts

@@ -34,3 +34,48 @@ export declare function normalizeBytes(bytes: Uint8Array | number[] | null | und
  * @param s The slice to sort in place
  */
 export declare function sortSlice<T extends string | number>(s: Slice<T>): void;
+/**
+ * bytesEqual efficiently compares two byte slices for equality.
+ * Optimized for different byte representations.
+ */
+export declare function bytesEqual(a: Bytes | null, b: Bytes | null): boolean;
+/**
+ * bytesCompare compares two byte slices lexicographically.
+ * Returns -1 if a < b, 0 if a == b, +1 if a > b.
+ */
+export declare function bytesCompare(a: Bytes | null, b: Bytes | null): number;
+/**
+ * bytesToArray converts any Bytes representation to a number array.
+ */
+export declare function bytesToArray(bytes: Bytes | null): number[];
+/**
+ * bytesToUint8Array converts any Bytes representation to a Uint8Array.
+ */
+export declare function bytesToUint8Array(bytes: Bytes | null): Uint8Array;
+/**
+ * bytesIndexOf finds the first occurrence of subslice in bytes.
+ * Returns -1 if not found.
+ */
+export declare function bytesIndexOf(bytes: Bytes | null, subslice: Bytes | null): number;
+/**
+ * bytesLastIndexOf finds the last occurrence of subslice in bytes.
+ * Returns -1 if not found.
+ */
+export declare function bytesLastIndexOf(bytes: Bytes | null, subslice: Bytes | null): number;
+/**
+ * bytesIndexByte finds the first occurrence of byte c in bytes.
+ * Returns -1 if not found.
+ */
+export declare function bytesIndexByte(bytes: Bytes | null, c: number): number;
+/**
+ * bytesLastIndexByte finds the last occurrence of byte c in bytes.
+ * Returns -1 if not found.
+ */
+export declare function bytesLastIndexByte(bytes: Bytes | null, c: number): number;
+/**
+ * bytesCount counts non-overlapping instances of sep in bytes.
+ */
+export declare function bytesCount(bytes: Bytes | null, sep: Bytes | null): number;
+export declare function min(a: number, b: number): number;
+export declare function max(a: number, b: number): number;
+export declare function recover(): any;