goscript 0.0.60 → 0.0.62

package/compiler/expr-call-builtins.go

@@ -25,6 +25,9 @@ var builtinFunctions = map[string]bool{
 	"recover": true,
 	"print":   true,
 	"println": true,
+	"min":     true,
+	"max":     true,
+	"clear":   true,
 }
 
 // writeBuiltinFunction handles built-in Go functions
@@ -34,7 +37,7 @@ func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string)
 		c.tsw.WriteLiterally("$.panic")
 		return true, nil
 	case "println":
-		c.tsw.WriteLiterally("console.log")
+		c.tsw.WriteLiterally("$.println")
 		return true, nil
 	case "len":
 		if len(exp.Args) != 1 {
@@ -89,6 +92,46 @@ func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string)
 		return true, nil
 	case "append":
 		return true, c.writeAppendCall(exp)
+	case "min":
+		if len(exp.Args) < 1 {
+			return true, errors.New("unhandled min call with no arguments")
+		}
+		c.tsw.WriteLiterally("Math.min(")
+		for i, arg := range exp.Args {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return true, fmt.Errorf("failed to write argument %d in min call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
+	case "max":
+		if len(exp.Args) < 1 {
+			return true, errors.New("unhandled max call with no arguments")
+		}
+		c.tsw.WriteLiterally("Math.max(")
+		for i, arg := range exp.Args {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return true, fmt.Errorf("failed to write argument %d in max call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
+	case "clear":
+		if len(exp.Args) != 1 {
+			return true, errors.Errorf("unhandled clear call with incorrect number of arguments: %d != 1", len(exp.Args))
+		}
+		c.tsw.WriteLiterally("$.clear(")
+		if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+			return true, fmt.Errorf("failed to write argument in clear call: %w", err)
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
 	case "byte":
 		if len(exp.Args) != 1 {
 			return true, errors.Errorf("unhandled byte call with incorrect number of arguments: %d != 1", len(exp.Args))
@@ -119,13 +162,16 @@ func (c *GoToTSCompiler) writeAppendCall(exp *ast.CallExpr) error {
 	}
 
 	// The remaining arguments are the elements to append
-	for i, arg := range exp.Args[1:] {
+	elemsToAppend := exp.Args[1:]
+	for i, arg := range elemsToAppend {
 		if i > 0 || len(exp.Args) > 1 {
 			c.tsw.WriteLiterally(", ")
 		}
 
-		// Special case: append([]byte, string...) should convert string to bytes
-		if exp.Ellipsis != token.NoPos && i == 0 { // This is the first element after slice and has ellipsis
+		// Handle ellipsis (spread) for the last argument: append(slice, elems...)
+		// The ellipsis can only appear on the last argument, so check if this is the last element
+		isLastElement := i == len(elemsToAppend)-1
+		if exp.Ellipsis != token.NoPos && isLastElement {
 			// Check if the slice is []byte and the argument is a string
 			sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
 			argType := c.pkg.TypesInfo.TypeOf(arg)
@@ -141,6 +187,16 @@ func (c *GoToTSCompiler) writeAppendCall(exp *ast.CallExpr) error {
 					continue
 				}
 			}
+
+			// For other slice types with ellipsis, use spread operator
+			// append(slice, anotherSlice...) -> $.append(slice, ...(anotherSlice || []))
+			// The || [] handles the case where anotherSlice is null (nil in Go)
+			c.tsw.WriteLiterally("...(")
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write spread argument in append call: %w", err)
+			}
+			c.tsw.WriteLiterally(" || [])")
+			continue
 		}
 
 		if err := c.WriteValueExpr(arg); err != nil {

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-type-conversion.go

@@ -18,14 +18,33 @@ func (c *GoToTSCompiler) writeNilConversion(exp *ast.CallExpr) (handled bool, er
 		return false, nil
 	}
 
-	// Handle nil pointer to struct type conversions: (*struct{})(nil)
-	if starExpr, isStarExpr := exp.Fun.(*ast.StarExpr); isStarExpr {
-		if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
-			c.tsw.WriteLiterally("null")
+	// Check if this is actually a type conversion, not a method/function call
+	// For type conversions, exp.Fun is a type expression (IsType() is true)
+	// For method calls like s.ptr.Swap(nil), exp.Fun is a selector expression (IsType() is false)
+	if tv, ok := c.pkg.TypesInfo.Types[exp.Fun]; !ok || !tv.IsType() {
+		// This is not a type conversion, let the normal call handling proceed
+		return false, nil
+	}
+
+	// Get the type being converted to
+	if typ := c.pkg.TypesInfo.TypeOf(exp.Fun); typ != nil {
+		// For pointer types, create a typed nil that preserves type information
+		if ptrType, ok := typ.(*types.Pointer); ok {
+			// Use a qualifier that returns the package name for local types
+			// This matches Go's reflect output format (e.g., "main.Stringer")
+			qualifier := func(pkg *types.Package) string {
+				if pkg == nil {
+					return ""
+				}
+				return pkg.Name()
+			}
+			typeName := types.TypeString(ptrType, qualifier)
+			c.tsw.WriteLiterallyf("$.typedNil(%q)", typeName)
 			return true, nil
 		}
 	}
 
+	// For non-pointer types (or if type info is unavailable), use plain null
 	c.tsw.WriteLiterally("null")
 	return true, nil
 }
@@ -141,8 +160,21 @@ func (c *GoToTSCompiler) writeStringConversion(exp *ast.CallExpr) error {
 
 	// Handle direct string(int32) conversion
 	if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
-		// Case 3a: Argument is already a string - no-op
+		// Case 3a: Argument is already a string - no-op (unless it's a named type with toString)
 		if c.isStringType(tv.Type) {
+			// Check if this is a named type from the reflect package (like StructTag)
+			// which is implemented as a class in TypeScript with a toString() method
+			if namedType, isNamed := tv.Type.(*types.Named); isNamed {
+				obj := namedType.Obj()
+				if obj != nil && obj.Pkg() != nil && obj.Pkg().Path() == "reflect" && obj.Name() == "StructTag" {
+					// Call toString() for reflect.StructTag
+					if err := c.WriteValueExpr(arg); err != nil {
+						return fmt.Errorf("failed to write argument for string(reflect.StructTag) conversion: %w", err)
+					}
+					c.tsw.WriteLiterally(".toString()")
+					return nil
+				}
+			}
 			// Translate string(stringValue) to stringValue (no-op)
 			if err := c.WriteValueExpr(arg); err != nil {
 				return fmt.Errorf("failed to write argument for string(string) no-op conversion: %w", err)

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`)
@@ -62,7 +61,8 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			// For built-ins that don't return early, write the arguments
 			if funIdent.String() != "new" && funIdent.String() != "close" && funIdent.String() != "make" &&
 				funIdent.String() != "string" && funIdent.String() != "append" && funIdent.String() != "byte" &&
-				funIdent.String() != "int" {
+				funIdent.String() != "int" && funIdent.String() != "min" && funIdent.String() != "max" &&
+				funIdent.String() != "clear" {
 				return c.writeCallArguments(exp)
 			}
 			return nil
@@ -97,6 +97,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)
@@ -109,14 +118,26 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		}
 		c.tsw.WriteLiterally(")")
 	} else {
+		// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+		// and if the inner call is async, wrap it in parentheses
+		innerCallExpr, isCallExpr := expFun.(*ast.CallExpr)
+		needsParens := isCallExpr && c.isCallExprAsync(innerCallExpr)
+
+		if needsParens {
+			c.tsw.WriteLiterally("(")
+		}
+
 		// Not an identifier (e.g., method call on a value, function call result)
 		if err := c.WriteValueExpr(expFun); err != nil {
 			return fmt.Errorf("failed to write method expression in call: %w", err)
 		}
 
-		// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+		if needsParens {
+			c.tsw.WriteLiterally(")")
+		}
+
 		// Add non-null assertion since the returned function could be null
-		if _, isCallExpr := expFun.(*ast.CallExpr); isCallExpr {
+		if isCallExpr {
 			c.tsw.WriteLiterally("!")
 		} else {
 			c.addNonNullAssertion(expFun)
@@ -246,35 +267,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
@@ -122,10 +130,23 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 
 	// Fallback / Normal Case (e.g., obj.Field, pkg.Var, method calls)
 	// WriteValueExpr handles adding .value for the base variable itself if it's varrefed.
+
+	// Check if the base expression is an async call - if so, we need to wrap it in parentheses
+	// so that await binds correctly: (await asyncFn()).method instead of await asyncFn().method
+	needsParensForAsync := false
+	if callExpr, isCall := exp.X.(*ast.CallExpr); isCall && c.isCallExprAsync(callExpr) {
+		needsParensForAsync = true
+		c.tsw.WriteLiterally("(")
+	}
+
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write selector base expression: %w", err)
 	}
 
+	if needsParensForAsync {
+		c.tsw.WriteLiterally(")")
+	}
+
 	// Add null assertion for selector expressions when accessing fields/methods on nullable types
 	// In Go, accessing fields or calling methods on nil pointers/interfaces panics, so we should throw in TypeScript
 	baseType := c.pkg.TypesInfo.TypeOf(exp.X)
@@ -189,6 +210,55 @@ 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")
+		}
+
+		// Get the method parameters to forward them
+		params := sig.Params()
+		paramNames := make([]string, params.Len())
+		for i := 0; i < params.Len(); i++ {
+			paramNames[i] = fmt.Sprintf("_p%d", i)
+		}
+
+		// Generate: ((_p0: type0, _p1: type1, ...) => TypeName_MethodName(receiverValue, _p0, _p1, ...))
+		c.tsw.WriteLiterally("((")
+		for i, name := range paramNames {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally(name)
+			c.tsw.WriteLiterally(": ")
+			c.WriteGoType(params.At(i).Type(), GoTypeContextGeneral)
+		}
+		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)
+		}
+		for _, name := range paramNames {
+			c.tsw.WriteLiterally(", ")
+			c.tsw.WriteLiterally(name)
+		}
+		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

@@ -26,13 +26,23 @@ func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
 			// Check if this is a package selector (e.g., os.FileInfo)
 			if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
 				if _, isPkg := obj.(*types.PkgName); isPkg {
-					// This is a package.Type reference - write the qualified name
+					// This is a package.Type reference
+					typ := c.pkg.TypesInfo.TypeOf(a)
+
+					// Check if this is an interface type and add null | prefix
+					if typ != nil {
+						if _, isInterface := typ.Underlying().(*types.Interface); isInterface {
+							c.tsw.WriteLiterally("null | ")
+						}
+					}
+
+					// Write the qualified name
 					c.tsw.WriteLiterally(pkgIdent.Name)
 					c.tsw.WriteLiterally(".")
 					c.tsw.WriteLiterally(selectorExpr.Sel.Name)
 
 					// Check if this is a function type and add | null
-					if typ := c.pkg.TypesInfo.TypeOf(a); typ != nil {
+					if typ != nil {
 						if namedType, isNamed := typ.(*types.Named); isNamed {
 							if _, isSignature := namedType.Underlying().(*types.Signature); isSignature {
 								c.tsw.WriteLiterally(" | null")
@@ -134,11 +144,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: