goscript 0.0.59 → 0.0.61

package/compiler/compiler.go

@@ -844,7 +844,7 @@ func (c *GoToTSCompiler) WriteCaseClause(exp *ast.CaseClause) error {
 	if exp.List == nil {
 		// Default case
 		c.tsw.WriteLiterally("default:")
-		c.tsw.WriteLine("")
+		c.tsw.WriteLine(" {")
 	} else {
 		// Case with expressions
 		// For Go's `case expr1, expr2:`, we translate to:
@@ -852,18 +852,23 @@ func (c *GoToTSCompiler) WriteCaseClause(exp *ast.CaseClause) error {
 		// case expr2:
 		// ... body ...
 		// break
-		for _, caseExpr := range exp.List {
+		for i, caseExpr := range exp.List {
 			c.tsw.WriteLiterally("case ")
 			if err := c.WriteValueExpr(caseExpr); err != nil {
 				return fmt.Errorf("failed to write case clause expression: %w", err)
 			}
 			c.tsw.WriteLiterally(":")
-			c.tsw.WriteLine("")
+			// Only add opening brace after the last case label
+			if i == len(exp.List)-1 {
+				c.tsw.WriteLine(" {")
+			} else {
+				c.tsw.WriteLine("")
+			}
 		}
 	}
 
 	// The body is written once, after all case labels for this clause.
-	// Indentation for the body starts here.
+	// Wrap in block to provide Go-like case scope semantics.
 	c.tsw.Indent(1)
 	for _, stmt := range exp.Body {
 		if err := c.WriteStmt(stmt); err != nil {
@@ -873,6 +878,7 @@ func (c *GoToTSCompiler) WriteCaseClause(exp *ast.CaseClause) error {
 	// Add break statement (Go's switch has implicit breaks, TS needs explicit break)
 	c.tsw.WriteLine("break")
 	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
 	return nil
 }
 

package/compiler/decl.go

@@ -252,122 +252,82 @@ func (c *GoToTSCompiler) extractStructFieldDependencies(fieldType ast.Expr, type
 	return deps
 }
 
-// sortVarSpecsByTypeDependencies sorts variable declarations based on their type dependencies
+// sortVarSpecsByTypeDependencies sorts variable declarations based on their value dependencies
+// to ensure that variables are initialized in the correct order (respecting JavaScript's TDZ).
+// For example: var StdEncoding = NewEncoding(...) must come before var RawStdEncoding = StdEncoding.WithPadding(...)
 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
-
+	// Build a map of variable names to their specs
+	varSpecMap := make(map[string]*ast.ValueSpec)
+	varNames := []string{}
 	for _, varSpec := range varSpecs {
-		// Get variable name for sorting
-		varName := ""
 		if len(varSpec.Names) > 0 {
-			varName = varSpec.Names[0].Name
+			name := varSpec.Names[0].Name
+			varSpecMap[name] = varSpec
+			varNames = append(varNames, name)
 		}
+	}
 
-		hasDependency := false
-
-		// Check type annotation
-		if varSpec.Type != nil {
-			deps := c.extractTypeDependencies(varSpec.Type, typeSpecMap)
-			if len(deps) > 0 {
-				hasDependency = true
-			}
-		}
+	// Build dependency graph: varName -> list of variables it depends on
+	dependencies := make(map[string][]string)
+	for _, name := range varNames {
+		dependencies[name] = []string{}
+	}
 
-		// Check initializer expressions for type usage
-		if !hasDependency {
-			for _, value := range varSpec.Values {
-				if c.hasTypeReferences(value, typeSpecMap) {
-					hasDependency = true
-					break
-				}
-			}
+	// Extract value dependencies from initializer expressions
+	for _, varSpec := range varSpecs {
+		if len(varSpec.Names) == 0 {
+			continue
 		}
+		varName := varSpec.Names[0].Name
 
-		namedVar := namedVarSpec{spec: varSpec, name: varName}
-		if hasDependency {
-			dependentVars = append(dependentVars, namedVar)
-		} else {
-			independentVars = append(independentVars, namedVar)
+		// Check initializer expressions for variable references
+		for _, value := range varSpec.Values {
+			deps := c.extractVarDependencies(value, varSpecMap)
+			dependencies[varName] = append(dependencies[varName], deps...)
 		}
 	}
 
-	// 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
-	})
+	// Perform topological sort
+	sorted, err := c.topologicalSort(dependencies)
+	if err != nil {
+		return nil, err
+	}
 
-	// Return independent variables first, then dependent ones
+	// Build result in sorted order
 	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)
+	for _, varName := range sorted {
+		if spec, exists := varSpecMap[varName]; exists {
+			result = append(result, 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
+// extractVarDependencies extracts variable dependencies from an initializer expression.
+// It returns a list of variable names that the expression depends on.
+func (c *GoToTSCompiler) extractVarDependencies(expr ast.Expr, varSpecMap map[string]*ast.ValueSpec) []string {
+	var deps []string
+	seen := make(map[string]bool)
 
 	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
+		if ident, ok := n.(*ast.Ident); ok {
+			// Check if this identifier refers to a package-level variable
+			if _, isVar := varSpecMap[ident.Name]; isVar {
+				if !seen[ident.Name] {
+					deps = append(deps, ident.Name)
+					seen[ident.Name] = true
 				}
 			}
-		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 true
 	})
 
-	return hasRef
+	return deps
 }
 
 // topologicalSort performs a topological sort of the dependency graph

package/compiler/expr-call-helpers.go

@@ -108,3 +108,185 @@ func (c *GoToTSCompiler) writeExprOrDefault(expr interface{}, defaultValue strin
 		return errors.Errorf("unsupported expression type in writeExprOrDefault: %T", e)
 	}
 }
+
+// writeReflectTypeFor handles reflect.TypeFor[T]() calls by generating appropriate TypeScript
+func (c *GoToTSCompiler) writeReflectTypeFor(exp *ast.CallExpr, selectorExpr *ast.SelectorExpr) (handled bool, err error) {
+	// Check if this is reflect.TypeFor
+	if selectorExpr.Sel.Name != "TypeFor" {
+		return false, nil
+	}
+
+	// Check if X is an identifier referring to the reflect package
+	xIdent, ok := selectorExpr.X.(*ast.Ident)
+	if !ok {
+		return false, nil
+	}
+
+	obj := c.objectOfIdent(xIdent)
+	if obj == nil {
+		return false, nil
+	}
+
+	pkgName, ok := obj.(*types.PkgName)
+	if !ok || pkgName.Imported().Path() != "reflect" {
+		return false, nil
+	}
+
+	// DEBUG: We found reflect.TypeFor
+	// fmt.Printf("DEBUG: Found reflect.TypeFor call\n")
+
+	// This is reflect.TypeFor - now get the type argument
+	if c.pkg.TypesInfo.Instances == nil {
+		return false, errors.New("reflect.TypeFor called but no type instances available")
+	}
+
+	instance, hasInstance := c.pkg.TypesInfo.Instances[selectorExpr.Sel]
+	if !hasInstance || instance.TypeArgs == nil || instance.TypeArgs.Len() == 0 {
+		return false, errors.New("reflect.TypeFor called without type arguments")
+	}
+
+	// Get the first type argument
+	typeArg := instance.TypeArgs.At(0)
+	// fmt.Printf("DEBUG: Type argument: %v\n", typeArg)
+
+	// Generate TypeScript code to create a Type for this type
+	if err := c.writeTypeForTypeArg(typeArg); err != nil {
+		return true, err
+	}
+
+	return true, nil
+}
+
+// writeTypeForTypeArg generates TypeScript code to create a reflect.Type for the given Go type
+func (c *GoToTSCompiler) writeTypeForTypeArg(t types.Type) error {
+	// Handle basic types
+	switch underlying := t.Underlying().(type) {
+	case *types.Basic:
+		return c.writeBasicTypeFor(underlying)
+	case *types.Named:
+		// For named types, use TypeOf with a zero value
+		return c.writeNamedTypeFor(t)
+	case *types.Pointer:
+		// For pointer types, use PointerTo
+		c.tsw.WriteLiterally("reflect.PointerTo(")
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	case *types.Slice:
+		// For slice types, use TypeOf with an empty slice
+		c.tsw.WriteLiterally("reflect.TypeOf([])")
+		return nil
+	case *types.Array:
+		// For array types, use TypeOf with an empty array
+		c.tsw.WriteLiterally("reflect.TypeOf([])")
+		return nil
+	case *types.Struct:
+		// For struct types, use TypeOf with zero value
+		return c.writeNamedTypeFor(t)
+	case *types.Interface:
+		// For interface types, use TypeOf with null
+		return c.writeNamedTypeFor(t)
+	default:
+		return errors.Errorf("unsupported type for reflect.TypeFor: %T", underlying)
+	}
+}
+
+// writeBasicTypeFor generates code for basic types
+func (c *GoToTSCompiler) writeBasicTypeFor(basic *types.Basic) error {
+	// Map basic types to their reflect constructors or TypeOf calls
+	// Note: We don't pass type parameters to TypeOf - it infers from the value
+	switch basic.Kind() {
+	case types.Bool:
+		c.tsw.WriteLiterally("reflect.TypeOf(false)")
+	case types.Int:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Int8:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Int16:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Int32:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Int64:
+		c.tsw.WriteLiterally("reflect.TypeOf(0n)")
+	case types.Uint:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Uint8:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Uint16:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Uint32:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Uint64:
+		c.tsw.WriteLiterally("reflect.TypeOf(0n)")
+	case types.Uintptr:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Float32:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Float64:
+		c.tsw.WriteLiterally("reflect.TypeOf(0)")
+	case types.Complex64:
+		c.tsw.WriteLiterally("reflect.TypeOf([0, 0])")
+	case types.Complex128:
+		c.tsw.WriteLiterally("reflect.TypeOf([0, 0])")
+	case types.String:
+		c.tsw.WriteLiterally("reflect.TypeOf(\"\")")
+	case types.UnsafePointer:
+		c.tsw.WriteLiterally("reflect.TypeOf(null)")
+	default:
+		return errors.Errorf("unsupported basic type for reflect.TypeFor: %v", basic)
+	}
+	return nil
+}
+
+// writeNamedTypeFor generates code for named types (structs, interfaces, etc.)
+func (c *GoToTSCompiler) writeNamedTypeFor(t types.Type) error {
+	// For interface types, we need special handling since null doesn't carry type info
+	if _, ok := t.Underlying().(*types.Interface); ok {
+		if named, ok := t.(*types.Named); ok {
+			obj := named.Obj()
+			pkgPath := ""
+			if pkg := obj.Pkg(); pkg != nil {
+				if pkg.Name() == "main" {
+					pkgPath = "main."
+				} else if pkg.Path() != "" {
+					pkgPath = pkg.Path() + "."
+				}
+			}
+			typeName := pkgPath + obj.Name()
+			c.tsw.WriteLiterally("reflect.getInterfaceTypeByName(\"" + typeName + "\")")
+			return nil
+		}
+		// For anonymous interfaces, use TypeOf(null)
+		c.tsw.WriteLiterally("reflect.TypeOf(null)")
+		return nil
+	}
+
+	// For named types, we need to create a zero value and call TypeOf
+	// Note: We don't pass a type parameter to TypeOf - it infers the type from the value
+	c.tsw.WriteLiterally("reflect.TypeOf(")
+
+	// Generate a zero value for this type
+	switch underlying := t.Underlying().(type) {
+	case *types.Struct:
+		// For struct types: new MyStruct()
+		// Check if this is a named type
+		if _, ok := t.(*types.Named); ok {
+			c.tsw.WriteLiterally("new ")
+			c.WriteGoType(t, GoTypeContextGeneral)
+			c.tsw.WriteLiterally("()")
+		} else {
+			// Anonymous struct
+			c.tsw.WriteLiterally("{}")
+		}
+	case *types.Basic:
+		// For basic types wrapped in named types
+		return c.writeBasicTypeFor(underlying)
+	default:
+		return errors.Errorf("unsupported named type underlying for reflect.TypeFor: %T", underlying)
+	}
+
+	c.tsw.WriteLiterally(")")
+	return nil
+}

package/compiler/expr-call.go

@@ -5,7 +5,6 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
-	"strings"
 )
 
 // WriteCallExpr translates a Go function call expression (`ast.CallExpr`)
@@ -97,6 +96,15 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		}
 	}
 
+	// Handle reflect.TypeFor[T]() - Fun is IndexExpr where X is SelectorExpr
+	if indexExpr, ok := expFun.(*ast.IndexExpr); ok {
+		if selectorExpr, ok := indexExpr.X.(*ast.SelectorExpr); ok {
+			if handled, err := c.writeReflectTypeFor(exp, selectorExpr); handled {
+				return err
+			}
+		}
+	}
+
 	// Handle non-identifier function expressions (method calls, function literals, etc.)
 	// Check if this is an async method call (e.g., mu.Lock())
 	c.writeAsyncCallIfNeeded(exp)
@@ -246,35 +254,6 @@ func (c *GoToTSCompiler) getQualifiedTypeName(t types.Type) string {
 	return obj.Name()
 }
 
-// getImportAlias returns the import alias for a given package path
-// Deprecated: use resolveImportAlias instead for better type safety
-func (c *GoToTSCompiler) getImportAlias(pkgPath string) string {
-	if c.analysis == nil {
-		return ""
-	}
-
-	// First try to find by exact package path
-	for importAlias := range c.analysis.Imports {
-		if importInfo := c.analysis.Imports[importAlias]; importInfo != nil {
-			if importInfo.importPath == pkgPath {
-				return importAlias
-			}
-		}
-	}
-
-	// Fallback: try to match by package name extracted from path
-	parts := strings.Split(pkgPath, "/")
-	defaultPkgName := parts[len(parts)-1]
-
-	for importAlias := range c.analysis.Imports {
-		if importAlias == defaultPkgName {
-			return importAlias
-		}
-	}
-
-	return ""
-}
-
 // writeAutoWrappedArgument writes an argument, auto-wrapping it if needed based on the expected parameter type
 func (c *GoToTSCompiler) writeAutoWrappedArgument(arg ast.Expr, expectedType types.Type) error {
 	// For wrapper types (now type aliases), no auto-wrapping is needed

package/compiler/expr-selector.go

@@ -27,10 +27,18 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 	// Check if this is a package selector (e.g., time.Now)
 	if pkgIdent, isPkgIdent := exp.X.(*ast.Ident); isPkgIdent {
 		if obj := c.pkg.TypesInfo.ObjectOf(pkgIdent); obj != nil {
-			if _, isPkg := obj.(*types.PkgName); isPkg {
+			if pkgName, isPkg := obj.(*types.PkgName); isPkg {
 				// Package selectors should never use .value on the package name
 				c.tsw.WriteLiterally(pkgIdent.Name)
 				c.tsw.WriteLiterally(".")
+
+				// Special case: reflect.Pointer should be translated to reflect.Ptr
+				// (Go has both names for the same Kind constant)
+				if pkgName.Imported().Path() == "reflect" && exp.Sel.Name == "Pointer" {
+					c.tsw.WriteLiterally("Ptr")
+					return nil
+				}
+
 				// Write the selected identifier, allowing .value if it's a varrefed package variable
 				c.WriteIdent(exp.Sel, true)
 				return nil
@@ -189,6 +197,35 @@ func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *type
 		baseIsPointer = true
 	}
 
+	// Check if the receiver is a primitive/wrapper type
+	underlyingRecvType := recvType
+	if ptr, ok := recvType.(*types.Pointer); ok {
+		underlyingRecvType = ptr.Elem()
+	}
+	isPrimitiveReceiver := c.isWrapperType(underlyingRecvType)
+
+	// For primitive types, generate a closure that captures the receiver and calls the free function
+	if isPrimitiveReceiver {
+		// Get the type name for the free function
+		typeName := c.getQualifiedTypeName(underlyingRecvType)
+		if typeName == "" {
+			return fmt.Errorf("failed to get qualified type name for primitive receiver")
+		}
+
+		// Generate: () => TypeName_MethodName(receiverValue)
+		c.tsw.WriteLiterally("(() => ")
+		c.tsw.WriteLiterally(typeName)
+		c.tsw.WriteLiterally("_")
+		c.tsw.WriteLiterally(exp.Sel.Name)
+		c.tsw.WriteLiterally("(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write method value receiver: %w", err)
+		}
+		c.tsw.WriteLiterally("))")
+
+		return nil
+	}
+
 	// Write the receiver expression
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write method value receiver: %w", err)

package/compiler/expr-type.go

@@ -134,11 +134,47 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 				c.tsw.WriteLiterally("}")
 			}
 		} else {
-			// For named types, just use the name string
+			// For named types, use the fully qualified name with package path
+			if goType != nil {
+				if namedType, isNamed := goType.(*types.Named); isNamed {
+					typeName := namedType.Obj().Name()
+					if pkg := namedType.Obj().Pkg(); pkg != nil {
+						pkgPath := pkg.Path()
+						pkgName := pkg.Name()
+						if pkgPath != "" && pkgName != "main" {
+							typeName = pkgPath + "." + typeName
+						} else if pkgName == "main" {
+							typeName = "main." + typeName
+						}
+					}
+					c.tsw.WriteLiterallyf("'%s'", typeName)
+					return
+				}
+			}
+			// Fallback to short name if type info unavailable
 			c.tsw.WriteLiterallyf("'%s'", t.Name)
 		}
 	case *ast.SelectorExpr:
 		if ident, ok := t.X.(*ast.Ident); ok {
+			// Use type info to get the actual package path
+			goType := c.pkg.TypesInfo.TypeOf(t)
+			if goType != nil {
+				if namedType, isNamed := goType.(*types.Named); isNamed {
+					typeName := namedType.Obj().Name()
+					if pkg := namedType.Obj().Pkg(); pkg != nil {
+						pkgPath := pkg.Path()
+						pkgName := pkg.Name()
+						if pkgPath != "" && pkgName != "main" {
+							typeName = pkgPath + "." + typeName
+						} else if pkgName == "main" {
+							typeName = "main." + typeName
+						}
+					}
+					c.tsw.WriteLiterallyf("'%s'", typeName)
+					return
+				}
+			}
+			// Fallback to using the identifier name (package alias)
 			c.tsw.WriteLiterallyf("'%s.%s'", ident.Name, t.Sel.Name)
 		}
 	case *ast.ArrayType:

package/compiler/expr.go

@@ -251,34 +251,6 @@ func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
 	return "unknown"
 }
 
-// getFinalUnderlyingType traverses the chain of named types to find the ultimate underlying type.
-// This handles cases like: type A B; type B C; type C string.
-// Returns the final underlying type and whether the original type was a named type.
-func (c *GoToTSCompiler) getFinalUnderlyingType(t types.Type) (types.Type, bool) {
-	if t == nil {
-		return nil, false
-	}
-
-	// Check if this is a named type
-	namedType, isNamed := t.(*types.Named)
-	if !isNamed {
-		return t, false
-	}
-
-	// Follow the chain of named types to find the ultimate underlying type
-	ultimate := namedType
-	for {
-		underlying := ultimate.Underlying()
-		if underlyingNamed, isNamedUnderlying := underlying.(*types.Named); isNamedUnderlying {
-			// Continue following the chain
-			ultimate = underlyingNamed
-		} else {
-			// We've reached the final underlying type
-			return underlying, true
-		}
-	}
-}
-
 // WriteBinaryExpr translates a Go binary expression (`ast.BinaryExpr`) into its
 // TypeScript equivalent.
 // It handles several cases:

package/compiler/spec-struct.go

@@ -429,8 +429,19 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	// Add code to register the type with the runtime type system
 	c.tsw.WriteLine("")
 	c.tsw.WriteLinef("// Register this type with the runtime type system")
+
+	// Build full package path name for registration
+	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.WriteLinef("static __typeInfo = $.registerStructType(")
-	c.tsw.WriteLinef("  '%s',", className)
+	c.tsw.WriteLinef("  '%s',", structName)
 	c.tsw.WriteLinef("  new %s(),", className)
 	c.tsw.WriteLiterally("  [")
 	// Collect methods for the struct type

package/compiler/spec.go

@@ -121,7 +121,7 @@ func (c *GoToTSCompiler) writeEmbeddedFieldInitializer(fieldName string, fieldTy
 	}
 
 	// For structs, instantiate with provided fields
-	typeForNew := fieldName
+	typeForNew := c.getTypeString(fieldType)
 	c.tsw.WriteLiterallyf("new %s(init?.%s)", typeForNew, fieldName)
 }
 
@@ -224,6 +224,12 @@ func (c *GoToTSCompiler) writeNamedTypeZeroValue(named *types.Named) {
 		return
 	}
 
+	// Check if underlying type is a function
+	if _, isFunc := named.Underlying().(*types.Signature); isFunc {
+		c.tsw.WriteLiterally("null")
+		return
+	}
+
 	// For non-struct, non-interface named types, use constructor
 	c.tsw.WriteLiterally("new ")
 	c.WriteNamedType(named)
@@ -254,6 +260,12 @@ func (c *GoToTSCompiler) writeTypeAliasZeroValue(alias *types.Alias, astType ast
 		return
 	}
 
+	// Check if underlying type is a function
+	if _, isFunc := alias.Underlying().(*types.Signature); isFunc {
+		c.tsw.WriteLiterally("null")
+		return
+	}
+
 	// For non-struct, non-interface type aliases, use constructor
 	c.tsw.WriteLiterally("new ")
 	// Use AST type information if available to preserve qualified names
@@ -521,7 +533,15 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 	c.tsw.WriteLine("")
 
 	// Add code to register the interface with the runtime system
+	// Build full package path name for registration
 	interfaceName := a.Name.Name
+	pkgPath := c.pkg.Types.Path()
+	pkgName := c.pkg.Types.Name()
+	if pkgPath != "" && pkgName != "main" {
+		interfaceName = pkgPath + "." + interfaceName
+	} else if pkgName == "main" {
+		interfaceName = "main." + interfaceName
+	}
 	c.tsw.WriteLine("")
 	c.tsw.WriteLinef("$.registerInterfaceType(")
 	c.tsw.WriteLinef("  '%s',", interfaceName)