fix: Add variadic parameter support and fix type conversion functions

- Add IsVariadic property to ParameterSymbol for params array handling
- Update CachedModuleDiscovery to extract element type from variadic parameters
- Update overload resolution in TypeChecker to handle variadic functions
  - Filter candidates properly considering variadic arg count (0+ args)
  - Type check variadic args against element type, not array type
- Fix code generation to treat builtin functions as invocations, not constructors
  - int(x), str(x), etc. now emit function calls, not 'new' expressions
- Fix SymbolTable to not add function symbols that shadow type names
  - Prevents int function from overwriting int type in symbol table

This fixes:
- print() accepting any number of arguments (variadic)
- int(), float(), str() type conversion functions working properly
- Builtin function overload resolution with multiple candidates

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: antonsynd

src/Sharpy.Compiler/CodeGen/RoslynEmitter.Expressions.cs

@@ -134,18 +134,24 @@ private ExpressionSyntax GenerateCall(FunctionCall call)
 
         if (call.Function is Identifier funcName)
         {
+            // Check if this is a builtin function call (e.g., int(), str(), print(), len(), etc.)
+            // Builtin functions are always invocation expressions, never constructor calls.
+            var isBuiltinFunc = _context.IsBuiltinFunction(funcName.Name);
+
             // Check if this is a type instantiation (calling a class or struct constructor)
             // We check both:
             // 1. The _classNames and _structNames sets (populated during type declaration generation)
             // 2. The symbol table (for testing and imported types)
+            // BUT: If it's a builtin function, it's NOT a type instantiation (e.g., int(x) is a conversion function)
             var symbol = _context.LookupSymbol(funcName.Name);
-            var isTypeInstantiation = _classNames.Contains(funcName.Name) ||
-                                     _structNames.Contains(funcName.Name) ||
-                                     (symbol is TypeSymbol typeSymbol &&
-                                      (typeSymbol.TypeKind == Semantic.TypeKind.Class ||
-                                       typeSymbol.TypeKind == Semantic.TypeKind.Struct));
-
-            var name = _context.IsBuiltinFunction(funcName.Name)
+            var isTypeInstantiation = !isBuiltinFunc &&
+                                     (_classNames.Contains(funcName.Name) ||
+                                      _structNames.Contains(funcName.Name) ||
+                                      (symbol is TypeSymbol typeSymbol &&
+                                       (typeSymbol.TypeKind == Semantic.TypeKind.Class ||
+                                        typeSymbol.TypeKind == Semantic.TypeKind.Struct)));
+
+            var name = isBuiltinFunc
                 ? $"global::Sharpy.Core.Exports.{NameMangler.ToPascalCase(funcName.Name)}"
                 : NameMangler.ToPascalCase(funcName.Name);
 

src/Sharpy.Compiler/Discovery/CachedModuleDiscovery.cs

@@ -116,16 +116,34 @@ private FunctionSymbol ConvertToFunctionSymbol(FunctionSignature signature, stri
                 .Select(p => new ParameterSymbol
                 {
                     Name = p.Name,
-                    Type = ConvertTypeSignature(p.Type),
+                    // For variadic parameters, extract the element type from list[T] -> T
+                    Type = p.IsVariadic ? GetVariadicElementType(p.Type) : ConvertTypeSignature(p.Type),
                     HasDefault = p.HasDefault,
                     // Note: DefaultValue Expression reconstruction is simplified
-                    DefaultValue = null  // TODO: Reconstruct from cached string
+                    DefaultValue = null,  // TODO: Reconstruct from cached string
+                    IsVariadic = p.IsVariadic
                 })
                 .ToList(),
             AccessLevel = AccessLevel.Public
         };
     }
 
+    /// <summary>
+    /// Extract the element type from a variadic parameter's type signature.
+    /// Variadic parameters are stored as list[T] but we need just T for type checking.
+    /// </summary>
+    private SemanticType GetVariadicElementType(TypeSignature typeSignature)
+    {
+        // Variadic parameters are stored as list[T] (mapped from T[])
+        // We need to extract T
+        if (typeSignature.IsGeneric && typeSignature.Name.StartsWith("list") && typeSignature.TypeArguments.Count == 1)
+        {
+            return ConvertTypeSignature(typeSignature.TypeArguments[0]);
+        }
+        // Fallback to the full type if not a list
+        return ConvertTypeSignature(typeSignature);
+    }
+
     /// <summary>
     /// Convert a TypeSignature back to a SemanticType.
     /// </summary>

src/Sharpy.Compiler/Discovery/Caching/OverloadIndexBuilder.cs

@@ -72,8 +72,8 @@ private ModuleOverloads DiscoverModuleFunctions(Type exportType)
             .Where(m => !m.Name.StartsWith("set_"))
             .Where(m => !m.IsSpecialName)
             .Where(m => !m.IsGenericMethodDefinition)  // Skip generic methods for now
-            // Note: Type constructors (Int, Bool, Str, etc.) are included as they are
-            // valid builtin functions that can be called for type conversion.
+                                                       // Note: Type constructors (Int, Bool, Str, etc.) are included as they are
+                                                       // valid builtin functions that can be called for type conversion.
             .ToList();
 
         // Group by function name

src/Sharpy.Compiler/Semantic/Symbol.cs

@@ -113,6 +113,11 @@ public record ParameterSymbol
     public SemanticType Type { get; init; } = SemanticType.Unknown;
     public bool HasDefault { get; init; }
     public Expression? DefaultValue { get; init; }
+    /// <summary>
+    /// If true, this parameter accepts a variable number of arguments (params array).
+    /// The Type property contains the element type of the params array.
+    /// </summary>
+    public bool IsVariadic { get; init; }
 }
 
 /// <summary>

src/Sharpy.Compiler/Semantic/SymbolTable.cs

@@ -22,18 +22,22 @@ public SymbolTable(BuiltinRegistry builtins)
     private void PopulateBuiltins()
     {
         // Add builtin types
+        var typeNames = new HashSet<string>();
         foreach (var (name, typeSymbol) in _builtins.GetAllTypes())
         {
             _globalScope.Define(typeSymbol);
+            typeNames.Add(name);
         }
 
         // Add builtin functions (only add one symbol per function name, overload resolution happens later)
         // For functions with multiple overloads, only the first overload is added to the global scope.
         // The TypeChecker uses BuiltinRegistry.GetFunctionOverloads() for proper overload resolution.
+        // Skip functions that have the same name as types (e.g., int(), str(), bool()) - these are
+        // handled by TypeChecker which routes primitive type "constructor" calls to builtin function overloads.
         var addedFunctions = new HashSet<string>();
         foreach (var (name, funcSymbol) in _builtins.GetAllFunctions())
         {
-            if (!addedFunctions.Contains(name))
+            if (!addedFunctions.Contains(name) && !typeNames.Contains(name))
             {
                 _globalScope.Define(funcSymbol);
                 addedFunctions.Add(name);

src/Sharpy.Compiler/Semantic/TypeChecker.Expressions.cs

@@ -789,15 +789,25 @@ indexAccess.Object is Identifier genericTypeId &&
             }
 
             // Special handling for builtin functions with overloads
-            // If there is exactly one overload, it will be handled by the regular function symbol validation below.
+            // When there are multiple overloads, we need to perform overload resolution to find the right one.
+            // The funcSymbol from Lookup is just the first overload, which may not match the call.
+            // Only use builtin overloads if there's no user-defined function shadowing the builtin.
             var overloads = _symbolTable.BuiltinRegistry.GetFunctionOverloads(id.Name);
-            if (overloads != null && overloads.Count > 1)
+            var isBuiltinWithOverloads = overloads != null && overloads.Count > 1;
+            // If funcSymbol was found in symbol table AND it's one of the builtin overloads, use overload resolution
+            var needsOverloadResolution = isBuiltinWithOverloads &&
+                (funcSymbol == null || (funcSymbol != null && overloads!.Contains(funcSymbol)));
+            if (needsOverloadResolution)
             {
-                // First pass: filter by argument count (considering default parameters)
+                // First pass: filter by argument count (considering default parameters and variadic parameters)
                 var candidateOverloads = overloads.Where(o =>
                 {
-                    var requiredParams = o.Parameters.Count(p => !p.HasDefault);
+                    var requiredParams = o.Parameters.Count(p => !p.HasDefault && !p.IsVariadic);
+                    var hasVariadic = o.Parameters.Any(p => p.IsVariadic);
                     var totalParams = o.Parameters.Count;
+                    // Variadic functions can accept any number of arguments >= required
+                    if (hasVariadic)
+                        return totalArgCount >= requiredParams;
                     return totalArgCount >= requiredParams && totalArgCount <= totalParams;
                 }).ToList();
 
@@ -806,9 +816,30 @@ indexAccess.Object is Identifier genericTypeId &&
                 foreach (var overload in candidateOverloads)
                 {
                     bool typesMatch = true;
+                    var hasVariadic = overload.Parameters.Any(p => p.IsVariadic);
+                    var variadicParam = overload.Parameters.FirstOrDefault(p => p.IsVariadic);
+
                     for (int i = 0; i < argTypes.Count; i++)
                     {
-                        if (!IsAssignable(argTypes[i], overload.Parameters[i].Type))
+                        SemanticType expectedType;
+                        if (i < overload.Parameters.Count && !overload.Parameters[i].IsVariadic)
+                        {
+                            // Regular parameter
+                            expectedType = overload.Parameters[i].Type;
+                        }
+                        else if (variadicParam != null)
+                        {
+                            // Variadic parameter - all remaining args must match the element type
+                            expectedType = variadicParam.Type;
+                        }
+                        else
+                        {
+                            // Index out of bounds - shouldn't happen with valid candidates
+                            typesMatch = false;
+                            break;
+                        }
+
+                        if (!IsAssignable(argTypes[i], expectedType))
                         {
                             typesMatch = false;
                             break;
@@ -832,8 +863,11 @@ indexAccess.Object is Identifier genericTypeId &&
                     // No matching overload found
                     var expectedCounts = string.Join(" or ", overloads.Select(o =>
                     {
-                        var required = o.Parameters.Count(p => !p.HasDefault);
+                        var required = o.Parameters.Count(p => !p.HasDefault && !p.IsVariadic);
                         var total = o.Parameters.Count;
+                        var hasVariadic = o.Parameters.Any(p => p.IsVariadic);
+                        if (hasVariadic)
+                            return $"{required}+";
                         return required == total ? total.ToString() : $"{required}-{total}";
                     }).Distinct());
                     AddError($"Function '{id.Name}' expects {expectedCounts} arguments but got {totalArgCount}",