goscript 0.0.84 → 0.1.0

package/compiler/expr-call-helpers.go

@@ -1,382 +0,0 @@
-package compiler
-
-import (
-	"go/ast"
-	"go/types"
-
-	"github.com/pkg/errors"
-)
-
-// writeByteSliceCreation handles the creation of []byte slices with proper Uint8Array handling
-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 any, isByteSlice bool) error {
-	hasCapacity := capacityArg != nil
-
-	if isByteSlice && !hasCapacity {
-		// make([]byte, len) - capacity equals length, use Uint8Array
-		c.tsw.WriteLiterally("new Uint8Array(")
-		if err := c.writeExprOrDefault(lengthArg, "0"); err != nil {
-			return err
-		}
-		c.tsw.WriteLiterally(")")
-		return nil
-	}
-
-	// Use $.makeSlice for all other cases
-	if isByteSlice {
-		c.tsw.WriteLiterally("$.makeSlice<number>(")
-	} else {
-		return errors.New("writeSliceCreationForType called for non-byte slice without element type")
-	}
-
-	if err := c.writeExprOrDefault(lengthArg, "0"); err != nil {
-		return err
-	}
-
-	if hasCapacity {
-		c.tsw.WriteLiterally(", ")
-		if err := c.writeExprOrDefault(capacityArg, "0"); err != nil {
-			return err
-		}
-	}
-
-	if isByteSlice {
-		c.tsw.WriteLiterally(", 'byte')")
-	}
-
-	return nil
-}
-
-// writeGenericSliceCreation handles the creation of generic slices with proper type hints
-func (c *GoToTSCompiler) writeGenericSliceCreation(elemType types.Type, lengthArg, capacityArg any) error {
-	hasCapacity := capacityArg != nil
-
-	c.tsw.WriteLiterally("$.makeSlice<")
-	c.WriteGoType(elemType, GoTypeContextGeneral)
-	c.tsw.WriteLiterally(">(")
-
-	if err := c.writeExprOrDefault(lengthArg, "0"); err != nil {
-		return err
-	}
-
-	if hasCapacity {
-		c.tsw.WriteLiterally(", ")
-		if err := c.writeExprOrDefault(capacityArg, "0"); err != nil {
-			return err
-		}
-	}
-
-	// Add type hint for proper zero value initialization
-	c.writeSliceTypeHint(elemType, hasCapacity)
-	c.tsw.WriteLiterally(")")
-	return nil
-}
-
-// writeSliceTypeHint writes the type hint parameter for makeSlice calls
-func (c *GoToTSCompiler) writeSliceTypeHint(elemType types.Type, hasCapacity bool) {
-	typeHint := c.getTypeHintForSliceElement(elemType)
-	if typeHint != "" {
-		if !hasCapacity {
-			c.tsw.WriteLiterally(", undefined")
-		}
-		c.tsw.WriteLiterally(", '")
-		c.tsw.WriteLiterally(typeHint)
-		c.tsw.WriteLiterally("'")
-	}
-}
-
-// writeExprOrDefault writes an expression if it's not nil, otherwise writes a default value
-func (c *GoToTSCompiler) writeExprOrDefault(expr any, defaultValue string) error {
-	if expr == nil {
-		c.tsw.WriteLiterally(defaultValue)
-		return nil
-	}
-
-	switch e := expr.(type) {
-	case string:
-		c.tsw.WriteLiterally(e)
-		return nil
-	case ast.Expr:
-		// If it's an ast.Expr, call WriteValueExpr directly
-		return c.WriteValueExpr(e)
-	default:
-		// If we can't handle the type, return an error
-		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)
-
-	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
-	}
-
-	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
-	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:
-		c.tsw.WriteLiterally("reflect.SliceOf(")
-		if err := c.writeTypeForTypeArg(underlying.Elem()); err != nil {
-			return err
-		}
-		c.tsw.WriteLiterally(")")
-		return nil
-	case *types.Array:
-		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
-		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-make.go

