refactor: remove collections.namedtuple, add helpful SPY0432 error (#508)

collections.namedtuple is redundant with Sharpy's native named tuples
(`type Point = tuple[x: float, y: float]`) and @DataClass, while being
strictly inferior — untyped fields (object), different C# target (record
vs ValueTuple), and string-based field names violating Axiom 3.

Remove the entire implementation:
- Delete Sharpy.Core/Collections/NamedTuple.cs runtime stub
- Remove TryCheckNamedTupleDefinition from TypeChecker
- Remove SemanticInfo namedtuple tracking (MarkAsNamedTupleDefinition)
- Remove GenerateNamedTupleRecord from RoslynEmitter
- Remove ModuleLevelValidator namedtuple exemption
- Remove ISemanticQuery.GetNamedTupleDefinition

Add SPY0432 error in ImportResolver that fires on `from collections
import namedtuple` with a message suggesting native alternatives.

Convert match_named_tuple fixture from .expected to .error test.
Delete namedtuple_basic and namedtuple_print fixtures.

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

Author: antonsynd

src/Sharpy.Compiler.Tests/Integration/TestFixtures/expressions/namedtuple_basic.expected

@@ -0,0 +1 @@
+collections.namedtuple is not supported in Sharpy

src/Sharpy.Compiler.Tests/Integration/TestFixtures/expressions/namedtuple_basic.spy

@@ -502,94 +502,11 @@ private MemberDeclarationSyntax GenerateReExportProperty(string localName, Varia
             VariableDeclaration varDecl => GenerateModuleLevelField(varDecl),
             TypeAlias => null,  // Type aliases are compile-time only, no C# output
             ReturnStatement ret => GenerateReturn(ret),
-            Assignment assign when _context.SemanticInfo?.GetNamedTupleDefinition(assign) is TypeSymbol ntSym
-                => GenerateNamedTupleRecord(ntSym),
             Assignment assign => GenerateAssignment(assign),
             ImportStatement => null,       // Imports are resolved at semantic level, no C# output
             FromImportStatement => null,   // Imports are resolved at semantic level, no C# output
             _ => EmitUnrecognizedStatementDiagnostic(stmt)
         };
     }
 
-    /// <summary>
-    /// Generates a C# record class for a namedtuple definition.
-    /// Example: Point = namedtuple("Point", ["x", "y"]) generates:
-    ///   public record Point(object X, object Y)
-    ///   {
-    ///       public override string ToString() => $"Point(x={X}, y={Y})";
-    ///   }
-    /// </summary>
-    private RecordDeclarationSyntax GenerateNamedTupleRecord(TypeSymbol typeSymbol)
-    {
-        var typeName = NameMangler.Transform(typeSymbol.Name, NameContext.Type);
-
-        // Generate primary constructor parameters from fields
-        var parameters = typeSymbol.Fields.Select(field =>
-        {
-            var paramType = _typeMapper.MapSemanticType(field.Type ?? SemanticType.Object);
-            var paramName = NameMangler.Transform(field.Name, NameContext.Field);
-            return Parameter(Identifier(paramName)).WithType(paramType);
-        }).ToArray();
-
-        var parameterList = ParameterList(SeparatedList(parameters));
-
-        // Build ToString() override using interpolated string: $"Point(x={X}, y={Y})"
-        var toStringMethod = MethodDeclaration(
-                PredefinedType(Token(SyntaxKind.StringKeyword)),
-                "ToString")
-            .WithModifiers(TokenList(
-                Token(SyntaxKind.PublicKeyword),
-                Token(SyntaxKind.OverrideKeyword)))
-            .WithExpressionBody(ArrowExpressionClause(
-                InterpolatedStringExpression(Token(SyntaxKind.InterpolatedStringStartToken))
-                    .WithContents(BuildNamedTupleToStringContents(typeSymbol))))
-            .WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
-
-        var record = RecordDeclaration(Token(SyntaxKind.RecordKeyword), typeName)
-            .WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
-            .WithParameterList(parameterList)
-            .WithOpenBraceToken(Token(SyntaxKind.OpenBraceToken))
-            .WithMembers(SingletonList<MemberDeclarationSyntax>(toStringMethod))
-            .WithCloseBraceToken(Token(SyntaxKind.CloseBraceToken));
-
-        return record;
-    }
-
-    /// <summary>
-    /// Builds the interpolated string contents for namedtuple ToString():
-    /// "Point(x={X}, y={Y})" using SyntaxFactory nodes.
-    /// </summary>
-    private static SyntaxList<InterpolatedStringContentSyntax> BuildNamedTupleToStringContents(
-        TypeSymbol typeSymbol)
-    {
-        var contents = new List<InterpolatedStringContentSyntax>();
-
-        // Leading text: "TypeName("
-        contents.Add(InterpolatedStringText(
-            Token(TriviaList(), SyntaxKind.InterpolatedStringTextToken,
-                $"{typeSymbol.Name}(", $"{typeSymbol.Name}(", TriviaList())));
-
-        for (int i = 0; i < typeSymbol.Fields.Count; i++)
-        {
-            var field = typeSymbol.Fields[i];
-            var originalName = field.Name;
-            var propertyName = NameMangler.Transform(field.Name, NameContext.Field);
-
-            // "x=" prefix (with ", " separator for non-first fields)
-            var prefix = i > 0 ? $", {originalName}=" : $"{originalName}=";
-            contents.Add(InterpolatedStringText(
-                Token(TriviaList(), SyntaxKind.InterpolatedStringTextToken,
-                    prefix, prefix, TriviaList())));
-
-            // {PropertyName} interpolation
-            contents.Add(Interpolation(IdentifierName(propertyName)));
-        }
-
-        // Closing ")"
-        contents.Add(InterpolatedStringText(
-            Token(TriviaList(), SyntaxKind.InterpolatedStringTextToken,
-                ")", ")", TriviaList())));
-
-        return List(contents);
-    }
 }

