fix(semantic+codegen): complete __getitem__/__setitem__ support for user-defined types (#279)

- Fix TypeInferenceService to check ProtocolMethods (not just OperatorMethods) for
  __getitem__, since container dunders are protocol dunders
- Add codegen for IndexAccess on user-defined types: emit obj.GetItem(key) instead
  of obj[key] since user-defined classes don't have C# indexer properties
- Add codegen for index assignment on user-defined types: emit obj.SetItem(key, value)
  instead of obj[key] = value
- Remove dunder_container.skip now that the test passes end-to-end

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

Author: antonsynd

src/Sharpy.Compiler.Tests/Integration/TestFixtures/classes/dunder_container.skip

@@ -877,12 +877,26 @@ private ExpressionSyntax GenerateIndexAccess(IndexAccess indexAccess)
         var objExpr = GenerateExpression(indexAccess.Object);
         var index = GenerateExpression(indexAccess.Index);
 
+        // User-defined types with __getitem__: emit obj.GetItem(key) instead of obj[key]
+        // because user-defined classes don't have a C# indexer property.
+        var objectType = GetExpressionSemanticType(indexAccess.Object);
+        if (objectType is Semantic.UserDefinedType udt && udt.Symbol != null &&
+            (udt.Symbol.ProtocolMethods.ContainsKey(Semantic.DunderNames.GetItem) ||
+             udt.Symbol.OperatorMethods.ContainsKey(Semantic.DunderNames.GetItem)))
+        {
+            return InvocationExpression(
+                MemberAccessExpression(
+                    SyntaxKind.SimpleMemberAccessExpression,
+                    objExpr,
+                    IdentifierName("GetItem")))
+                .AddArgumentListArguments(Argument(index));
+        }
+
         var elementAccess = ElementAccessExpression(objExpr)
             .AddArgumentListArguments(Argument(index));
 
         // String indexing: C# string[int] returns char, but Sharpy types it as str.
         // Wrap with .ToString() to bridge the type gap.
-        var objectType = GetExpressionSemanticType(indexAccess.Object);
         if (objectType == Semantic.SemanticType.Str)
         {
             return InvocationExpression(

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

@@ -395,19 +395,45 @@ private StatementSyntax GenerateAssignment(Assignment assign)
             var obj = GenerateExpression(indexAccess.Object);
             var index = GenerateExpression(indexAccess.Index);
 
+            // User-defined types with __setitem__: emit obj.SetItem(key, value)
+            var targetObjType = GetExpressionSemanticType(indexAccess.Object);
+            if (targetObjType is Semantic.UserDefinedType setUdt && setUdt.Symbol != null &&
+                (setUdt.Symbol.ProtocolMethods.ContainsKey(Semantic.DunderNames.SetItem) ||
+                 setUdt.Symbol.OperatorMethods.ContainsKey(Semantic.DunderNames.SetItem)))
+            {
+                var assignmentValue = assign.Operator == AssignmentOperator.Assign
+                    ? value
+                    : GenerateAugmentedValue(assign.Operator,
+                        InvocationExpression(
+                            MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
+                                obj, IdentifierName("GetItem")))
+                            .AddArgumentListArguments(Argument(index)),
+                        value, assign.Target, assign.Value);
+
+                return ExpressionStatement(
+                    InvocationExpression(
+                        MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            obj,
+                            IdentifierName("SetItem")))
+                        .AddArgumentListArguments(
+                            Argument(index),
+                            Argument(assignmentValue)));
+            }
+
             var elementAccess = ElementAccessExpression(obj)
                 .WithArgumentList(BracketedArgumentList(
                     SingletonSeparatedList(Argument(index))));
 
-            var assignmentValue = assign.Operator == AssignmentOperator.Assign
+            var augmentedValue = assign.Operator == AssignmentOperator.Assign
                 ? value
                 : GenerateAugmentedValue(assign.Operator, elementAccess, value, assign.Target, assign.Value);
 
             return ExpressionStatement(
                 AssignmentExpression(
                     SyntaxKind.SimpleAssignmentExpression,
                     elementAccess,
-                    assignmentValue));
+                    augmentedValue));
         }
 
         // Handle member assignment: obj.field = value

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

@@ -730,7 +730,8 @@ c.Parameters[1].Type is GenericType paramGeneric &&
         };
 
         if (typeSymbol != null &&
-            typeSymbol.OperatorMethods.TryGetValue(DunderNames.GetItem, out var getItemMethods))
+            (typeSymbol.OperatorMethods.TryGetValue(DunderNames.GetItem, out var getItemMethods) ||
+             typeSymbol.ProtocolMethods.TryGetValue(DunderNames.GetItem, out getItemMethods)))
         {
             var bestOverload = FindBestOverload(getItemMethods, index);
             if (bestOverload != null)