goscript 0.0.76 → 0.0.78

package/compiler/analysis.go

@@ -240,6 +240,53 @@ func NewPackageAnalysis() *PackageAnalysis {
 	}
 }
 
+// collectZeroValueTypeNames records named struct types whose zero value emits a
+// runtime constructor call.
+func collectZeroValueTypeNames(typ types.Type, names map[string]struct{}) {
+	switch t := typ.(type) {
+	case *types.Array:
+		collectZeroValueTypeNames(t.Elem(), names)
+	case *types.Named:
+		if _, isStruct := t.Underlying().(*types.Struct); isStruct {
+			names[t.Obj().Name()] = struct{}{}
+			return
+		}
+		collectZeroValueTypeNames(t.Underlying(), names)
+	case *types.Alias:
+		collectZeroValueTypeNames(t.Underlying(), names)
+	}
+}
+
+// addTypeRefsFromZeroValue adds same-package type imports needed when code
+// generation synthesizes a zero value without an explicit AST type reference.
+func addTypeRefsFromZeroValue(analysis *PackageAnalysis, currentFileName string, typ types.Type, refs map[string][]string) {
+	typeNames := make(map[string]struct{})
+	collectZeroValueTypeNames(typ, typeNames)
+	if len(typeNames) == 0 {
+		return
+	}
+
+	currentFileTypes := analysis.TypeDefs[currentFileName]
+	for typeName := range typeNames {
+		if slices.Contains(currentFileTypes, typeName) {
+			continue
+		}
+
+		for sourceFile, types := range analysis.TypeDefs {
+			if sourceFile == currentFileName || !slices.Contains(types, typeName) {
+				continue
+			}
+
+			if refs[sourceFile] == nil {
+				refs[sourceFile] = []string{}
+			}
+			if !slices.Contains(refs[sourceFile], typeName) {
+				refs[sourceFile] = append(refs[sourceFile], typeName)
+			}
+		}
+	}
+}
+
 // ensureNodeData ensures that NodeData exists for a given node and returns it
 func (a *Analysis) ensureNodeData(node ast.Node) *NodeInfo {
 	if node == nil {
@@ -1148,8 +1195,7 @@ func (v *analysisVisitor) visitTypeAssertExpr(typeAssert *ast.TypeAssertExpr) as
 	}
 
 	// For each method in the interface, check if the struct implements it
-	for i := 0; i < interfaceType.NumExplicitMethods(); i++ {
-		interfaceMethod := interfaceType.ExplicitMethod(i)
+	for interfaceMethod := range interfaceType.ExplicitMethods() {
 
 		// Find the corresponding method in the struct type
 		structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
@@ -1417,8 +1463,7 @@ func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
 			}
 
 			// Look for embedded fields
-			for i := 0; i < structType.NumFields(); i++ {
-				field := structType.Field(i)
+			for field := range structType.Fields() {
 				if !field.Embedded() {
 					continue
 				}
@@ -1442,8 +1487,7 @@ func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
 				embeddedMethodSet := types.NewMethodSet(methodSetType)
 
 				// Scan all methods in the method set
-				for j := 0; j < embeddedMethodSet.Len(); j++ {
-					selection := embeddedMethodSet.At(j)
+				for selection := range embeddedMethodSet.Methods() {
 					method := selection.Obj()
 					sig, ok := method.Type().(*types.Signature)
 					if !ok {
@@ -1452,16 +1496,14 @@ func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
 
 					// Scan parameters
 					if sig.Params() != nil {
-						for k := 0; k < sig.Params().Len(); k++ {
-							param := sig.Params().At(k)
+						for param := range sig.Params().Variables() {
 							a.collectPackageFromType(param.Type(), pkg.Types, packagesToAdd)
 						}
 					}
 
 					// Scan results
 					if sig.Results() != nil {
-						for k := 0; k < sig.Results().Len(); k++ {
-							result := sig.Results().At(k)
+						for result := range sig.Results().Variables() {
 							a.collectPackageFromType(result.Type(), pkg.Types, packagesToAdd)
 						}
 					}
@@ -1494,17 +1536,16 @@ func (a *Analysis) collectPackageFromType(t types.Type, currentPkg *types.Packag
 		}
 		// Check type arguments for generics
 		if typ.TypeArgs() != nil {
-			for i := 0; i < typ.TypeArgs().Len(); i++ {
-				a.collectPackageFromType(typ.TypeArgs().At(i), currentPkg, packagesToAdd)
+			for t := range typ.TypeArgs().Types() {
+				a.collectPackageFromType(t, currentPkg, packagesToAdd)
 			}
 		}
 	case *types.Interface:
 		// For interfaces, we need to check embedded interfaces and method signatures
-		for i := 0; i < typ.NumEmbeddeds(); i++ {
-			a.collectPackageFromType(typ.EmbeddedType(i), currentPkg, packagesToAdd)
+		for etyp := range typ.EmbeddedTypes() {
+			a.collectPackageFromType(etyp, currentPkg, packagesToAdd)
 		}
-		for i := 0; i < typ.NumExplicitMethods(); i++ {
-			method := typ.ExplicitMethod(i)
+		for method := range typ.ExplicitMethods() {
 			a.collectPackageFromType(method.Type(), currentPkg, packagesToAdd)
 		}
 	case *types.Pointer:
@@ -1521,14 +1562,14 @@ func (a *Analysis) collectPackageFromType(t types.Type, currentPkg *types.Packag
 	case *types.Signature:
 		// Collect from parameters
 		if typ.Params() != nil {
-			for i := 0; i < typ.Params().Len(); i++ {
-				a.collectPackageFromType(typ.Params().At(i).Type(), currentPkg, packagesToAdd)
+			for v := range typ.Params().Variables() {
+				a.collectPackageFromType(v.Type(), currentPkg, packagesToAdd)
 			}
 		}
 		// Collect from results
 		if typ.Results() != nil {
-			for i := 0; i < typ.Results().Len(); i++ {
-				a.collectPackageFromType(typ.Results().At(i).Type(), currentPkg, packagesToAdd)
+			for v := range typ.Results().Variables() {
+				a.collectPackageFromType(v.Type(), currentPkg, packagesToAdd)
 			}
 		}
 	}
@@ -1693,6 +1734,37 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 					}
 				}
 			}
+
+			if callExpr, ok := n.(*ast.CallExpr); ok {
+				if funIdent, ok := callExpr.Fun.(*ast.Ident); ok && funIdent.Name == "make" && len(callExpr.Args) > 0 {
+					if typ := pkg.TypesInfo.TypeOf(callExpr.Args[0]); typ != nil {
+						if chanType, ok := typ.Underlying().(*types.Chan); ok {
+							addTypeRefsFromZeroValue(analysis, baseFileName, chanType.Elem(), typeRefsFromOtherFiles)
+						}
+					}
+				}
+			}
+
+			if indexExpr, ok := n.(*ast.IndexExpr); ok {
+				if tv, ok := pkg.TypesInfo.Types[indexExpr.X]; ok {
+					if mapType, ok := tv.Type.Underlying().(*types.Map); ok {
+						addTypeRefsFromZeroValue(analysis, baseFileName, mapType.Elem(), typeRefsFromOtherFiles)
+						return true
+					}
+
+					if typeParam, ok := tv.Type.(*types.TypeParam); ok {
+						constraint := typeParam.Constraint()
+						if constraint == nil {
+							return true
+						}
+						if iface, ok := constraint.Underlying().(*types.Interface); ok && hasMapConstraint(iface) {
+							if mapValueType := getMapValueTypeFromConstraint(iface); mapValueType != nil {
+								addTypeRefsFromZeroValue(analysis, baseFileName, mapValueType, typeRefsFromOtherFiles)
+							}
+						}
+					}
+				}
+			}
 			return true
 		})
 
@@ -1830,8 +1902,8 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 			// Check if this type has the method being called
 			methodName := selectorExpr.Sel.Name
 			found := false
-			for j := 0; j < namedType.NumMethods(); j++ {
-				if namedType.Method(j).Name() == methodName {
+			for method := range namedType.Methods() {
+				if method.Name() == methodName {
 					found = true
 					break
 				}
@@ -2351,8 +2423,7 @@ func (a *Analysis) GetIdentifierMapping(ident *ast.Ident) string {
 // findStructMethod finds a method with the given name on a named type
 func (v *analysisVisitor) findStructMethod(namedType *types.Named, methodName string) *types.Func {
 	// Check methods directly on the type
-	for i := 0; i < namedType.NumMethods(); i++ {
-		method := namedType.Method(i)
+	for method := range namedType.Methods() {
 		if method.Name() == methodName {
 			return method
 		}
@@ -2455,8 +2526,7 @@ func (v *analysisVisitor) trackInterfaceAssignments(assignStmt *ast.AssignStmt)
 		}
 
 		// Track implementations for all interface methods
-		for j := 0; j < interfaceType.NumExplicitMethods(); j++ {
-			interfaceMethod := interfaceType.ExplicitMethod(j)
+		for interfaceMethod := range interfaceType.ExplicitMethods() {
 
 			structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
 			if structMethod != nil {
@@ -2514,8 +2584,7 @@ func (v *analysisVisitor) trackInterfaceCallArguments(callExpr *ast.CallExpr) {
 		}
 
 		// Track implementations for all interface methods
-		for j := 0; j < interfaceType.NumExplicitMethods(); j++ {
-			interfaceMethod := interfaceType.ExplicitMethod(j)
+		for interfaceMethod := range interfaceType.ExplicitMethods() {
 
 			structMethod := v.findStructMethod(namedType, interfaceMethod.Name())
 			if structMethod != nil {
@@ -2659,8 +2728,7 @@ func (v *interfaceImplementationVisitor) findImplementationsInPackage(interfaceT
 // trackImplementation records that a named type implements an interface
 func (v *interfaceImplementationVisitor) trackImplementation(interfaceType *types.Interface, namedType *types.Named) {
 	// For each method in the interface, find the corresponding implementation
-	for i := 0; i < interfaceType.NumExplicitMethods(); i++ {
-		interfaceMethod := interfaceType.ExplicitMethod(i)
+	for interfaceMethod := range interfaceType.ExplicitMethods() {
 
 		// Find the method in the implementing type
 		structMethod := v.findMethodInType(namedType, interfaceMethod.Name())
@@ -2672,8 +2740,7 @@ func (v *interfaceImplementationVisitor) trackImplementation(interfaceType *type
 
 // findMethodInType finds a method with the given name in a named type
 func (v *interfaceImplementationVisitor) findMethodInType(namedType *types.Named, methodName string) *types.Func {
-	for i := 0; i < namedType.NumMethods(); i++ {
-		method := namedType.Method(i)
+	for method := range namedType.Methods() {
 		if method.Name() == methodName {
 			return method
 		}
@@ -2696,7 +2763,7 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 	// 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
 	maxIterations := 10
-	for iteration := 0; iteration < maxIterations; iteration++ {
+	for range maxIterations {
 		changed := false
 
 		for _, methodKey := range cycles {

package/compiler/analysis_test.go

@@ -6,6 +6,7 @@ import (
 	"go/token"
 	"go/types"
 	"os"
+	"slices"
 	"testing"
 
 	"golang.org/x/tools/go/packages"
@@ -329,13 +330,7 @@ func TestDiscoverGsPackages(t *testing.T) {
 	// Check for some known packages that should exist
 	expectedPackages := []string{"sync", "bytes", "strings"}
 	for _, expected := range expectedPackages {
-		found := false
-		for _, pkg := range packages {
-			if pkg == expected {
-				found = true
-				break
-			}
-		}
+		found := slices.Contains(packages, expected)
 		if !found {
 			t.Logf("Expected package '%s' not found in discovered packages: %v", expected, packages)
 		}

package/compiler/code-writer.go

@@ -59,8 +59,8 @@ func (w *TSCodeWriter) WriteImport(symbolName, importPath string) {
 
 // WriteCommentLine writes a comment as a // line.
 func (w *TSCodeWriter) WriteCommentLine(commentText string) {
-	lines := strings.Split(commentText, "\n")
-	for _, line := range lines {
+	lines := strings.SplitSeq(commentText, "\n")
+	for line := range lines {
 		w.WriteLinef("// %s", line)
 	}
 }

package/compiler/compiler.go

@@ -414,9 +414,9 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 
 		// Check if this is a .pb.go file that should be skipped
 		baseFileName := filepath.Base(fileName)
-		if strings.HasSuffix(baseFileName, ".pb.go") {
+		if before, ok := strings.CutSuffix(baseFileName, ".pb.go"); ok {
 			// Check if there's a corresponding .pb.ts file
-			pbTsFileName := strings.TrimSuffix(baseFileName, ".pb.go") + ".pb.ts"
+			pbTsFileName := before + ".pb.ts"
 			packageDir := filepath.Dir(fileName)
 			pbTsPath := filepath.Join(packageDir, pbTsFileName)
 
@@ -1131,10 +1131,10 @@ func (c *GoToTSCompiler) WriteDoc(doc *ast.CommentGroup) {
 		// Preserve original comment style (// or /*)
 		if strings.HasPrefix(comment.Text, "//") {
 			c.tsw.WriteLine(comment.Text)
-		} else if strings.HasPrefix(comment.Text, "/*") {
+		} else if after, ok := strings.CutPrefix(comment.Text, "/*"); ok {
 			// Write block comments potentially spanning multiple lines
 			// Remove /* and */, then split by newline
-			content := strings.TrimSuffix(strings.TrimPrefix(comment.Text, "/*"), "*/")
+			content := strings.TrimSuffix(after, "*/")
 			lines := strings.Split(content, "\n") // Use \n as Split expects a separator string
 
 			if len(lines) == 1 && !strings.Contains(lines[0], "\n") { // Check again for internal newlines just in case

package/compiler/composite-lit.go

@@ -107,7 +107,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 			// Use type info to get array length and element type
 			var arrayLen int
 			var elemType ast.Expr
-			var goElemType interface{}
+			var goElemType any
 			if typ := c.pkg.TypesInfo.TypeOf(exp.Type); typ != nil {
 				if at, ok := typ.Underlying().(*types.Array); ok {
 					arrayLen = int(at.Len())
@@ -534,7 +534,7 @@ func (c *GoToTSCompiler) WriteVarRefedValue(expr ast.Expr) error {
 // evaluateConstantExpr attempts to evaluate a Go expression as a compile-time constant.
 // It returns the constant value if successful, or nil if the expression is not a constant.
 // This is used for evaluating array literal keys that are constant expressions.
-func (c *GoToTSCompiler) evaluateConstantExpr(expr ast.Expr) interface{} {
+func (c *GoToTSCompiler) evaluateConstantExpr(expr ast.Expr) any {
 	// Use the type checker's constant evaluation
 	if tv, ok := c.pkg.TypesInfo.Types[expr]; ok && tv.Value != nil {
 		// The expression has a constant value
@@ -575,8 +575,7 @@ func (c *GoToTSCompiler) categorizeStructFields(
 	explicitEmbedded = make(map[string]ast.Expr)
 
 	// Pre-populate embeddedFields map keys using the correct property name
-	for i := 0; i < structType.NumFields(); i++ {
-		field := structType.Field(i)
+	for field := range structType.Fields() {
 		if field.Anonymous() {
 			fieldType := field.Type()
 			if ptr, ok := fieldType.(*types.Pointer); ok {
@@ -611,8 +610,7 @@ func (c *GoToTSCompiler) categorizeStructFields(
 		}
 
 		isDirectField := false
-		for i := range structType.NumFields() {
-			field := structType.Field(i)
+		for field := range structType.Fields() {
 			if field.Name() == keyName {
 				isDirectField = true
 				directFields[keyName] = kv.Value

package/compiler/constraint.go

@@ -16,11 +16,9 @@ type ConstraintInfo struct {
 func analyzeConstraint(iface *types.Interface) ConstraintInfo {
 	info := ConstraintInfo{}
 
-	for i := 0; i < iface.NumEmbeddeds(); i++ {
-		embedded := iface.EmbeddedType(i)
+	for embedded := range iface.EmbeddedTypes() {
 		if union, ok := embedded.(*types.Union); ok {
-			for j := 0; j < union.Len(); j++ {
-				term := union.Term(j)
+			for term := range union.Terms() {
 				checkType(term.Type(), &info)
 			}
 		} else {

package/compiler/decl.go

@@ -1,6 +1,7 @@
 package compiler
 
 import (
+	"bytes"
 	"fmt"
 	"go/ast"
 	"go/token"
@@ -677,6 +678,14 @@ func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error)
 		}
 	}
 
+	if !isAsync {
+		bodyNeedsAsync, err := c.funcBodyNeedsAsync(decl, true)
+		if err != nil {
+			return false, err
+		}
+		isAsync = bodyNeedsAsync
+	}
+
 	// Methods are typically public in the TS output
 	c.tsw.WriteLiterally("public ")
 
@@ -744,6 +753,31 @@ func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error)
 	return isAsync, nil
 }
 
+// funcBodyNeedsAsync checks whether emitting a function body would generate await.
+func (c *GoToTSCompiler) funcBodyNeedsAsync(decl *ast.FuncDecl, isMethod bool) (bool, error) {
+	if decl.Body == nil {
+		return false, nil
+	}
+
+	var body strings.Builder
+	writer := NewTSCodeWriter(&body)
+	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis, c.currentFilePath)
+
+	if isMethod {
+		if err := tempCompiler.writeMethodBodyWithReceiverBinding(decl, "this"); err != nil {
+			return false, err
+		}
+	} else {
+		for _, stmt := range decl.Body.List {
+			if err := tempCompiler.WriteStmt(stmt); err != nil {
+				return false, err
+			}
+		}
+	}
+
+	return bytes.Contains([]byte(body.String()), []byte("await")), nil
+}
+
 // writeMethodBodyWithReceiverBinding writes the method body with optional receiver binding
 // receiverTarget should be "this" for struct methods or "this._value" for named type methods
 func (c *GoToTSCompiler) writeMethodBodyWithReceiverBinding(decl *ast.FuncDecl, receiverTarget string) error {

package/compiler/expr-call-async.go

@@ -169,6 +169,10 @@ func (c *GoToTSCompiler) addNonNullAssertion(expFun ast.Expr) {
 						c.tsw.WriteLiterally("!")
 					}
 				}
+			} else if _, isParenExpr := expFun.(*ast.ParenExpr); isParenExpr {
+				// Parenthesized function expressions often come from pointer dereferences
+				// like (*rel)(), which remain nullable in TypeScript.
+				c.tsw.WriteLiterally("!")
 			} else if _, isNamed := funType.(*types.Named); isNamed {
 				c.tsw.WriteLiterally("!")
 			}

package/compiler/expr-call-helpers.go

@@ -8,12 +8,12 @@ import (
 )
 
 // writeByteSliceCreation handles the creation of []byte slices with proper Uint8Array handling
-func (c *GoToTSCompiler) writeByteSliceCreation(lengthArg, capacityArg interface{}) error {
+func (c *GoToTSCompiler) writeByteSliceCreation(lengthArg, capacityArg any) error {
 	return c.writeSliceCreationForType(lengthArg, capacityArg, true)
 }
 
 // writeSliceCreationForType handles slice creation with special handling for byte slices
-func (c *GoToTSCompiler) writeSliceCreationForType(lengthArg, capacityArg interface{}, isByteSlice bool) error {
+func (c *GoToTSCompiler) writeSliceCreationForType(lengthArg, capacityArg any, isByteSlice bool) error {
 	hasCapacity := capacityArg != nil
 
 	if isByteSlice && !hasCapacity {
@@ -52,7 +52,7 @@ func (c *GoToTSCompiler) writeSliceCreationForType(lengthArg, capacityArg interf
 }
 
 // writeGenericSliceCreation handles the creation of generic slices with proper type hints
-func (c *GoToTSCompiler) writeGenericSliceCreation(elemType types.Type, lengthArg, capacityArg interface{}) error {
+func (c *GoToTSCompiler) writeGenericSliceCreation(elemType types.Type, lengthArg, capacityArg any) error {
 	hasCapacity := capacityArg != nil
 
 	c.tsw.WriteLiterally("$.makeSlice<")
@@ -90,7 +90,7 @@ func (c *GoToTSCompiler) writeSliceTypeHint(elemType types.Type, hasCapacity boo
 }
 
 // writeExprOrDefault writes an expression if it's not nil, otherwise writes a default value
-func (c *GoToTSCompiler) writeExprOrDefault(expr interface{}, defaultValue string) error {
+func (c *GoToTSCompiler) writeExprOrDefault(expr any, defaultValue string) error {
 	if expr == nil {
 		c.tsw.WriteLiterally(defaultValue)
 		return nil
@@ -149,6 +149,14 @@ func (c *GoToTSCompiler) writeReflectTypeFor(exp *ast.CallExpr, selectorExpr *as
 	typeArg := instance.TypeArgs.At(0)
 	// fmt.Printf("DEBUG: Type argument: %v\n", typeArg)
 
+	if named, ok := typeArg.(*types.Named); ok {
+		if _, isInterface := named.Underlying().(*types.Interface); isInterface {
+			typeName := qualifiedTypeName(named)
+			c.tsw.WriteLiterally("reflect.getInterfaceLiteralTypeByName(\"" + typeName + "\")")
+			return true, nil
+		}
+	}
+
 	// Generate TypeScript code to create a Type for this type
 	if err := c.writeTypeForTypeArg(typeArg); err != nil {
 		return true, err
@@ -157,6 +165,54 @@ func (c *GoToTSCompiler) writeReflectTypeFor(exp *ast.CallExpr, selectorExpr *as
 	return true, nil
 }
 
+// writeReflectTypeAssert handles reflect.TypeAssert[T](v) calls.
+func (c *GoToTSCompiler) writeReflectTypeAssert(exp *ast.CallExpr, selectorExpr *ast.SelectorExpr) (handled bool, err error) {
+	if selectorExpr.Sel.Name != "TypeAssert" {
+		return false, nil
+	}
+
+	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
+	}
+
+	if len(exp.Args) != 1 {
+		return false, errors.New("reflect.TypeAssert called with unexpected argument count")
+	}
+
+	if c.pkg.TypesInfo.Instances == nil {
+		return false, errors.New("reflect.TypeAssert 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.TypeAssert called without type arguments")
+	}
+
+	typeArg := instance.TypeArgs.At(0)
+
+	c.tsw.WriteLiterally("$.typeAssertTuple<")
+	c.WriteGoType(typeArg, GoTypeContextGeneral)
+	c.tsw.WriteLiterally(">(")
+	if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+		return true, err
+	}
+	c.tsw.WriteLiterally(".Interface(), ")
+	c.writeTypeInfoObject(typeArg)
+	c.tsw.WriteLiterally(")")
+	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
@@ -175,12 +231,46 @@ func (c *GoToTSCompiler) writeTypeForTypeArg(t types.Type) error {
 		c.tsw.WriteLiterally(")")
 		return nil
 	case *types.Slice:
-		// For slice types, use TypeOf with an empty slice
-		c.tsw.WriteLiterally("reflect.TypeOf([])")
+		c.tsw.WriteLiterally("reflect.SliceOf(")
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
 		return nil
 	case *types.Array:
-		// For array types, use TypeOf with an empty array
-		c.tsw.WriteLiterally("reflect.TypeOf([])")
+		c.tsw.WriteLiterally("reflect.ArrayOf(")
+		c.tsw.WriteLiterallyf("%d, ", underlying.Len())
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	case *types.Map:
+		c.tsw.WriteLiterally("reflect.MapOf(")
+		if err := c.writeTypeForTypeArg(underlying.Key()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(", ")
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	case *types.Chan:
+		c.tsw.WriteLiterally("reflect.ChanOf(")
+		switch underlying.Dir() {
+		case types.RecvOnly:
+			c.tsw.WriteLiterally("reflect.RecvDir")
+		case types.SendOnly:
+			c.tsw.WriteLiterally("reflect.SendDir")
+		default:
+			c.tsw.WriteLiterally("reflect.BothDir")
+		}
+		c.tsw.WriteLiterally(", ")
+		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
 		return nil
 	case *types.Struct:
 		// For struct types, use TypeOf with zero value

package/compiler/expr-call-make.go

@@ -79,7 +79,7 @@ func (c *GoToTSCompiler) writeMakeSlice(sliceType *types.Slice, exp *ast.CallExp
 
 	// Check if it's []byte
 	if c.isByteSliceType(sliceType) {
-		var lengthArg, capacityArg interface{}
+		var lengthArg, capacityArg any
 		if len(exp.Args) >= 2 {
 			lengthArg = exp.Args[1]
 		}
@@ -90,7 +90,7 @@ func (c *GoToTSCompiler) writeMakeSlice(sliceType *types.Slice, exp *ast.CallExp
 	}
 
 	// Handle other slice types
-	var lengthArg, capacityArg interface{}
+	var lengthArg, capacityArg any
 	if len(exp.Args) >= 2 {
 		lengthArg = exp.Args[1]
 	}
@@ -193,7 +193,7 @@ func (c *GoToTSCompiler) WriteCallExprMake(exp *ast.CallExpr) error {
 									if elemType != nil {
 										// Check if it's make(S, ...) where S constrains to []byte
 										if c.isByteSliceType(types.NewSlice(elemType)) {
-											var lengthArg, capacityArg interface{}
+											var lengthArg, capacityArg any
 											if len(exp.Args) >= 2 {
 												lengthArg = exp.Args[1]
 											}
@@ -203,7 +203,7 @@ func (c *GoToTSCompiler) WriteCallExprMake(exp *ast.CallExpr) error {
 											return c.writeByteSliceCreation(lengthArg, capacityArg)
 										}
 
-										var lengthArg, capacityArg interface{}
+										var lengthArg, capacityArg any
 										if len(exp.Args) >= 2 {
 											lengthArg = exp.Args[1]
 										}

package/compiler/expr-call.go

@@ -100,6 +100,9 @@ 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.writeReflectTypeAssert(exp, selectorExpr); handled {
+				return err
+			}
 			if handled, err := c.writeReflectTypeFor(exp, selectorExpr); handled {
 				return err
 			}

package/compiler/expr-type.go

@@ -20,6 +20,48 @@ import (
 // - Interface types -> TypeScript interface types or "any"
 // - Function types -> TypeScript function signatures
 func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
+	// Handle qualified generic type references (e.g., pkg.Type[T]) preserving the package alias.
+	if indexExpr, ok := a.(*ast.IndexExpr); ok {
+		if selectorExpr, ok := indexExpr.X.(*ast.SelectorExpr); ok {
+			if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {
+				if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
+					if _, isPkg := obj.(*types.PkgName); isPkg {
+						c.tsw.WriteLiterally(pkgIdent.Name)
+						c.tsw.WriteLiterally(".")
+						c.tsw.WriteLiterally(selectorExpr.Sel.Name)
+						c.tsw.WriteLiterally("<")
+						c.WriteTypeExpr(indexExpr.Index)
+						c.tsw.WriteLiterally(">")
+						return
+					}
+				}
+			}
+		}
+	}
+
+	if indexListExpr, ok := a.(*ast.IndexListExpr); ok {
+		if selectorExpr, ok := indexListExpr.X.(*ast.SelectorExpr); ok {
+			if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {
+				if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
+					if _, isPkg := obj.(*types.PkgName); isPkg {
+						c.tsw.WriteLiterally(pkgIdent.Name)
+						c.tsw.WriteLiterally(".")
+						c.tsw.WriteLiterally(selectorExpr.Sel.Name)
+						c.tsw.WriteLiterally("<")
+						for i, index := range indexListExpr.Indices {
+							if i > 0 {
+								c.tsw.WriteLiterally(", ")
+							}
+							c.WriteTypeExpr(index)
+						}
+						c.tsw.WriteLiterally(">")
+						return
+					}
+				}
+			}
+		}
+	}
+
 	// Handle selector expressions (e.g., os.FileInfo) specially to preserve qualified names
 	if selectorExpr, ok := a.(*ast.SelectorExpr); ok {
 		if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {