fix(compiler): fix variadic string iteration and test expectations

- Fix for-loop codegen: don't wrap variadic string[] params with
  StringHelpers.Iterate() — track variadic param names in
  _currentVariadicParams set, populated via ResetMethodScope(func)
- Fix elif condition test: strings are now truth-testable (Python
  semantics), so test uses tuple (non-truthable) instead of string
- Update 48 compiler test expectations for str→string migration
- Regenerate C# snapshot files
- Delete n-string test fixtures (3 .spy + 3 .expected files)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: antonsynd

src/Sharpy.Compiler.Tests/Semantic/SemanticAnalyzerNegativeTests.cs

@@ -1072,18 +1072,20 @@ def foo(x: int):
     [Fact]
     public void ChecksElifConditionType()
     {
+        // String literals are truth-testable (Python semantics: `if "nonempty":` is valid).
+        // Use a non-truth-testable type (tuple literal) to test elif condition type checking.
         var source = @"
 def foo():
     x: int = 1
     if x > 10:
         print(""high"")
-    elif ""not a bool"":  # elif condition must be boolean
+    elif (1, 2):  # elif condition must be boolean — tuples are not truth-testable
         print(""medium"")
 ";
         var (module, _, _, _, typeChecker) = CompileAndCheck(source);
         typeChecker.CheckModule(module, isEntryPoint: false);
 
-        // Elif condition type checking
+        // Elif condition type checking — tuple is not truth-testable
         typeChecker.Diagnostics.GetErrors().Should().Contain(e => e.Message.Contains("boolean"));
     }
 

src/Sharpy.Compiler/CodeGen/RoslynEmitter.ClassMembers.Methods.cs

@@ -20,7 +20,7 @@ internal partial class RoslynEmitter
     private MethodDeclarationSyntax GenerateClassMethod(FunctionDef func)
     {
         // Clear declared variables and version tracking for new method scope
-        ResetMethodScope();
+        ResetMethodScope(func);
 
         // Check if this method is a generator and/or async
         using var _gen = SetGeneratorScope(_context.SemanticInfo?.IsGenerator(func) == true);

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

@@ -1147,6 +1147,16 @@ private StatementSyntax GenerateVariableDeclaration(VariableDeclaration varDecl)
             .WithModifiers(modifiers);
     }
 
+    /// <summary>
+    /// Checks if the expression is a reference to a variadic parameter (*args).
+    /// Variadic parameters have semantic type T but are params T[] at C# level,
+    /// so they should not be wrapped with StringHelpers.Iterate().
+    /// </summary>
+    private bool IsVariadicParameterReference(Expression expr)
+    {
+        return expr is Identifier ident && _currentVariadicParams.Contains(ident.Name);
+    }
+
     private static bool IsCompileTimeLiteral(Expression? expr)
     {
         // Check if the expression is a compile-time literal that can be used with C# const
@@ -1571,8 +1581,10 @@ private StatementSyntax GenerateFor(ForStatement forStmt)
         var iterator = GenerateExpression(forStmt.Iterator);
 
         // String iteration: `for c in s:` → `foreach (var c in StringHelpers.Iterate(s))`
-        // Yields string elements (single-character strings), not char
-        if (iteratorType == SemanticType.Str)
+        // Yields string elements (single-character strings), not char.
+        // Skip for variadic parameters (*args: str) — those are string[] at C# level,
+        // and iterating over string[] already yields string elements.
+        if (iteratorType == SemanticType.Str && !IsVariadicParameterReference(forStmt.Iterator))
         {
             iterator = InvocationExpression(
                 MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,

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

@@ -21,7 +21,7 @@ private MethodDeclarationSyntax GenerateFunctionDeclaration(FunctionDef func)
         _cancellationToken.ThrowIfCancellationRequested();
 
         // Clear declared variables and version tracking for new function scope
-        ResetMethodScope();
+        ResetMethodScope(func);
 
         // Pre-scan the function body to collect all variable names that will be declared.
         // This enables us to avoid generating versioned names (x_1, x_2) that collide

src/Sharpy.Compiler/CodeGen/RoslynEmitter.cs

@@ -83,6 +83,12 @@ internal partial class RoslynEmitter
     // CodeGenInfo.IsStringEnum (for string enums). This information is populated
     // during semantic analysis.
 
+    /// <summary>
+    /// Tracks the Sharpy names of variadic parameters (*args) in the current function scope.
+    /// Used to avoid wrapping variadic string[] params with StringHelpers.Iterate() in for-loops.
+    /// </summary>
+    private readonly HashSet<string> _currentVariadicParams = new();
+
     private readonly DunderCodeGenRegistry _dunderRegistry;
     private readonly Dictionary<string, InterfaceDef> _interfaceDefinitions = new(); // Track interface definitions for abstract class stub generation
     private int _tempVarCounter = 0;
@@ -312,13 +318,25 @@ private ScopeSnapshot SaveScope()
     /// Clears all local scope tracking fields for a new method/function scope.
     /// Call at the start of each method, function, property accessor, or operator body.
     /// </summary>
-    private void ResetMethodScope()
+    private void ResetMethodScope(FunctionDef? funcDef = null)
     {
         _declaredVariables.Clear();
         _variableVersions.Clear();
         _constVariables.Clear();
         _sourceVariableNames.Clear();
+        _currentVariadicParams.Clear();
         _narrowing.Reset();
+
+        // Track variadic parameter names so codegen can distinguish
+        // `for x in str_var:` (needs Iterate) from `for x in variadic_params:` (already T[])
+        if (funcDef != null)
+        {
+            foreach (var p in funcDef.Parameters)
+            {
+                if (p.IsVariadic)
+                    _currentVariadicParams.Add(p.Name);
+            }
+        }
     }
 
     /// <summary>