fix: handle for/while ElseBody in generator traversals and remove stale symbol fallback

- ContainsYield() now checks ForStatement.ElseBody and WhileStatement.ElseBody,
  ensuring yield in for/while else blocks correctly marks the function as a generator.
- FindReturnWithValue() now checks ForStatement.ElseBody and WhileStatement.ElseBody,
  ensuring return-with-value in those blocks triggers SPY0267.
- Removed stale functionSymbol fallback in generator symbol update path; replaced
  with Debug.Assert + null guard to surface bugs instead of silently succeeding.
- Removed redundant Shared. namespace qualifier in DunderDetector call.

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

Author: antonsynd

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

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using Sharpy.Compiler.Parser.Ast;
 using Sharpy.Compiler.Diagnostics;
 using Sharpy.Compiler.Logging;
@@ -387,23 +388,26 @@ private void CheckFunction(FunctionDef functionDef)
                 // reference stored in ProtocolMethods/OperatorMethods.
                 // For top-level functions, fall back to the symbol table.
                 var currentSymbol = _currentClass?.Methods.FirstOrDefault(m => m.Name == functionDef.Name && m.DeclarationLine == functionDef.LineStart)
-                    ?? _symbolTable.Lookup(functionDef.Name) as FunctionSymbol
-                    ?? functionSymbol;
-                currentSymbol.IsGenerator = true;
-
-                // For non-dunder generators (standalone functions and regular class methods),
-                // wrap the return type so callers see IEnumerable<T> instead of T.
-                // Dunder methods (__iter__, __reversed__) keep their element type as ReturnType
-                // because SynthesisAnalyzer reads it to determine interface type arguments,
-                // and codegen handles the wrapping independently via AST annotations.
-                var isDunder = Shared.DunderDetector.IsDunderMethod(functionDef.Name);
-                if (!isDunder && currentSymbol.ReturnType is not (VoidType or UnknownType))
+                    ?? _symbolTable.Lookup(functionDef.Name) as FunctionSymbol;
+                Debug.Assert(currentSymbol != null, $"Generator function '{functionDef.Name}' not found in Methods list or SymbolTable");
+                if (currentSymbol != null)
                 {
-                    currentSymbol.ReturnType = new GenericType
+                    currentSymbol.IsGenerator = true;
+
+                    // For non-dunder generators (standalone functions and regular class methods),
+                    // wrap the return type so callers see IEnumerable<T> instead of T.
+                    // Dunder methods (__iter__, __reversed__) keep their element type as ReturnType
+                    // because SynthesisAnalyzer reads it to determine interface type arguments,
+                    // and codegen handles the wrapping independently via AST annotations.
+                    var isDunder = DunderDetector.IsDunderMethod(functionDef.Name);
+                    if (!isDunder && currentSymbol.ReturnType is not (VoidType or UnknownType))
                     {
-                        Name = "IEnumerable",
-                        TypeArguments = new List<SemanticType> { currentSymbol.ReturnType }
-                    };
+                        currentSymbol.ReturnType = new GenericType
+                        {
+                            Name = "IEnumerable",
+                            TypeArguments = new List<SemanticType> { currentSymbol.ReturnType }
+                        };
+                    }
                 }
             }
         }
@@ -793,11 +797,15 @@ private static bool ContainsYield(System.Collections.Immutable.ImmutableArray<St
             {
                 if (ContainsYield(whileStmt.Body))
                     return true;
+                if (ContainsYield(whileStmt.ElseBody))
+                    return true;
             }
             else if (stmt is ForStatement forStmt)
             {
                 if (ContainsYield(forStmt.Body))
                     return true;
+                if (ContainsYield(forStmt.ElseBody))
+                    return true;
             }
             else if (stmt is TryStatement tryStmt)
             {

src/Sharpy.Compiler/Semantic/Validation/GeneratorValidator.cs

@@ -144,12 +144,18 @@ private void ValidateGeneratorFunction(FunctionDef funcDef, SemanticContext cont
                 found = FindReturnWithValue(whileStmt.Body);
                 if (found != null)
                     return found;
+                found = FindReturnWithValue(whileStmt.ElseBody);
+                if (found != null)
+                    return found;
             }
             else if (stmt is ForStatement forStmt)
             {
                 found = FindReturnWithValue(forStmt.Body);
                 if (found != null)
                     return found;
+                found = FindReturnWithValue(forStmt.ElseBody);
+                if (found != null)
+                    return found;
             }
             else if (stmt is TryStatement tryStmt)
             {