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,84 @@
+// 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.Linq;
+using System.Threading;
+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, SequenceEqualImmutableArray<ComMethodContext> ShadowingMethods)
+        {
+            /// <summary>
+            /// COM methods that are declared on the attributed interface declaration.
+            /// </summary>
+            public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where((m => m.DeclaringInterface == Interface));
+
+            /// <summary>
+            /// COM methods that are declared on an interface the interface inherits from.
+            /// </summary>
+            public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.DeclaringInterface != Interface);
+
+            public static IEnumerable<ComInterfaceAndMethodsContext> CalculateAllMethods(ValueEqualityImmutableDictionary<ComInterfaceContext, SequenceEqualImmutableArray<ComMethodInfo>> ifaceToDeclaredMethodsMap, StubEnvironment environment, CancellationToken ct)
+            {
+                Dictionary<ComInterfaceContext, (ImmutableArray<ComMethodContext> Methods, ImmutableArray<ComMethodContext> ShadowingMethods)> allMethodsCache = new();
+
+                foreach (var kvp in ifaceToDeclaredMethodsMap)
+                {
+                    AddMethods(kvp.Key, kvp.Value);
+                }
+
+                return allMethodsCache.Select(kvp => new ComInterfaceAndMethodsContext(kvp.Key, kvp.Value.Methods.ToSequenceEqual(), kvp.Value.ShadowingMethods.ToSequenceEqualImmutableArray()));
+
+                (ImmutableArray<ComMethodContext> Methods, ImmutableArray<ComMethodContext> ShadowingMethods) AddMethods(ComInterfaceContext iface, IEnumerable<ComMethodInfo> declaredMethods)
+                {
+                    if (allMethodsCache.TryGetValue(iface, out var cachedValue))
+                    {
+                        return cachedValue;
+                    }
+
+                    int startingIndex = 3;
+                    List<ComMethodContext> methods = new();
+                    // If we have a base interface, we should add the inherited methods to our list in vtable order
+                    if (iface.Base is not null)
+                    {
+                        var baseComIface = iface.Base;
+                        ImmutableArray<ComMethodContext> baseMethods;
+                        if (!allMethodsCache.TryGetValue(baseComIface, out var pair))
+                        {
+                            baseMethods = AddMethods(baseComIface, ifaceToDeclaredMethodsMap[baseComIface]).Methods;
+                        }
+                        else
+                        {
+                            baseMethods = pair.Methods;
+                        }
+                        methods.AddRange(baseMethods);
+                    }
+                    var shadowingMethods = methods.Select(method =>
+                    {
+                        var info = method.MethodInfo;
+                        var ctx = CalculateStubInformation(info.Syntax, info.Symbol, startingIndex, environment, iface.Info.Type, ct);
+                        return new ComMethodContext(iface, info, startingIndex++, ctx);
+                    }).ToImmutableArray();
+                    // Then we append the declared methods in vtable order
+                    foreach (var method in declaredMethods)
+                    {
+                        var ctx = CalculateStubInformation(method.Syntax, method.Symbol, startingIndex, environment, iface.Info.Type, ct);
+                        methods.Add(new ComMethodContext(iface, method, startingIndex++, ctx));
+                    }
+                    // Cache so we don't recalculate if many interfaces inherit from the same one
+                    var finalPair = (methods.ToImmutableArray(), shadowingMethods);
+                    allMethodsCache[iface] = finalPair;
+                    return finalPair;
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+// 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 IEnumerable<ComInterfaceContext> GetContexts(ImmutableArray<ComInterfaceInfo> data, CancellationToken _)
+            {
+                Dictionary<string, ComInterfaceInfo> symbolToInterfaceInfoMap = new();
+                foreach (var iface in data)
+                {
+                    symbolToInterfaceInfoMap.Add(iface.ThisInterfaceKey, iface);
+                }
+                Dictionary<string, ComInterfaceContext> symbolToContextMap = new();
+
+                foreach (var iface in data)
+                {
+                    yield return AddContext(iface);
+                }
+
+                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;
+                }
+            }
+        }
+    }
+}