@@ -1,318 +0,0 @@
-package compiler
-
-import (
-	"fmt"
-	"go/ast"
-	"go/types"
-
-	"github.com/pkg/errors"
-)
-
-// getTypeHintForSliceElement returns the appropriate type hint for makeSlice based on the Go element type
-func (c *GoToTSCompiler) getTypeHintForSliceElement(elemType types.Type) string {
-	if basicType, isBasic := elemType.(*types.Basic); isBasic {
-		switch basicType.Kind() {
-		case types.Int, types.Int8, types.Int16, types.Int32, types.Int64,
-			types.Uint, types.Uint8, types.Uint16, types.Uint32, types.Uint64,
-			types.Float32, types.Float64, types.Complex64, types.Complex128:
-			return "number"
-		case types.Bool:
-			return "boolean"
-		case types.String:
-			return "string"
-		}
-	}
-	// For other types (structs, interfaces, pointers, etc.), don't provide a hint
-	// This will use the default null initialization which is appropriate for object types
-	return ""
-}
-
-// writeMakeChannel writes the TypeScript code for creating a channel with $.makeChannel
-// It handles buffer size, zero value, and direction parameters
-func (c *GoToTSCompiler) writeMakeChannel(chanType *types.Chan, bufferArg ast.Expr) error {
-	c.tsw.WriteLiterally("$.makeChannel<")
-	c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
-	c.tsw.WriteLiterally(">(")
-
-	// If buffer size is provided, add it
-	if bufferArg != nil {
-		if err := c.WriteValueExpr(bufferArg); err != nil {
-			return fmt.Errorf("failed to write buffer size in makeChannel: %w", err)
-		}
-	} else {
-		// Default to 0 (unbuffered channel)
-		c.tsw.WriteLiterally("0")
-	}
-
-	c.tsw.WriteLiterally(", ") // Add comma for zero value argument
-
-	// Write the zero value for the channel's element type
-	if chanType.Elem().String() == "struct{}" {
-		c.tsw.WriteLiterally("{}")
-	} else {
-		c.WriteZeroValueForType(chanType.Elem())
-	}
-
-	// Add direction parameter
-	c.tsw.WriteLiterally(", ")
-
-	// Determine channel direction
-	switch chanType.Dir() {
-	case types.SendRecv:
-		c.tsw.WriteLiterally("'both'")
-	case types.SendOnly:
-		c.tsw.WriteLiterally("'send'")
-	case types.RecvOnly:
-		c.tsw.WriteLiterally("'receive'")
-	default:
-		c.tsw.WriteLiterally("'both'") // Default to bidirectional
-	}
-
-	c.tsw.WriteLiterally(")")
-	return nil
-}
-
-// writeMakeSlice writes the TypeScript code for creating a slice
-// It handles []byte special case and generic slice creation
-func (c *GoToTSCompiler) writeMakeSlice(sliceType *types.Slice, exp *ast.CallExpr) error {
-	goElemType := sliceType.Elem()
-
-	// Check if it's []byte
-	if c.isByteSliceType(sliceType) {
-		var lengthArg, capacityArg any
-		if len(exp.Args) >= 2 {
-			lengthArg = exp.Args[1]
-		}
-		if len(exp.Args) == 3 {
-			capacityArg = exp.Args[2]
-		}
-		return c.writeByteSliceCreation(lengthArg, capacityArg)
-	}
-
-	// Handle other slice types
-	var lengthArg, capacityArg any
-	if len(exp.Args) >= 2 {
-		lengthArg = exp.Args[1]
-	}
-	if len(exp.Args) == 3 {
-		capacityArg = exp.Args[2]
-	} else if len(exp.Args) > 3 {
-		return errors.New("makeSlice expects 2 or 3 arguments")
-	}
-	return c.writeGenericSliceCreation(goElemType, lengthArg, capacityArg)
-}
-
-// WriteCallExprMake handles make() function calls and translates them to TypeScript.
-// It handles channel, map, and slice creation with different type patterns including:
-// - Channel creation with different directions
-// - Map creation for various type patterns
-// - Slice creation with special handling for []byte, generic types, named types, instantiated generics, and selector expressions
-func (c *GoToTSCompiler) WriteCallExprMake(exp *ast.CallExpr) error {
-	// First check if we have a channel type
-	if typ := c.pkg.TypesInfo.TypeOf(exp.Args[0]); typ != nil {
-		if chanType, ok := typ.Underlying().(*types.Chan); ok {
-			// Handle channel creation: make(chan T, bufferSize) or make(chan T)
-			var bufferArg ast.Expr
-			if len(exp.Args) >= 2 {
-				bufferArg = exp.Args[1]
-			}
-			return c.writeMakeChannel(chanType, bufferArg)
-		}
-	}
-	// Handle make for slices: make([]T, len, cap) or make([]T, len)
-	if len(exp.Args) >= 1 {
-		// Handle map creation: make(map[K]V)
-		if mapType, ok := exp.Args[0].(*ast.MapType); ok {
-			c.tsw.WriteLiterally("$.makeMap<")
-			c.WriteTypeExpr(mapType.Key) // Write the key type
-			c.tsw.WriteLiterally(", ")
-			c.WriteTypeExpr(mapType.Value) // Write the value type
-			c.tsw.WriteLiterally(">()")
-			return nil // Handled make for map
-		}
-
-		// Handle slice creation
-		if _, ok := exp.Args[0].(*ast.ArrayType); ok {
-			// Get the slice type information
-			sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
-			if sliceType == nil {
-				return errors.New("could not get type information for slice in make call")
-			}
-			goUnderlyingType, ok := sliceType.Underlying().(*types.Slice)
-			if !ok {
-				return errors.New("expected slice type for make call")
-			}
-
-			// Check if the element type is a generic type parameter
-			if _, isTypeParam := goUnderlyingType.Elem().(*types.TypeParam); isTypeParam {
-				// This is make([]E, n) where E is a type parameter
-				c.tsw.WriteLiterally("$.makeSlice<")
-				c.WriteGoType(goUnderlyingType.Elem(), GoTypeContextGeneral) // Write the element type parameter
-				c.tsw.WriteLiterally(">(")
-
-				if len(exp.Args) >= 2 {
-					if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
-						return err
-					}
-					if len(exp.Args) == 3 {
-						c.tsw.WriteLiterally(", ")
-						if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
-							return err
-						}
-					} else if len(exp.Args) > 3 {
-						return errors.New("makeSlice expects 2 or 3 arguments")
-					}
-				} else {
-					// If no length is provided, default to 0
-					c.tsw.WriteLiterally("0")
-				}
-				c.tsw.WriteLiterally(")")
-				return nil // Handled make for []E where E is type parameter
-			}
-
-			return c.writeMakeSlice(goUnderlyingType, exp)
-		}
-
-		// Handle generic type parameter make calls: make(S, len, cap) where S ~[]E
-		if ident, ok := exp.Args[0].(*ast.Ident); ok {
-			// Check if this identifier refers to a type parameter
-			if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
-				if typeName, isTypeName := obj.(*types.TypeName); isTypeName {
-					if typeParam, isTypeParam := typeName.Type().(*types.TypeParam); isTypeParam {
-						// Check if the type parameter is constrained to slice types
-						constraint := typeParam.Constraint()
-						if constraint != nil {
-							underlying := constraint.Underlying()
-							if iface, isInterface := underlying.(*types.Interface); isInterface {
-								// Check if the constraint includes slice types
-								// For constraints like ~[]E, we need to look at the type terms
-								if hasSliceConstraint(iface) {
-									// This is a generic slice type parameter
-									// We need to determine the element type from the constraint
-									elemType := getSliceElementTypeFromConstraint(iface)
-									if elemType != nil {
-										// Check if it's make(S, ...) where S constrains to []byte
-										if c.isByteSliceType(types.NewSlice(elemType)) {
-											var lengthArg, capacityArg any
-											if len(exp.Args) >= 2 {
-												lengthArg = exp.Args[1]
-											}
-											if len(exp.Args) == 3 {
-												capacityArg = exp.Args[2]
-											}
-											return c.writeByteSliceCreation(lengthArg, capacityArg)
-										}
-
-										var lengthArg, capacityArg any
-										if len(exp.Args) >= 2 {
-											lengthArg = exp.Args[1]
-										}
-										if len(exp.Args) == 3 {
-											capacityArg = exp.Args[2]
-										} else if len(exp.Args) > 3 {
-											return errors.New("makeSlice expects 2 or 3 arguments")
-										}
-										return c.writeGenericSliceCreation(elemType, lengthArg, capacityArg)
-									}
-								}
-							}
-						}
-					} else {
-						// Handle named types with slice underlying types: make(NamedSliceType, len, cap)
-						namedType := typeName.Type()
-						if sliceType, isSlice := namedType.Underlying().(*types.Slice); isSlice {
-							return c.writeMakeSlice(sliceType, exp)
-						}
-
-						// Handle named types with map underlying types: make(NamedMapType)
-						if mapType, isMap := namedType.Underlying().(*types.Map); isMap {
-							c.tsw.WriteLiterally("$.makeMap<")
-							c.WriteGoType(mapType.Key(), GoTypeContextGeneral) // Write the key type
-							c.tsw.WriteLiterally(", ")
-							c.WriteGoType(mapType.Elem(), GoTypeContextGeneral) // Write the value type
-							c.tsw.WriteLiterally(">()")
-							return nil // Handled make for named map type
-						}
-
-						// Handle named types with channel underlying types: make(NamedChannelType, bufferSize)
-						if chanType, isChan := namedType.Underlying().(*types.Chan); isChan {
-							var bufferArg ast.Expr
-							if len(exp.Args) >= 2 {
-								bufferArg = exp.Args[1]
-							}
-							return c.writeMakeChannel(chanType, bufferArg)
-						}
-					}
-				}
-			}
-		}
-	}
-	// Handle instantiated generic types: make(GenericType[TypeArg], ...)
-	// This handles cases like: make(Ints[int64]) where Ints[T] is a generic type
-	if indexExpr, ok := exp.Args[0].(*ast.IndexExpr); ok {
-		// Get the type information for the instantiated generic type
-		if typ := c.pkg.TypesInfo.TypeOf(indexExpr); typ != nil {
-			// Check the underlying type of the instantiated generic type
-			underlying := typ.Underlying()
-
-			// Handle instantiated generic map types: make(GenericMap[K, V])
-			if mapType, isMap := underlying.(*types.Map); isMap {
-				c.tsw.WriteLiterally("$.makeMap<")
-				c.WriteGoType(mapType.Key(), GoTypeContextGeneral) // Write the key type
-				c.tsw.WriteLiterally(", ")
-				c.WriteGoType(mapType.Elem(), GoTypeContextGeneral) // Write the value type
-				c.tsw.WriteLiterally(">()")
-				return nil // Handled make for instantiated generic map type
-			}
-
-			// Handle instantiated generic slice types: make(GenericSlice[T], len, cap)
-			if sliceType, isSlice := underlying.(*types.Slice); isSlice {
-				return c.writeMakeSlice(sliceType, exp)
-			}
-
-			// Handle instantiated generic channel types: make(GenericChannel[T], bufferSize)
-			if chanType, isChan := underlying.(*types.Chan); isChan {
-				var bufferArg ast.Expr
-				if len(exp.Args) >= 2 {
-					bufferArg = exp.Args[1]
-				}
-				return c.writeMakeChannel(chanType, bufferArg)
-			}
-		}
-	}
-	// Handle selector expressions: make(pkg.TypeName, ...)
-	// This handles cases like: make(fstest.MapFS) where fstest.MapFS is map[string]*MapFile
-	if selectorExpr, ok := exp.Args[0].(*ast.SelectorExpr); ok {
-		// Get the type information for the selector expression
-		if typ := c.pkg.TypesInfo.TypeOf(selectorExpr); typ != nil {
-			// Check the underlying type of the selector expression
-			underlying := typ.Underlying()
-
-			// Handle selector expression map types: make(pkg.MapType)
-			if mapType, isMap := underlying.(*types.Map); isMap {
-				c.tsw.WriteLiterally("$.makeMap<")
-				c.WriteGoType(mapType.Key(), GoTypeContextGeneral) // Write the key type
-				c.tsw.WriteLiterally(", ")
-				c.WriteGoType(mapType.Elem(), GoTypeContextGeneral) // Write the value type
-				c.tsw.WriteLiterally(">()")
-				return nil // Handled make for selector expression map type
-			}
-
-			// Handle selector expression slice types: make(pkg.SliceType, len, cap)
-			if sliceType, isSlice := underlying.(*types.Slice); isSlice {
-				return c.writeMakeSlice(sliceType, exp)
-			}
-
-			// Handle selector expression channel types: make(pkg.ChannelType, bufferSize)
-			if chanType, isChan := underlying.(*types.Chan); isChan {
-				var bufferArg ast.Expr
-				if len(exp.Args) >= 2 {
-					bufferArg = exp.Args[1]
-				}
-				return c.writeMakeChannel(chanType, bufferArg)
-			}
-		}
-	}
-	// Fallthrough for unhandled make calls (e.g., channels)
-	return errors.New("unhandled make call")
-}