Interface inheritance follow up

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/AttributeInfo.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Microsoft.Interop
+{
+    /// <summary>
+    /// Provides the info necessary for copying an attribute from user code to generated code.
+    /// </summary>
+    internal sealed record AttributeInfo(ManagedTypeInfo Type, SequenceEqualImmutableArray<string> Arguments)
+    {
+        internal static AttributeInfo From(AttributeData attribute)
+        {
+            var type = ManagedTypeInfo.CreateTypeInfoForTypeSymbol(attribute.AttributeClass);
+            var args = attribute.ConstructorArguments.Select(ca => ca.ToCSharpString());
+            return new(type, args.ToSequenceEqualImmutableArray());
+        }
+    }
+}

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceAndMethodsContext.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.Interop
+{
+    public sealed partial class ComInterfaceGenerator
+    {
+        /// <summary>
+        /// Represents an interface and all of the methods that need to be generated for it (methods declared on the interface and methods inherited from base interfaces).
+        /// </summary>
+        private sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interface, SequenceEqualImmutableArray<ComMethodContext> Methods)
+        {
+            // Change Calc all methods to return an ordered list of all the methods and the data in comInterfaceandMethodsContext
+            // Have a step that runs CalculateMethodStub on each of them.
+            // Call GroupMethodsByInterfaceForGeneration
+
+            /// <summary>
+            /// COM methods that are declared on the attributed interface declaration.
+            /// </summary>
+            public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
+
+            /// <summary>
+            /// COM methods that are declared on an interface the interface inherits from.
+            /// </summary>
+            public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+        }
+    }
+}

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceContext.cs

@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+
+namespace Microsoft.Interop
+{
+    public sealed partial class ComInterfaceGenerator
+    {
+        private sealed record ComInterfaceContext(ComInterfaceInfo Info, ComInterfaceContext? Base)
+        {
+            /// <summary>
+            /// Takes a list of ComInterfaceInfo, and creates a list of ComInterfaceContext.
+            /// </summary>
+            public static ImmutableArray<ComInterfaceContext> GetContexts(ImmutableArray<ComInterfaceInfo> data, CancellationToken _)
+            {
+                Dictionary<string, ComInterfaceInfo> symbolToInterfaceInfoMap = new();
+                var accumulator = ImmutableArray.CreateBuilder<ComInterfaceContext>(data.Length);
+                foreach (var iface in data)
+                {
+                    symbolToInterfaceInfoMap.Add(iface.ThisInterfaceKey, iface);
+                }
+                Dictionary<string, ComInterfaceContext> symbolToContextMap = new();
+
+                foreach (var iface in data)
+                {
+                    accumulator.Add(AddContext(iface));
+                }
+                return accumulator.MoveToImmutable();
+
+                ComInterfaceContext AddContext(ComInterfaceInfo iface)
+                {
+                    if (symbolToContextMap.TryGetValue(iface.ThisInterfaceKey, out var cachedValue))
+                    {
+                        return cachedValue;
+                    }
+
+                    if (iface.BaseInterfaceKey is null)
+                    {
+                        var baselessCtx = new ComInterfaceContext(iface, null);
+                        symbolToContextMap[iface.ThisInterfaceKey] = baselessCtx;
+                        return baselessCtx;
+                    }
+
+                    if (!symbolToContextMap.TryGetValue(iface.BaseInterfaceKey, out var baseContext))
+                    {
+                        baseContext = AddContext(symbolToInterfaceInfoMap[iface.BaseInterfaceKey]);
+                    }
+                    var ctx = new ComInterfaceContext(iface, baseContext);
+                    symbolToContextMap[iface.ThisInterfaceKey] = ctx;
+                    return ctx;
+                }
+            }
+        }
+    }
+}