src/Sharpy.Compiler.Tests/Integration/TestFixtures/expressions/namedtuple_print.expected

@@ -417,7 +417,8 @@ public static class Validation
         // Access modifier decorator validation (SPY0430-SPY0431)
         public const string ConflictingAccessModifiers = "SPY0430"; // Active
         public const string AccessModifierOnDunder = "SPY0431";     // Active
-        // SPY0432-SPY0449: Reserved for future validation errors
+        public const string NamedtupleNotSupported = "SPY0432";     // Active
+        // SPY0433-SPY0449: Reserved for future validation errors
 
         #endregion
 

src/Sharpy.Compiler.Tests/Integration/TestFixtures/expressions/namedtuple_print.spy

@@ -1341,6 +1341,17 @@ private static Dictionary<string, DiagnosticExplanation> BuildExplanations()
             "class Foo:\n    @private\n    def __init__(self) -> None:\n        ...",
             "Remove the access modifier decorator from the dunder method:\nclass Foo:\n    def __init__(self) -> None:\n        ...");
 
+        // ── Validation errors: Unsupported Python constructs (SPY0432) ──
+
+        Add(dict, DiagnosticCodes.Validation.NamedtupleNotSupported,
+            "collections.namedtuple is not supported",
+            "Validation",
+            "Sharpy does not support collections.namedtuple. Use native named tuples " +
+            "(type aliases with named fields) or @dataclass for data-holding classes instead.",
+            "from collections import namedtuple\nPoint = namedtuple(\"Point\", [\"x\", \"y\"])",
+            "Use native named tuples:\ntype Point = tuple[x: float, y: float]\n\n" +
+            "Or use @dataclass:\n@dataclass\nclass Point:\n    x: float\n    y: float");
+
         // ── Validation warnings: Deprecation (SPY0464) ─────────────────
 
         Add(dict, DiagnosticCodes.Validation.DeprecatedBodylessSyntax,

src/Sharpy.Compiler.Tests/Integration/TestFixtures/pattern_matching/match_named_tuple.error

@@ -338,6 +338,43 @@ public void ResolveAllImports(Module module, SymbolTable symbolTable, string? cu
             _logger.LogDebug($"[ImportResolver]   Current module: {Path.GetFileName(_currentModulePath)}");
         }
 
+        // Helpful error for unsupported Python constructs: intercept before module resolution
+        // so the error fires even when the module has no remaining exported functions.
+        if (fromImport.Module == "collections" && !fromImport.ImportAll)
+        {
+            foreach (var alias in fromImport.Names)
+            {
+                if (alias.Name == "namedtuple")
+                {
+                    AddError(
+                        "collections.namedtuple is not supported in Sharpy. " +
+                        "Use 'type Point = tuple[x: float, y: float]' for named tuples, " +
+                        "or '@dataclass class Point: x: float; y: float' for data classes.",
+                        alias.LineStart, alias.ColumnStart,
+                        code: DiagnosticCodes.Validation.NamedtupleNotSupported,
+                        span: alias.Span ?? fromImport.Span);
+
+                    // Create error recovery module to suppress cascading errors
+                    var errorRecoveryModule = CreateErrorRecoveryModule(
+                        fromImport.Module, fromImport.LineStart, fromImport.ColumnStart);
+                    foreach (var importAlias in fromImport.Names)
+                    {
+                        var targetName = importAlias.AsName ?? importAlias.Name;
+                        errorRecoveryModule.Exports[targetName] = CreateErrorRecoverySymbol(
+                            targetName, fromImport.Module, importAlias.LineStart, importAlias.ColumnStart);
+                        _diagnostics.MarkAsRootCause(targetName);
+                    }
+                    return new ModuleInfo
+                    {
+                        Path = $"<error-recovery:{fromImport.Module}>",
+                        Module = null!,
+                        ExportedSymbols = errorRecoveryModule.Exports,
+                        IsNetModule = false
+                    };
+                }
+            }
+        }
+
         // First, try to resolve as .NET assembly module
         var moduleInfo = TryResolveNetModule(fromImport.Module, fromImport.LineStart, fromImport.ColumnStart);