goscript 0.0.41 → 0.0.43

package/compiler/analysis.go

@@ -43,6 +43,14 @@ type VariableUsageInfo struct {
 	Destinations []AssignmentInfo
 }
 
+// ShadowingInfo tracks variable shadowing in if statement initializations
+type ShadowingInfo struct {
+	// ShadowedVariables maps shadowed variable names to their outer scope objects
+	ShadowedVariables map[string]types.Object
+	// TempVariables maps shadowed variable names to temporary variable names
+	TempVariables map[string]string
+}
+
 // FunctionTypeInfo represents Go function type information for reflection
 type FunctionTypeInfo struct {
 	Params   []types.Type // Parameter types
@@ -69,8 +77,9 @@ type NodeInfo struct {
 	IsBareReturn      bool
 	EnclosingFuncDecl *ast.FuncDecl
 	EnclosingFuncLit  *ast.FuncLit
-	IsInsideFunction  bool // true if this declaration is inside a function body
-	IsMethodValue     bool // true if this SelectorExpr is a method value that needs binding
+	IsInsideFunction  bool           // true if this declaration is inside a function body
+	IsMethodValue     bool           // true if this SelectorExpr is a method value that needs binding
+	ShadowingInfo     *ShadowingInfo // variable shadowing information for if statements
 }
 
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
@@ -116,6 +125,14 @@ type PackageAnalysis struct {
 	// FunctionCalls maps file names to the functions they call from other files
 	// Key: filename (without .go extension), Value: map[sourceFile][]functionNames
 	FunctionCalls map[string]map[string][]string
+
+	// TypeDefs maps file names to the types defined in that file
+	// Key: filename (without .go extension), Value: list of type names
+	TypeDefs map[string][]string
+
+	// TypeCalls maps file names to the types they reference from other files
+	// Key: filename (without .go extension), Value: map[sourceFile][]typeNames
+	TypeCalls map[string]map[string][]string
 }
 
 // NewAnalysis creates a new Analysis instance.
@@ -137,6 +154,8 @@ func NewPackageAnalysis() *PackageAnalysis {
 	return &PackageAnalysis{
 		FunctionDefs:  make(map[string][]string),
 		FunctionCalls: make(map[string]map[string][]string),
+		TypeDefs:      make(map[string][]string),
+		TypeCalls:     make(map[string]map[string][]string),
 	}
 }
 
@@ -270,6 +289,30 @@ func (a *Analysis) IsMethodValue(node *ast.SelectorExpr) bool {
 	return nodeInfo.IsMethodValue
 }
 
+// HasVariableShadowing returns whether the given node has variable shadowing issues
+func (a *Analysis) HasVariableShadowing(node ast.Node) bool {
+	if node == nil {
+		return false
+	}
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return false
+	}
+	return nodeInfo.ShadowingInfo != nil
+}
+
+// GetShadowingInfo returns the variable shadowing information for the given node
+func (a *Analysis) GetShadowingInfo(node ast.Node) *ShadowingInfo {
+	if node == nil {
+		return nil
+	}
+	nodeInfo := a.NodeData[node]
+	if nodeInfo == nil {
+		return nil
+	}
+	return nodeInfo.ShadowingInfo
+}
+
 // analysisVisitor implements ast.Visitor and is used to traverse the AST during analysis.
 type analysisVisitor struct {
 	// analysis stores information gathered during the traversal
@@ -631,6 +674,19 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		return v // Continue traversal
 
 	case *ast.AssignStmt:
+		// Detect variable shadowing in any := assignment
+		if n.Tok == token.DEFINE {
+			shadowingInfo := v.detectVariableShadowing(n)
+			if shadowingInfo != nil {
+				// Store shadowing info on the assignment statement itself
+				if v.analysis.NodeData[n] == nil {
+					v.analysis.NodeData[n] = &NodeInfo{}
+				}
+				v.analysis.NodeData[n].ShadowingInfo = shadowingInfo
+			}
+		}
+
+		// Continue with the existing assignment analysis logic
 		for i, currentLHSExpr := range n.Lhs {
 			if i >= len(n.Rhs) {
 				break // Should not happen in valid Go
@@ -779,6 +835,22 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 		return v // Continue traversal
+
+	case *ast.IfStmt:
+		// Detect variable shadowing in if statement initializations
+		if n.Init != nil {
+			if assignStmt, ok := n.Init.(*ast.AssignStmt); ok && assignStmt.Tok == token.DEFINE {
+				shadowingInfo := v.detectVariableShadowing(assignStmt)
+				if shadowingInfo != nil {
+					// Initialize NodeData for this if statement
+					if v.analysis.NodeData[n] == nil {
+						v.analysis.NodeData[n] = &NodeInfo{}
+					}
+					v.analysis.NodeData[n].ShadowingInfo = shadowingInfo
+				}
+			}
+		}
+		return v // Continue traversal
 	}
 
 	// For all other nodes, continue traversal
@@ -974,6 +1046,7 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
 
 		var functions []string
+		var types []string
 		for _, decl := range syntax.Decls {
 			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
 				// Only collect top-level functions (not methods)
@@ -981,11 +1054,22 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 					functions = append(functions, funcDecl.Name.Name)
 				}
 			}
+			if genDecl, ok := decl.(*ast.GenDecl); ok {
+				// Collect type declarations
+				for _, spec := range genDecl.Specs {
+					if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+						types = append(types, typeSpec.Name.Name)
+					}
+				}
+			}
 		}
 
 		if len(functions) > 0 {
 			analysis.FunctionDefs[baseFileName] = functions
 		}
+		if len(types) > 0 {
+			analysis.TypeDefs[baseFileName] = types
+		}
 	}
 
 	// Second pass: analyze function calls and determine which need imports
@@ -1049,6 +1133,71 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 		}
 	}
 
+	// Third pass: analyze type references and determine which need imports
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		// Find all type references in this file
+		typeRefsFromOtherFiles := make(map[string][]string)
+
+		ast.Inspect(syntax, func(n ast.Node) bool {
+			// Look for type references in struct fields, function parameters, etc.
+			if ident, ok := n.(*ast.Ident); ok {
+				// Check if this identifier refers to a type
+				if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
+					if _, ok := obj.(*types.TypeName); ok {
+						typeName := ident.Name
+
+						// Check if this type is defined in the current file
+						currentFileTypes := analysis.TypeDefs[baseFileName]
+						isDefinedInCurrentFile := false
+						for _, t := range currentFileTypes {
+							if t == typeName {
+								isDefinedInCurrentFile = true
+								break
+							}
+						}
+
+						// If not defined in current file, find which file defines it
+						if !isDefinedInCurrentFile {
+							for sourceFile, types := range analysis.TypeDefs {
+								if sourceFile == baseFileName {
+									continue // Skip current file
+								}
+								for _, t := range types {
+									if t == typeName {
+										// Found the type in another file
+										if typeRefsFromOtherFiles[sourceFile] == nil {
+											typeRefsFromOtherFiles[sourceFile] = []string{}
+										}
+										// Check if already added to avoid duplicates
+										found := false
+										for _, existing := range typeRefsFromOtherFiles[sourceFile] {
+											if existing == typeName {
+												found = true
+												break
+											}
+										}
+										if !found {
+											typeRefsFromOtherFiles[sourceFile] = append(typeRefsFromOtherFiles[sourceFile], typeName)
+										}
+										break
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			return true
+		})
+
+		if len(typeRefsFromOtherFiles) > 0 {
+			analysis.TypeCalls[baseFileName] = typeRefsFromOtherFiles
+		}
+	}
+
 	return analysis
 }
 
@@ -1225,3 +1374,112 @@ func (v *analysisVisitor) markFunctionVariable(ident *ast.Ident, funcType *types
 		v.analysis.MarkFunctionForReflection(funcNode, funcType)
 	}
 }
+
+// detectVariableShadowing detects variable shadowing in any := assignment
+func (v *analysisVisitor) detectVariableShadowing(assignStmt *ast.AssignStmt) *ShadowingInfo {
+	shadowingInfo := &ShadowingInfo{
+		ShadowedVariables: make(map[string]types.Object),
+		TempVariables:     make(map[string]string),
+	}
+
+	hasShadowing := false
+
+	// First, collect all LHS variable names that are being declared
+	lhsVarNames := make(map[string]*ast.Ident)
+	for _, lhsExpr := range assignStmt.Lhs {
+		if lhsIdent, ok := lhsExpr.(*ast.Ident); ok && lhsIdent.Name != "_" {
+			lhsVarNames[lhsIdent.Name] = lhsIdent
+		}
+	}
+
+	// Next, check all RHS expressions for usage of variables that are also being declared on LHS
+	for _, rhsExpr := range assignStmt.Rhs {
+		v.findVariableUsageInExpr(rhsExpr, lhsVarNames, shadowingInfo, &hasShadowing)
+	}
+
+	if hasShadowing {
+		return shadowingInfo
+	}
+	return nil
+}
+
+// findVariableUsageInExpr recursively searches for variable usage in an expression
+func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map[string]*ast.Ident, shadowingInfo *ShadowingInfo, hasShadowing *bool) {
+	if expr == nil {
+		return
+	}
+
+	switch e := expr.(type) {
+	case *ast.Ident:
+		// Check if this identifier is being shadowed
+		if lhsIdent, exists := lhsVarNames[e.Name]; exists {
+			// This variable is being used on RHS but also declared on LHS - this is shadowing!
+
+			// Get the outer scope object for this variable
+			if outerObj := v.pkg.TypesInfo.Uses[e]; outerObj != nil {
+				// Make sure this isn't the same object as the LHS (which would mean no shadowing)
+				if lhsObj := v.pkg.TypesInfo.Defs[lhsIdent]; lhsObj != outerObj {
+					shadowingInfo.ShadowedVariables[e.Name] = outerObj
+					shadowingInfo.TempVariables[e.Name] = "_temp_" + e.Name
+					*hasShadowing = true
+				}
+			}
+		}
+
+	case *ast.CallExpr:
+		// Check function arguments
+		for _, arg := range e.Args {
+			v.findVariableUsageInExpr(arg, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		// Check function expression itself
+		v.findVariableUsageInExpr(e.Fun, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.SelectorExpr:
+		// Check the base expression (e.g., x in x.Method())
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.IndexExpr:
+		// Check both the expression and index (e.g., arr[i])
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		v.findVariableUsageInExpr(e.Index, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.SliceExpr:
+		// Check the expression and slice bounds
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		if e.Low != nil {
+			v.findVariableUsageInExpr(e.Low, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		if e.High != nil {
+			v.findVariableUsageInExpr(e.High, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+		if e.Max != nil {
+			v.findVariableUsageInExpr(e.Max, lhsVarNames, shadowingInfo, hasShadowing)
+		}
+
+	case *ast.UnaryExpr:
+		// Check the operand (e.g., &x, -x, !x)
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.BinaryExpr:
+		// Check both operands (e.g., x + y)
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+		v.findVariableUsageInExpr(e.Y, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.ParenExpr:
+		// Check the parenthesized expression
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.TypeAssertExpr:
+		// Check the expression being type-asserted
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	case *ast.StarExpr:
+		// Check the expression being dereferenced
+		v.findVariableUsageInExpr(e.X, lhsVarNames, shadowingInfo, hasShadowing)
+
+	// Add more expression types as needed
+	default:
+		// For other expression types, we might need to add specific handling
+		// For now, we'll ignore them as they're less common in shadowing scenarios
+	}
+}

package/compiler/assignment.go

@@ -124,6 +124,12 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			}
 		}
 
+		// Add semicolon before destructuring assignment to prevent TypeScript
+		// from interpreting it as array access on the previous line
+		if tok != token.DEFINE {
+			c.tsw.WriteLiterally(";")
+		}
+
 		// Use array destructuring for multi-variable assignments
 		c.tsw.WriteLiterally("[")
 		for i, l := range lhs {

package/compiler/compiler.go

@@ -621,6 +621,61 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		}
 	}
 
+	// Generate auto-imports for types from other files in the same package
+	if typeImports := c.PackageAnalysis.TypeCalls[currentFileName]; typeImports != nil {
+		// Sort source files for consistent import order
+		var sourceFiles []string
+		for sourceFile := range typeImports {
+			sourceFiles = append(sourceFiles, sourceFile)
+		}
+		sort.Strings(sourceFiles)
+
+		for _, sourceFile := range sourceFiles {
+			typeImports := typeImports[sourceFile]
+			if len(typeImports) > 0 {
+				// Filter out protobuf types - they should be imported from .pb.js files, not .gs.js files
+				var nonProtobufTypes []string
+				for _, typeName := range typeImports {
+					// Check if this type is a protobuf type by looking for it in the package
+					isProtobuf := false
+					if typeObj := c.pkg.Types.Scope().Lookup(typeName); typeObj != nil {
+						objType := typeObj.Type()
+						if namedType, ok := objType.(*types.Named); ok {
+							obj := namedType.Obj()
+							if obj != nil && obj.Pkg() != nil {
+								// Check if the type is defined in the current package and has a corresponding .pb.go file
+								if obj.Pkg() == c.pkg.Types {
+									// Check if there's a .pb.go file in the package that exports this type
+									// For now, we'll use a simple heuristic: if the type name ends with "Msg"
+									// and there's a .pb.go file in the package, assume it's a protobuf type
+									if strings.HasSuffix(typeName, "Msg") {
+										// Check if there are any .pb.go files in this package
+										for _, fileName := range c.pkg.CompiledGoFiles {
+											if strings.HasSuffix(fileName, ".pb.go") {
+												isProtobuf = true
+												break
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+					if !isProtobuf {
+						nonProtobufTypes = append(nonProtobufTypes, typeName)
+					}
+				}
+
+				if len(nonProtobufTypes) > 0 {
+					// Sort types for consistent output
+					sort.Strings(nonProtobufTypes)
+					c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
+						strings.Join(nonProtobufTypes, ", "), sourceFile)
+				}
+			}
+		}
+	}
+
 	c.codeWriter.WriteLine("") // Add a newline after imports
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {
@@ -639,6 +694,9 @@ type GoToTSCompiler struct {
 	pkg *packages.Package
 
 	analysis *Analysis
+
+	// shadowingContext tracks temporary variable mappings when we're in a shadowing context
+	shadowingContext map[string]string
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,
@@ -646,9 +704,10 @@ type GoToTSCompiler struct {
 // analysis results (`Analysis`) to guide the translation process.
 func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis) *GoToTSCompiler {
 	return &GoToTSCompiler{
-		tsw:      tsw,
-		pkg:      pkg,
-		analysis: analysis,
+		tsw:              tsw,
+		pkg:              pkg,
+		analysis:         analysis,
+		shadowingContext: make(map[string]string),
 	}
 }
 
@@ -670,6 +729,12 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 		return
 	}
 
+	// Check if we're in a shadowing context and should use a temporary variable
+	if tempVarName, exists := c.shadowingContext[exp.Name]; exists {
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(tempVarName))
+		return
+	}
+
 	// Use TypesInfo to find the object associated with the identifier
 	var obj types.Object
 	obj = c.pkg.TypesInfo.Uses[exp]
@@ -680,11 +745,30 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 	// Check if this identifier refers to a constant
 	if obj != nil {
 		if constObj, isConst := obj.(*types.Const); isConst {
-			// Only evaluate constants from the current package being compiled
-			// Don't evaluate constants from imported packages (they should use their exported names)
-			// Special case: predeclared constants like iota have a nil package, so we should evaluate them
-			if constObj.Pkg() == c.pkg.Types || constObj.Pkg() == nil {
-				// Write the constant's evaluated value instead of the identifier name
+			// Evaluate constants to literals in these cases:
+			// 1. Predeclared constants (like iota, true, false) - these have nil package
+			// 2. Constants from the current package that are computed expressions
+			//    (like iota-based constants or mathematical expressions)
+			//
+			// For simple assignments from imported constants (const x = pkg.Y),
+			// preserve the variable name for better readability.
+
+			if constObj.Pkg() == nil {
+				// Predeclared constants - always evaluate to literals
+				c.writeConstantValue(constObj)
+				return
+			}
+
+			if constObj.Pkg() == c.pkg.Types {
+				// This is a constant from the current package.
+				// Check if it's a simple assignment by looking at the constant value:
+				// If the constant has the same name as an identifier in the import,
+				// it's likely a simple assignment and we should preserve the name.
+				// Otherwise, evaluate to literal (for computed expressions like iota).
+
+				// For now, let's be conservative and evaluate current package constants
+				// to literals to maintain compatibility with existing behavior.
+				// This handles iota-based constants correctly.
 				c.writeConstantValue(constObj)
 				return
 			}
@@ -970,6 +1054,12 @@ func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) e
 				continue
 			}
 
+			// Skip .test.ts files
+			if strings.HasSuffix(fileName, ".test.ts") {
+				// c.le.Debugf("Skipping test file: %s", fileName)
+				continue
+			}
+
 			// Remove existing file if it exists (but preserve directories)
 			if stat, err := os.Stat(outputEntryPath); err == nil && !stat.IsDir() {
 				if err := os.Remove(outputEntryPath); err != nil {

package/compiler/decl.go

@@ -101,29 +101,13 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 	c.WriteFuncType(decl.Type, isAsync) // Write signature (params, return type)
 	c.tsw.WriteLiterally(" ")
 
-	hasNamedReturns := false
-	if decl.Type.Results != nil {
-		for _, field := range decl.Type.Results.List {
-			if len(field.Names) > 0 {
-				hasNamedReturns = true
-				break
-			}
-		}
-	}
-
-	if hasNamedReturns {
+	if c.hasNamedReturns(decl.Type.Results) {
 		c.tsw.WriteLine("{")
 		c.tsw.Indent(1)
 
 		// Declare named return variables and initialize them to their zero values
-		for _, field := range decl.Type.Results.List {
-			for _, name := range field.Names {
-				c.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
-				c.WriteTypeExpr(field.Type)
-				c.tsw.WriteLiterally(" = ")
-				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
-				c.tsw.WriteLine("")
-			}
+		if err := c.writeNamedReturnDeclarations(decl.Type.Results); err != nil {
+			return fmt.Errorf("failed to write named return declarations: %w", err)
 		}
 	}
 
@@ -131,7 +115,7 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 		return fmt.Errorf("failed to write function body: %w", err)
 	}
 
-	if hasNamedReturns {
+	if c.hasNamedReturns(decl.Type.Results) {
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("}")
 	}
@@ -244,6 +228,11 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 				}
 			}
 
+			// Declare named return variables and initialize them to their zero values
+			if err := c.writeNamedReturnDeclarations(decl.Type.Results); err != nil {
+				return fmt.Errorf("failed to write named return declarations: %w", err)
+			}
+
 			// write method body without outer braces
 			for _, stmt := range decl.Body.List {
 				if err := c.WriteStmt(stmt); err != nil {
@@ -263,3 +252,36 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 
 	return nil
 }
+
+// writeNamedReturnDeclarations generates TypeScript variable declarations for named return parameters.
+// It declares each named return variable with its appropriate type and zero value.
+func (c *GoToTSCompiler) writeNamedReturnDeclarations(results *ast.FieldList) error {
+	if results == nil {
+		return nil
+	}
+
+	for _, field := range results.List {
+		for _, name := range field.Names {
+			c.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
+			c.WriteTypeExpr(field.Type)
+			c.tsw.WriteLiterally(" = ")
+			c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
+			c.tsw.WriteLine("")
+		}
+	}
+	return nil
+}
+
+// hasNamedReturns checks if a function type has any named return parameters.
+func (c *GoToTSCompiler) hasNamedReturns(results *ast.FieldList) bool {
+	if results == nil {
+		return false
+	}
+
+	for _, field := range results.List {
+		if len(field.Names) > 0 {
+			return true
+		}
+	}
+	return false
+}

package/compiler/expr-call.go

@@ -97,6 +97,37 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				}
 			}
 		}
+
+		// Handle general slice type conversions like []T(namedType) where namedType has underlying type []T
+		if arrayType.Len == nil && len(exp.Args) == 1 {
+			arg := exp.Args[0]
+			if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
+				// Check if the argument is a named type with a slice underlying type
+				if namedArgType, isNamed := argType.(*types.Named); isNamed {
+					// Check if the named type has receiver methods (is a wrapper class)
+					typeName := namedArgType.Obj().Name()
+					if c.hasReceiverMethods(typeName) {
+						// Check if the underlying type matches the target slice type
+						if sliceUnderlying, isSlice := namedArgType.Underlying().(*types.Slice); isSlice {
+							// Get the target slice type
+							targetType := c.pkg.TypesInfo.TypeOf(arrayType)
+							if targetSliceType, isTargetSlice := targetType.Underlying().(*types.Slice); isTargetSlice {
+								// Check if element types are compatible
+								if types.Identical(sliceUnderlying.Elem(), targetSliceType.Elem()) {
+									// This is a conversion from NamedType to []T where NamedType has underlying []T
+									// Use valueOf() to get the underlying slice
+									if err := c.WriteValueExpr(arg); err != nil {
+										return fmt.Errorf("failed to write argument for slice type conversion: %w", err)
+									}
+									c.tsw.WriteLiterally(".valueOf()")
+									return nil // Handled named type to slice conversion
+								}
+							}
+						}
+					}
+				}
+			}
+		}
 	}
 
 	if funIdent, funIsIdent := expFun.(*ast.Ident); funIsIdent {
@@ -274,7 +305,12 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					}
 
 					c.tsw.WriteLiterally("$.makeSlice<")
-					c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
+					// Use AST-based type writing to preserve qualified names
+					if arrType, ok := exp.Args[0].(*ast.ArrayType); ok {
+						c.WriteTypeExpr(arrType.Elt)
+					} else {
+						c.WriteGoType(goElemType, GoTypeContextGeneral)
+					}
 					c.tsw.WriteLiterally(">(")
 
 					hasCapacity := len(exp.Args) == 3

package/compiler/expr-type.go

@@ -45,6 +45,26 @@ func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
 		}
 	}
 
+	// Handle array/slice types to preserve qualified names in element types
+	if arrayType, ok := a.(*ast.ArrayType); ok {
+		if arrayType.Len == nil {
+			// Slice type: []T -> $.Slice<T>
+			// Check if it's a []byte slice first
+			if ident, ok := arrayType.Elt.(*ast.Ident); ok && ident.Name == "byte" {
+				c.tsw.WriteLiterally("$.Bytes")
+				return
+			}
+			c.tsw.WriteLiterally("$.Slice<")
+			c.WriteTypeExpr(arrayType.Elt) // Recursively handle element type preserving qualified names
+			c.tsw.WriteLiterally(">")
+		} else {
+			// Array type: [N]T -> T[]
+			c.WriteTypeExpr(arrayType.Elt) // Recursively handle element type preserving qualified names
+			c.tsw.WriteLiterally("[]")
+		}
+		return
+	}
+
 	// Get type information for the expression and use WriteGoType
 	typ := c.pkg.TypesInfo.TypeOf(a)
 	c.WriteGoType(typ, GoTypeContextGeneral)