Fix interface delegation to include inherited interface members

Fixes #27

- Process all inherited interfaces recursively using AllInterfaces
- Add ProcessInterfaceMembers helper to traverse interface hierarchy
- Include return type in method key to handle overloaded GetEnumerator
- Add local NuGet cache to avoid global cache issues
- Add version marker comment for debugging (YO YO YO MAMA v2)
- Update .gitignore to exclude .nuget-cache/

The fix now generates ALL interface members including those from base
interfaces. For example, IList<T> now generates:
- IList<T> members: IndexOf, Insert, RemoveAt, this[int]
- ICollection<T> members: Add, Clear, Contains, CopyTo, Remove, Count, IsReadOnly
- IEnumerable<T> members: GetEnumerator

Known limitation: IEnumerable (non-generic) GetEnumerator() requires
explicit interface implementation due to return type conflict. This
will be addressed in a future update.

Author: StevenTCramer

.gitignore

@@ -316,3 +316,4 @@ __pycache__/
 /.aider.tags.cache.v3/cache.db-shm
 /.aider.tags.cache.v3/cache.db-wal
 /.aider.input.history
+.nuget-cache/

Directory.Build.props

@@ -15,6 +15,9 @@
     <!-- Output packages to our local feed directory -->
     <PackageOutputPath>$(PackagesDirectory)</PackageOutputPath>
 
+    <!-- Use local NuGet cache instead of global -->
+    <RestorePackagesPath>$(RepositoryRoot).nuget-cache/</RestorePackagesPath>
+
     <!-- Suppress .NET preview SDK message -->
     <SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
   </PropertyGroup>

source/timewarp-source-generators/interface-delegation-generator.cs

@@ -267,12 +267,59 @@ private static List<string> GenerateInterfaceDelegation(
       SemanticModel semanticModel)
   {
     var code = new List<string>();
+    var processedMembers = new HashSet<string>();
 
-    // Get all members of the interface
+    // Process the interface and all inherited interfaces
+    if (interfaceType is INamedTypeSymbol namedInterface)
+    {
+      ProcessInterfaceMembers(namedInterface, delegateMemberName, classSymbol, code, processedMembers);
+    }
+
+    return code;
+  }
+
+  private static void ProcessInterfaceMembers(
+      INamedTypeSymbol interfaceType,
+      string delegateMemberName,
+      INamedTypeSymbol classSymbol,
+      List<string> code,
+      HashSet<string> processedMembers)
+  {
+    // First, recursively process all base interfaces
+    foreach (INamedTypeSymbol baseInterface in interfaceType.AllInterfaces)
+    {
+      ProcessInterfaceMembersCore(baseInterface, delegateMemberName, classSymbol, code, processedMembers);
+    }
+
+    // Then process the current interface's own members
+    ProcessInterfaceMembersCore(interfaceType, delegateMemberName, classSymbol, code, processedMembers);
+  }
+
+  private static void ProcessInterfaceMembersCore(
+      INamedTypeSymbol interfaceType,
+      string delegateMemberName,
+      INamedTypeSymbol classSymbol,
+      List<string> code,
+      HashSet<string> processedMembers)
+  {
     ImmutableArray<ISymbol> interfaceMembers = interfaceType.GetMembers();
 
     foreach (ISymbol member in interfaceMembers)
     {
+      // Create a unique key for this member to avoid duplicates
+      string memberKey = $"{member.Name}_{member.Kind}";
+      if (member is IMethodSymbol method)
+      {
+        // Include return type and parameter types in key to handle overloads and different return types
+        string returnType = method.ReturnType.ToDisplayString();
+        string paramTypes = string.Join(",", method.Parameters.Select(p => p.Type.ToDisplayString()));
+        memberKey = $"{member.Name}_{method.MethodKind}_{returnType}_{paramTypes}";
+      }
+
+      // Skip if we've already processed this member
+      if (!processedMembers.Add(memberKey))
+        continue;
+
       // Skip if the class already implements this member explicitly
       ISymbol? existingImplementation = classSymbol.GetMembers(member.Name)
                 .FirstOrDefault(m => !m.IsImplicitlyDeclared);
@@ -282,8 +329,8 @@ private static List<string> GenerateInterfaceDelegation(
 
       switch (member)
       {
-        case IMethodSymbol method when method.MethodKind == MethodKind.Ordinary:
-          code.Add(GenerateMethodDelegation(method, delegateMemberName));
+        case IMethodSymbol methodSymbol when methodSymbol.MethodKind == MethodKind.Ordinary:
+          code.Add(GenerateMethodDelegation(methodSymbol, delegateMemberName));
           break;
 
         case IPropertySymbol property:
@@ -295,8 +342,6 @@ private static List<string> GenerateInterfaceDelegation(
           break;
       }
     }
-
-    return code;
   }
 
   private static string GenerateMethodDelegation(IMethodSymbol method, string delegateMemberName)
@@ -375,7 +420,7 @@ private static string GenerateSourceFile(
       builder.AppendLine();
     }
 
-    builder.AppendLine($"// Interface delegation for {className}");
+    builder.AppendLine($"// Interface delegation for {className} - YO YO YO MAMA v2 with inherited interfaces!");
     builder.AppendLine($"public partial class {className}");
     builder.AppendLine("{");
 

tests/timewarp-source-generators-test-console/generated/timewarp-source-generators/TimeWarp.SourceGenerators.InterfaceDelegationGenerator/DataService.implements.g.cs

@@ -3,7 +3,7 @@
 
 namespace TimeWarp.SourceGenerators.TestConsole;
 
-// Interface delegation for DataService
+// Interface delegation for DataService - YO YO YO MAMA v2 with inherited interfaces!
 public partial class DataService
 {
     // Delegation to _logger for TimeWarp.SourceGenerators.TestConsole.ILogger

tests/timewarp-source-generators-test-console/generated/timewarp-source-generators/TimeWarp.SourceGenerators.InterfaceDelegationGenerator/StringListWrapper.implements.g.cs

@@ -0,0 +1,70 @@
+// <auto-generated/>
+#nullable enable
+
+namespace TimeWarp.SourceGenerators.TestConsole;
+
+// Interface delegation for StringListWrapper - YO YO YO MAMA v2 with inherited interfaces!
+public partial class StringListWrapper
+{
+    // Delegation to InnerList for System.Collections.Generic.IList<string>
+    public void Add(string item)
+    {
+        InnerList.Add(item);
+    }
+
+    public void Clear()
+    {
+        InnerList.Clear();
+    }
+
+    public bool Contains(string item)
+    {
+        return InnerList.Contains(item);
+    }
+
+    public void CopyTo(string[] array, int arrayIndex)
+    {
+        InnerList.CopyTo(array, arrayIndex);
+    }
+
+    public bool Remove(string item)
+    {
+        return InnerList.Remove(item);
+    }
+
+    public int Count
+    {
+ get => InnerList.Count;
+    }
+
+    public bool IsReadOnly
+    {
+ get => InnerList.IsReadOnly;
+    }
+
+    public System.Collections.Generic.IEnumerator<string> GetEnumerator()
+    {
+        return InnerList.GetEnumerator();
+    }
+
+    public int IndexOf(string item)
+    {
+        return InnerList.IndexOf(item);
+    }
+
+    public void Insert(int index, string item)
+    {
+        InnerList.Insert(index, item);
+    }
+
+    public void RemoveAt(int index)
+    {
+        InnerList.RemoveAt(index);
+    }
+
+    public string this[int index]
+    {
+ get => InnerList[index]; set => InnerList[index] = value;
+    }
+
+}