Enable derived COM interfaces to hide base methods with the new keyword

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

@@ -17,9 +17,14 @@ internal sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interfa
  /// </summary>
  public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
 
+ /// <summary>
+ /// COM methods that require shadowing declarations on the derived interface.
+ /// </summary>
+ public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod && !m.IsHiddenOnDerivedInterface);
+
  /// <summary>
  /// COM methods that are declared on an interface the interface inherits from.
  /// </summary>
- public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+ public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.IsInheritedMethod);
  }
 }

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

@@ -127,7 +127,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .WithComparer(SyntaxEquivalentComparer.Instance)
  .SelectNormalized();
 
- var shadowingMethods = interfaceAndMethodsContexts
+ var shadowingMethodDeclarations = interfaceAndMethodsContexts
  .Select((data, ct) =>
  {
  var context = data.Interface.Info;
@@ -163,7 +163,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .Zip(nativeToManagedVtableMethods)
  .Zip(nativeToManagedVtables)
  .Zip(iUnknownDerivedAttributeApplication)
- .Zip(shadowingMethods)
+ .Zip(shadowingMethodDeclarations)
  .Select(static (data, ct) =>
  {
  var ((((((interfaceContext, interfaceInfo), managedToNativeStubs), nativeToManagedStubs), nativeToManagedVtable), iUnknownDerivedAttribute), shadowingMethod) = data;
@@ -352,7 +352,7 @@ private static IncrementalMethodStubGenerationContext CalculateStubInformation(M
 
  var containingSyntaxContext = new ContainingSyntaxContext(syntax);
 
- var methodSyntaxTemplate = new ContainingSyntax(syntax.Modifiers.StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
+ var methodSyntaxTemplate = new ContainingSyntax(new SyntaxTokenList(syntax.Modifiers.Where(static m => !m.IsKind(SyntaxKind.NewKeyword))).StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
 
  ImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> callConv = VirtualMethodPointerStubGenerator.GenerateCallConvSyntaxFromAttributes(
  suppressGCTransitionAttribute,
@@ -423,11 +423,42 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  var methodList = ImmutableArray.CreateBuilder<ComMethodContext>();
  while (methodIndex < methods.Length && methods[methodIndex].OwningInterface == iface)
  {
+ var method = methods[methodIndex];
+ if (method.MethodInfo.IsUserDefinedShadowingMethod)
+ {
+ bool shadowFound = false;
+ int shadowIndex = -1;
+ // Don't remove method, but make it so that it doesn't generate any stubs
+ for (int i = methodList.Count - 1; i > -1; i--)
+ {
+ var potentialShadowedMethod = methodList[i];
+ if (MethodEquals(method, potentialShadowedMethod))
+ {
+ shadowFound = true;
+ shadowIndex = i;
+ break;
+ }
+ }
+ if (shadowFound)
+ {
+ methodList[shadowIndex].IsHiddenOnDerivedInterface = true;
+ }
+ // We might not find the shadowed method if it's defined on a non-GeneratedComInterface-attributed interface. Thats okay and we can disregard it.
+ }
  methodList.Add(methods[methodIndex++]);
  }
  contextList.Add(new(iface, methodList.ToImmutable().ToSequenceEqual()));
  }
  return contextList.ToImmutable();
+
+ static bool MethodEquals(ComMethodContext a, ComMethodContext b)
+ {
+ if (a.MethodInfo.MethodName != b.MethodInfo.MethodName)
+ return false;
+ if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))
+ return true;
+ return false;
+ }
  }
 
  private static readonly InterfaceDeclarationSyntax ImplementationInterfaceTemplate = InterfaceDeclaration("InterfaceImplementation")
@@ -436,12 +467,12 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  private static InterfaceDeclarationSyntax GenerateImplementationInterface(ComInterfaceAndMethodsContext interfaceGroup, CancellationToken _)
  {
  var definingType = interfaceGroup.Interface.Info.Type;
- var shadowImplementations = interfaceGroup.ShadowingMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
+ var shadowImplementations = interfaceGroup.InheritedMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
  .Where(p => p.ManagedToUnmanagedStub is GeneratedStubCodeContext)
  .Select(ctx => ((GeneratedStubCodeContext)ctx.ManagedToUnmanagedStub).Stub.Node
  .WithExplicitInterfaceSpecifier(
  ExplicitInterfaceSpecifier(ParseName(definingType.FullTypeName))));
- var inheritedStubs = interfaceGroup.ShadowingMethods.Select(m => m.UnreachableExceptionStub);
+ var inheritedStubs = interfaceGroup.InheritedMethods.Select(m => m.UnreachableExceptionStub);
  return ImplementationInterfaceTemplate
  .AddBaseListTypes(SimpleBaseType(definingType.Syntax))
  .WithMembers(
@@ -560,7 +591,7 @@ private static InterfaceDeclarationSyntax GenerateImplementationVTable(ComInterf
  ParenthesizedExpression(
  BinaryExpression(SyntaxKind.MultiplyExpression,
  SizeOfExpression(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword)))),
- LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.ShadowingMethods.Count() + 3))))))));
+ LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));
  }
 
  var vtableSlotAssignments = VirtualMethodPointerStubGenerator.GenerateVirtualMethodTableSlotAssignments(

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

@@ -69,13 +69,15 @@ public ComMethodContext(Builder builder, ComInterfaceContext owningInterface, In
 
  public bool IsInheritedMethod => OriginalDeclaringInterface != OwningInterface;
 
+ public bool IsHiddenOnDerivedInterface { get; set; }
+
  private GeneratedMethodContextBase? _managedToUnmanagedStub;
 
  public GeneratedMethodContextBase ManagedToUnmanagedStub => _managedToUnmanagedStub ??= CreateManagedToUnmanagedStub();
 
  private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(OriginalDeclaringInterface.Info.Type);
  }
@@ -89,7 +91,7 @@ private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
 
  private GeneratedMethodContextBase CreateUnmanagedToManagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(GenerationContext.OriginalDefiningType);
  }

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

@@ -17,7 +17,8 @@ namespace Microsoft.Interop
  internal sealed record ComMethodInfo(
  MethodDeclarationSyntax Syntax,
  string MethodName,
- SequenceEqualImmutableArray<AttributeInfo> Attributes)
+ SequenceEqualImmutableArray<AttributeInfo> Attributes,
+ bool IsUserDefinedShadowingMethod)
  {
  /// <summary>
  /// Returns a list of tuples of ComMethodInfo, IMethodSymbol, and Diagnostic. If ComMethodInfo is null, Diagnostic will not be null, and vice versa.
@@ -123,7 +124,9 @@ internal sealed record ComMethodInfo(
  {
  attributeInfos.Add(AttributeInfo.From(attr));
  }
- var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual());
+
+ bool shadowsBaseMethod = comMethodDeclaringSyntax.Modifiers.Any(SyntaxKind.NewKeyword);
+ var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);
  return DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From((comMethodInfo, method));
  }
  }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/RcwAroundCcwTests.cs

@@ -386,5 +386,39 @@ public void IStringArrayMarshallingFails_Failing()
  obj.ByValueOutParam(strings);
  });
  }
+
+ [Fact]
+ public unsafe void IHideWorksAsExpected()
+ {
+ IHide obj = CreateWrapper<HideBaseMethods, IHide3>();
+
+ // IHide.SameMethod should be index 3
+ Assert.Equal(3, obj.SameMethod());
+ Assert.Equal(4, obj.DifferentMethod());
+
+ IHide2 obj2 = (IHide2)obj;
+
+ // IHide2.SameMethod should be index 5
+ Assert.Equal(5, obj2.SameMethod());
+ Assert.Equal(4, obj2.DifferentMethod());
+ Assert.Equal(6, obj2.DifferentMethod2());
+
+ IHide3 obj3 = (IHide3)obj;
+ // IHide3.SameMethod should be index 7
+ Assert.Equal(7, obj3.SameMethod());
+ Assert.Equal(4, obj3.DifferentMethod());
+ Assert.Equal(6, obj3.DifferentMethod2());
+ Assert.Equal(8, obj3.DifferentMethod3());
+
+ // Ensure each VTable method points to the correct method on HideBaseMethods
+ for (int i = 3; i < 9; i++)
+ {
+ var (__this, __vtable_native) = ((global::System.Runtime.InteropServices.Marshalling.IUnmanagedVirtualMethodTableProvider)obj3).GetVirtualMethodTableInfoForKey(typeof(global::SharedTypes.ComInterfaces.IHide3));
+ int __retVal;
+ int __invokeRetVal;
+ __invokeRetVal = ((delegate* unmanaged[MemberFunction]<void*, int*, int>)__vtable_native[i])(__this, &__retVal);
+ Assert.Equal(i, __retVal);
+ }
+ }
  }
 }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/CodeSnippets.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -109,8 +110,6 @@ public static StatelessCollectionAllShapes<TManagedElement> AllocateContainerFor
  }
  """;
 
- public static readonly string DisableRuntimeMarshalling = "[assembly:System.Runtime.CompilerServices.DisableRuntimeMarshalling]";
- public static readonly string UsingSystemRuntimeInteropServicesMarshalling = "using System.Runtime.InteropServices.Marshalling;";
  public const string IntMarshaller = """
  [CustomMarshaller(typeof(int), MarshalMode.Default, typeof(IntMarshaller))]
  internal static class IntMarshaller
@@ -433,6 +432,87 @@ partial interface INativeAPI
  {{_attributeProvider.AdditionalUserRequiredInterfaces("INativeAPI")}}
  """;
 
+ public string DerivedComInterfaceTypeWithShadowingMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method2();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method2();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsComAndNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeTwoLevelShadows => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface1: IComInterface
+ {
+ new void Method1();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface1
+ {
+ new void Method();
+ }
+ """;
+
  public string DerivedComInterfaceType => $$"""
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/Compiles.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using Microsoft.DotNet.XUnitExtensions.Attributes;
 using Microsoft.Interop.UnitTests;
 using Xunit;
 using VerifyComInterfaceGenerator = Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier<Microsoft.Interop.ComInterfaceGenerator>;
@@ -336,6 +335,10 @@ public static IEnumerable<object[]> ComInterfaceSnippetsToCompile()
  {
  CodeSnippets codeSnippets = new(new GeneratedComInterfaceAttributeProvider());
  yield return new object[] { ID(), codeSnippets.DerivedComInterfaceType };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeWithShadowingMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsComAndNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeTwoLevelShadows};
  yield return new object[] { ID(), codeSnippets.DerivedWithParametersDeclaredInOtherNamespace };
  yield return new object[] { ID(), codeSnippets.ComInterfaceParameters };
  }

src/libraries/System.Runtime.InteropServices/tests/TestAssets/SharedTypes/ComInterfaces/IHide.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;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+namespace SharedTypes.ComInterfaces
+{
+ [GeneratedComInterface]
+ [Guid("023EA72A-ECAA-4B65-9D96-2122CFADE16C")]
+ internal partial interface IHide
+ {
+ int SameMethod();
+ int DifferentMethod();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5293B3B1-4994-425C-803E-A21A5011E077")]
+ internal partial interface IHide2 : IHide
+ {
+ new int SameMethod();
+ int DifferentMethod2();
+ }
+
+ internal interface UnrelatedInterfaceWithSameMethod
+ {
+ int SameMethod();
+ int DifferentMethod3();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5DD35432-4987-488D-94F1-7682D7E4405C")]
+ internal partial interface IHide3 : IHide2, UnrelatedInterfaceWithSameMethod
+ {
+ new int SameMethod();
+ new int DifferentMethod3();
+ }
+
+ [GeneratedComClass]
+ [Guid("2D36BD6D-C80E-4F00-86E9-8D1B4A0CB59A")]
+ /// <summary>
+ /// Implements IHides3 and returns the expected VTable index for each method.
+ /// </summary>
+ internal partial class HideBaseMethods : IHide3
+ {
+ int IHide.SameMethod() => 3;
+ int IHide.DifferentMethod() => 4;
+ int IHide2.SameMethod() => 5;
+ int IHide2.DifferentMethod2() => 6;
+ int IHide3.SameMethod() => 7;
+ int IHide3.DifferentMethod3() => 8;
+ int UnrelatedInterfaceWithSameMethod.SameMethod() => -1;
+ int UnrelatedInterfaceWithSameMethod.DifferentMethod3() => -1;
+ }
+}

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

@@ -17,9 +17,14 @@ internal sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interfa
  /// </summary>
  public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
 
+ /// <summary>
+ /// COM methods that require shadowing declarations on the derived interface.
+ /// </summary>
+ public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod && !m.IsHiddenOnDerivedInterface);
+
  /// <summary>
  /// COM methods that are declared on an interface the interface inherits from.
  /// </summary>
- public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+ public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.IsInheritedMethod);
  }
 }

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

@@ -127,7 +127,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .WithComparer(SyntaxEquivalentComparer.Instance)
  .SelectNormalized();
 
- var shadowingMethods = interfaceAndMethodsContexts
+ var shadowingMethodDeclarations = interfaceAndMethodsContexts
  .Select((data, ct) =>
  {
  var context = data.Interface.Info;
@@ -163,7 +163,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .Zip(nativeToManagedVtableMethods)
  .Zip(nativeToManagedVtables)
  .Zip(iUnknownDerivedAttributeApplication)
- .Zip(shadowingMethods)
+ .Zip(shadowingMethodDeclarations)
  .Select(static (data, ct) =>
  {
  var ((((((interfaceContext, interfaceInfo), managedToNativeStubs), nativeToManagedStubs), nativeToManagedVtable), iUnknownDerivedAttribute), shadowingMethod) = data;
@@ -352,7 +352,7 @@ private static IncrementalMethodStubGenerationContext CalculateStubInformation(M
 
  var containingSyntaxContext = new ContainingSyntaxContext(syntax);
 
- var methodSyntaxTemplate = new ContainingSyntax(syntax.Modifiers.StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
+ var methodSyntaxTemplate = new ContainingSyntax(new SyntaxTokenList(syntax.Modifiers.Where(static m => !m.IsKind(SyntaxKind.NewKeyword))).StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
 
  ImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> callConv = VirtualMethodPointerStubGenerator.GenerateCallConvSyntaxFromAttributes(
  suppressGCTransitionAttribute,
@@ -423,11 +423,42 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  var methodList = ImmutableArray.CreateBuilder<ComMethodContext>();
  while (methodIndex < methods.Length && methods[methodIndex].OwningInterface == iface)
  {
+ var method = methods[methodIndex];
+ if (method.MethodInfo.IsUserDefinedShadowingMethod)
+ {
+ bool shadowFound = false;
+ int shadowIndex = -1;
+ // Don't remove method, but make it so that it doesn't generate any stubs
+ for (int i = methodList.Count - 1; i > -1; i--)
+ {
+ var potentialShadowedMethod = methodList[i];
+ if (MethodEquals(method, potentialShadowedMethod))
+ {
+ shadowFound = true;
+ shadowIndex = i;
+ break;
+ }
+ }
+ if (shadowFound)
+ {
+ methodList[shadowIndex].IsHiddenOnDerivedInterface = true;
+ }
+ // We might not find the shadowed method if it's defined on a non-GeneratedComInterface-attributed interface. Thats okay and we can disregard it.
+ }
  methodList.Add(methods[methodIndex++]);
  }
  contextList.Add(new(iface, methodList.ToImmutable().ToSequenceEqual()));
  }
  return contextList.ToImmutable();
+
+ static bool MethodEquals(ComMethodContext a, ComMethodContext b)
+ {
+ if (a.MethodInfo.MethodName != b.MethodInfo.MethodName)
+ return false;
+ if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))
+ return true;
+ return false;
+ }
  }
 
  private static readonly InterfaceDeclarationSyntax ImplementationInterfaceTemplate = InterfaceDeclaration("InterfaceImplementation")
@@ -436,12 +467,12 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  private static InterfaceDeclarationSyntax GenerateImplementationInterface(ComInterfaceAndMethodsContext interfaceGroup, CancellationToken _)
  {
  var definingType = interfaceGroup.Interface.Info.Type;
- var shadowImplementations = interfaceGroup.ShadowingMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
+ var shadowImplementations = interfaceGroup.InheritedMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
  .Where(p => p.ManagedToUnmanagedStub is GeneratedStubCodeContext)
  .Select(ctx => ((GeneratedStubCodeContext)ctx.ManagedToUnmanagedStub).Stub.Node
  .WithExplicitInterfaceSpecifier(
  ExplicitInterfaceSpecifier(ParseName(definingType.FullTypeName))));
- var inheritedStubs = interfaceGroup.ShadowingMethods.Select(m => m.UnreachableExceptionStub);
+ var inheritedStubs = interfaceGroup.InheritedMethods.Select(m => m.UnreachableExceptionStub);
  return ImplementationInterfaceTemplate
  .AddBaseListTypes(SimpleBaseType(definingType.Syntax))
  .WithMembers(
@@ -560,7 +591,7 @@ private static InterfaceDeclarationSyntax GenerateImplementationVTable(ComInterf
  ParenthesizedExpression(
  BinaryExpression(SyntaxKind.MultiplyExpression,
  SizeOfExpression(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword)))),
- LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.ShadowingMethods.Count() + 3))))))));
+ LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));
  }
 
  var vtableSlotAssignments = VirtualMethodPointerStubGenerator.GenerateVirtualMethodTableSlotAssignments(

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

@@ -69,13 +69,15 @@ public ComMethodContext(Builder builder, ComInterfaceContext owningInterface, In
 
  public bool IsInheritedMethod => OriginalDeclaringInterface != OwningInterface;
 
+ public bool IsHiddenOnDerivedInterface { get; set; }
+
  private GeneratedMethodContextBase? _managedToUnmanagedStub;
 
  public GeneratedMethodContextBase ManagedToUnmanagedStub => _managedToUnmanagedStub ??= CreateManagedToUnmanagedStub();
 
  private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(OriginalDeclaringInterface.Info.Type);
  }
@@ -89,7 +91,7 @@ private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
 
  private GeneratedMethodContextBase CreateUnmanagedToManagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(GenerationContext.OriginalDefiningType);
  }

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

@@ -17,7 +17,8 @@ namespace Microsoft.Interop
  internal sealed record ComMethodInfo(
  MethodDeclarationSyntax Syntax,
  string MethodName,
- SequenceEqualImmutableArray<AttributeInfo> Attributes)
+ SequenceEqualImmutableArray<AttributeInfo> Attributes,
+ bool IsUserDefinedShadowingMethod)
  {
  /// <summary>
  /// Returns a list of tuples of ComMethodInfo, IMethodSymbol, and Diagnostic. If ComMethodInfo is null, Diagnostic will not be null, and vice versa.
@@ -123,7 +124,9 @@ internal sealed record ComMethodInfo(
  {
  attributeInfos.Add(AttributeInfo.From(attr));
  }
- var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual());
+
+ bool shadowsBaseMethod = comMethodDeclaringSyntax.Modifiers.Any(SyntaxKind.NewKeyword);
+ var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);
  return DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From((comMethodInfo, method));
  }
  }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/RcwAroundCcwTests.cs

@@ -386,5 +386,39 @@ public void IStringArrayMarshallingFails_Failing()
  obj.ByValueOutParam(strings);
  });
  }
+
+ [Fact]
+ public unsafe void IHideWorksAsExpected()
+ {
+ IHide obj = CreateWrapper<HideBaseMethods, IHide3>();
+
+ // IHide.SameMethod should be index 3
+ Assert.Equal(3, obj.SameMethod());
+ Assert.Equal(4, obj.DifferentMethod());
+
+ IHide2 obj2 = (IHide2)obj;
+
+ // IHide2.SameMethod should be index 5
+ Assert.Equal(5, obj2.SameMethod());
+ Assert.Equal(4, obj2.DifferentMethod());
+ Assert.Equal(6, obj2.DifferentMethod2());
+
+ IHide3 obj3 = (IHide3)obj;
+ // IHide3.SameMethod should be index 7
+ Assert.Equal(7, obj3.SameMethod());
+ Assert.Equal(4, obj3.DifferentMethod());
+ Assert.Equal(6, obj3.DifferentMethod2());
+ Assert.Equal(8, obj3.DifferentMethod3());
+
+ // Ensure each VTable method points to the correct method on HideBaseMethods
+ for (int i = 3; i < 9; i++)
+ {
+ var (__this, __vtable_native) = ((global::System.Runtime.InteropServices.Marshalling.IUnmanagedVirtualMethodTableProvider)obj3).GetVirtualMethodTableInfoForKey(typeof(global::SharedTypes.ComInterfaces.IHide3));
+ int __retVal;
+ int __invokeRetVal;
+ __invokeRetVal = ((delegate* unmanaged[MemberFunction]<void*, int*, int>)__vtable_native[i])(__this, &__retVal);
+ Assert.Equal(i, __retVal);
+ }
+ }
  }
 }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/CodeSnippets.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -109,8 +110,6 @@ public static StatelessCollectionAllShapes<TManagedElement> AllocateContainerFor
  }
  """;
 
- public static readonly string DisableRuntimeMarshalling = "[assembly:System.Runtime.CompilerServices.DisableRuntimeMarshalling]";
- public static readonly string UsingSystemRuntimeInteropServicesMarshalling = "using System.Runtime.InteropServices.Marshalling;";
  public const string IntMarshaller = """
  [CustomMarshaller(typeof(int), MarshalMode.Default, typeof(IntMarshaller))]
  internal static class IntMarshaller
@@ -433,6 +432,87 @@ partial interface INativeAPI
  {{_attributeProvider.AdditionalUserRequiredInterfaces("INativeAPI")}}
  """;
 
+ public string DerivedComInterfaceTypeWithShadowingMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method2();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method2();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsComAndNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeTwoLevelShadows => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface1: IComInterface
+ {
+ new void Method1();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface1
+ {
+ new void Method();
+ }
+ """;
+
  public string DerivedComInterfaceType => $$"""
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/Compiles.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using Microsoft.DotNet.XUnitExtensions.Attributes;
 using Microsoft.Interop.UnitTests;
 using Xunit;
 using VerifyComInterfaceGenerator = Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier<Microsoft.Interop.ComInterfaceGenerator>;
@@ -336,6 +335,10 @@ public static IEnumerable<object[]> ComInterfaceSnippetsToCompile()
  {
  CodeSnippets codeSnippets = new(new GeneratedComInterfaceAttributeProvider());
  yield return new object[] { ID(), codeSnippets.DerivedComInterfaceType };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeWithShadowingMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsComAndNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeTwoLevelShadows};
  yield return new object[] { ID(), codeSnippets.DerivedWithParametersDeclaredInOtherNamespace };
  yield return new object[] { ID(), codeSnippets.ComInterfaceParameters };
  }

src/libraries/System.Runtime.InteropServices/tests/TestAssets/SharedTypes/ComInterfaces/IHide.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;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+namespace SharedTypes.ComInterfaces
+{
+ [GeneratedComInterface]
+ [Guid("023EA72A-ECAA-4B65-9D96-2122CFADE16C")]
+ internal partial interface IHide
+ {
+ int SameMethod();
+ int DifferentMethod();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5293B3B1-4994-425C-803E-A21A5011E077")]
+ internal partial interface IHide2 : IHide
+ {
+ new int SameMethod();
+ int DifferentMethod2();
+ }
+
+ internal interface UnrelatedInterfaceWithSameMethod
+ {
+ int SameMethod();
+ int DifferentMethod3();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5DD35432-4987-488D-94F1-7682D7E4405C")]
+ internal partial interface IHide3 : IHide2, UnrelatedInterfaceWithSameMethod
+ {
+ new int SameMethod();
+ new int DifferentMethod3();
+ }
+
+ [GeneratedComClass]
+ [Guid("2D36BD6D-C80E-4F00-86E9-8D1B4A0CB59A")]
+ /// <summary>
+ /// Implements IHides3 and returns the expected VTable index for each method.
+ /// </summary>
+ internal partial class HideBaseMethods : IHide3
+ {
+ int IHide.SameMethod() => 3;
+ int IHide.DifferentMethod() => 4;
+ int IHide2.SameMethod() => 5;
+ int IHide2.DifferentMethod2() => 6;
+ int IHide3.SameMethod() => 7;
+ int IHide3.DifferentMethod3() => 8;
+ int UnrelatedInterfaceWithSameMethod.SameMethod() => -1;
+ int UnrelatedInterfaceWithSameMethod.DifferentMethod3() => -1;
+ }
+}

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

@@ -17,9 +17,14 @@ internal sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interfa
  /// </summary>
  public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
 
+ /// <summary>
+ /// COM methods that require shadowing declarations on the derived interface.
+ /// </summary>
+ public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod && !m.IsHiddenOnDerivedInterface);
+
  /// <summary>
  /// COM methods that are declared on an interface the interface inherits from.
  /// </summary>
- public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+ public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.IsInheritedMethod);
  }
 }

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

@@ -127,7 +127,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .WithComparer(SyntaxEquivalentComparer.Instance)
  .SelectNormalized();
 
- var shadowingMethods = interfaceAndMethodsContexts
+ var shadowingMethodDeclarations = interfaceAndMethodsContexts
  .Select((data, ct) =>
  {
  var context = data.Interface.Info;
@@ -163,7 +163,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .Zip(nativeToManagedVtableMethods)
  .Zip(nativeToManagedVtables)
  .Zip(iUnknownDerivedAttributeApplication)
- .Zip(shadowingMethods)
+ .Zip(shadowingMethodDeclarations)
  .Select(static (data, ct) =>
  {
  var ((((((interfaceContext, interfaceInfo), managedToNativeStubs), nativeToManagedStubs), nativeToManagedVtable), iUnknownDerivedAttribute), shadowingMethod) = data;
@@ -352,7 +352,7 @@ private static IncrementalMethodStubGenerationContext CalculateStubInformation(M
 
  var containingSyntaxContext = new ContainingSyntaxContext(syntax);
 
- var methodSyntaxTemplate = new ContainingSyntax(syntax.Modifiers.StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
+ var methodSyntaxTemplate = new ContainingSyntax(new SyntaxTokenList(syntax.Modifiers.Where(static m => !m.IsKind(SyntaxKind.NewKeyword))).StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
 
  ImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> callConv = VirtualMethodPointerStubGenerator.GenerateCallConvSyntaxFromAttributes(
  suppressGCTransitionAttribute,
@@ -423,11 +423,42 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  var methodList = ImmutableArray.CreateBuilder<ComMethodContext>();
  while (methodIndex < methods.Length && methods[methodIndex].OwningInterface == iface)
  {
+ var method = methods[methodIndex];
+ if (method.MethodInfo.IsUserDefinedShadowingMethod)
+ {
+ bool shadowFound = false;
+ int shadowIndex = -1;
+ // Don't remove method, but make it so that it doesn't generate any stubs
+ for (int i = methodList.Count - 1; i > -1; i--)
+ {
+ var potentialShadowedMethod = methodList[i];
+ if (MethodEquals(method, potentialShadowedMethod))
+ {
+ shadowFound = true;
+ shadowIndex = i;
+ break;
+ }
+ }
+ if (shadowFound)
+ {
+ methodList[shadowIndex].IsHiddenOnDerivedInterface = true;
+ }
+ // We might not find the shadowed method if it's defined on a non-GeneratedComInterface-attributed interface. Thats okay and we can disregard it.
+ }
  methodList.Add(methods[methodIndex++]);
  }
  contextList.Add(new(iface, methodList.ToImmutable().ToSequenceEqual()));
  }
  return contextList.ToImmutable();
+
+ static bool MethodEquals(ComMethodContext a, ComMethodContext b)
+ {
+ if (a.MethodInfo.MethodName != b.MethodInfo.MethodName)
+ return false;
+ if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))
+ return true;
+ return false;
+ }
  }
 
  private static readonly InterfaceDeclarationSyntax ImplementationInterfaceTemplate = InterfaceDeclaration("InterfaceImplementation")
@@ -436,12 +467,12 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  private static InterfaceDeclarationSyntax GenerateImplementationInterface(ComInterfaceAndMethodsContext interfaceGroup, CancellationToken _)
  {
  var definingType = interfaceGroup.Interface.Info.Type;
- var shadowImplementations = interfaceGroup.ShadowingMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
+ var shadowImplementations = interfaceGroup.InheritedMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
  .Where(p => p.ManagedToUnmanagedStub is GeneratedStubCodeContext)
  .Select(ctx => ((GeneratedStubCodeContext)ctx.ManagedToUnmanagedStub).Stub.Node
  .WithExplicitInterfaceSpecifier(
  ExplicitInterfaceSpecifier(ParseName(definingType.FullTypeName))));
- var inheritedStubs = interfaceGroup.ShadowingMethods.Select(m => m.UnreachableExceptionStub);
+ var inheritedStubs = interfaceGroup.InheritedMethods.Select(m => m.UnreachableExceptionStub);
  return ImplementationInterfaceTemplate
  .AddBaseListTypes(SimpleBaseType(definingType.Syntax))
  .WithMembers(
@@ -560,7 +591,7 @@ private static InterfaceDeclarationSyntax GenerateImplementationVTable(ComInterf
  ParenthesizedExpression(
  BinaryExpression(SyntaxKind.MultiplyExpression,
  SizeOfExpression(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword)))),
- LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.ShadowingMethods.Count() + 3))))))));
+ LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));
  }
 
  var vtableSlotAssignments = VirtualMethodPointerStubGenerator.GenerateVirtualMethodTableSlotAssignments(

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

@@ -69,13 +69,15 @@ public ComMethodContext(Builder builder, ComInterfaceContext owningInterface, In
 
  public bool IsInheritedMethod => OriginalDeclaringInterface != OwningInterface;
 
+ public bool IsHiddenOnDerivedInterface { get; set; }
+
  private GeneratedMethodContextBase? _managedToUnmanagedStub;
 
  public GeneratedMethodContextBase ManagedToUnmanagedStub => _managedToUnmanagedStub ??= CreateManagedToUnmanagedStub();
 
  private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(OriginalDeclaringInterface.Info.Type);
  }
@@ -89,7 +91,7 @@ private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
 
  private GeneratedMethodContextBase CreateUnmanagedToManagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(GenerationContext.OriginalDefiningType);
  }

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

@@ -17,7 +17,8 @@ namespace Microsoft.Interop
  internal sealed record ComMethodInfo(
  MethodDeclarationSyntax Syntax,
  string MethodName,
- SequenceEqualImmutableArray<AttributeInfo> Attributes)
+ SequenceEqualImmutableArray<AttributeInfo> Attributes,
+ bool IsUserDefinedShadowingMethod)
  {
  /// <summary>
  /// Returns a list of tuples of ComMethodInfo, IMethodSymbol, and Diagnostic. If ComMethodInfo is null, Diagnostic will not be null, and vice versa.
@@ -123,7 +124,9 @@ internal sealed record ComMethodInfo(
  {
  attributeInfos.Add(AttributeInfo.From(attr));
  }
- var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual());
+
+ bool shadowsBaseMethod = comMethodDeclaringSyntax.Modifiers.Any(SyntaxKind.NewKeyword);
+ var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);
  return DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From((comMethodInfo, method));
  }
  }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/RcwAroundCcwTests.cs

@@ -386,5 +386,39 @@ public void IStringArrayMarshallingFails_Failing()
  obj.ByValueOutParam(strings);
  });
  }
+
+ [Fact]
+ public unsafe void IHideWorksAsExpected()
+ {
+ IHide obj = CreateWrapper<HideBaseMethods, IHide3>();
+
+ // IHide.SameMethod should be index 3
+ Assert.Equal(3, obj.SameMethod());
+ Assert.Equal(4, obj.DifferentMethod());
+
+ IHide2 obj2 = (IHide2)obj;
+
+ // IHide2.SameMethod should be index 5
+ Assert.Equal(5, obj2.SameMethod());
+ Assert.Equal(4, obj2.DifferentMethod());
+ Assert.Equal(6, obj2.DifferentMethod2());
+
+ IHide3 obj3 = (IHide3)obj;
+ // IHide3.SameMethod should be index 7
+ Assert.Equal(7, obj3.SameMethod());
+ Assert.Equal(4, obj3.DifferentMethod());
+ Assert.Equal(6, obj3.DifferentMethod2());
+ Assert.Equal(8, obj3.DifferentMethod3());
+
+ // Ensure each VTable method points to the correct method on HideBaseMethods
+ for (int i = 3; i < 9; i++)
+ {
+ var (__this, __vtable_native) = ((global::System.Runtime.InteropServices.Marshalling.IUnmanagedVirtualMethodTableProvider)obj3).GetVirtualMethodTableInfoForKey(typeof(global::SharedTypes.ComInterfaces.IHide3));
+ int __retVal;
+ int __invokeRetVal;
+ __invokeRetVal = ((delegate* unmanaged[MemberFunction]<void*, int*, int>)__vtable_native[i])(__this, &__retVal);
+ Assert.Equal(i, __retVal);
+ }
+ }
  }
 }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/CodeSnippets.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -109,8 +110,6 @@ public static StatelessCollectionAllShapes<TManagedElement> AllocateContainerFor
  }
  """;
 
- public static readonly string DisableRuntimeMarshalling = "[assembly:System.Runtime.CompilerServices.DisableRuntimeMarshalling]";
- public static readonly string UsingSystemRuntimeInteropServicesMarshalling = "using System.Runtime.InteropServices.Marshalling;";
  public const string IntMarshaller = """
  [CustomMarshaller(typeof(int), MarshalMode.Default, typeof(IntMarshaller))]
  internal static class IntMarshaller
@@ -433,6 +432,87 @@ partial interface INativeAPI
  {{_attributeProvider.AdditionalUserRequiredInterfaces("INativeAPI")}}
  """;
 
+ public string DerivedComInterfaceTypeWithShadowingMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method2();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method2();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsComAndNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeTwoLevelShadows => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface1: IComInterface
+ {
+ new void Method1();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface1
+ {
+ new void Method();
+ }
+ """;
+
  public string DerivedComInterfaceType => $$"""
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/Compiles.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using Microsoft.DotNet.XUnitExtensions.Attributes;
 using Microsoft.Interop.UnitTests;
 using Xunit;
 using VerifyComInterfaceGenerator = Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier<Microsoft.Interop.ComInterfaceGenerator>;
@@ -336,6 +335,10 @@ public static IEnumerable<object[]> ComInterfaceSnippetsToCompile()
  {
  CodeSnippets codeSnippets = new(new GeneratedComInterfaceAttributeProvider());
  yield return new object[] { ID(), codeSnippets.DerivedComInterfaceType };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeWithShadowingMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsComAndNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeTwoLevelShadows};
  yield return new object[] { ID(), codeSnippets.DerivedWithParametersDeclaredInOtherNamespace };
  yield return new object[] { ID(), codeSnippets.ComInterfaceParameters };
  }

src/libraries/System.Runtime.InteropServices/tests/TestAssets/SharedTypes/ComInterfaces/IHide.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;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+namespace SharedTypes.ComInterfaces
+{
+ [GeneratedComInterface]
+ [Guid("023EA72A-ECAA-4B65-9D96-2122CFADE16C")]
+ internal partial interface IHide
+ {
+ int SameMethod();
+ int DifferentMethod();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5293B3B1-4994-425C-803E-A21A5011E077")]
+ internal partial interface IHide2 : IHide
+ {
+ new int SameMethod();
+ int DifferentMethod2();
+ }
+
+ internal interface UnrelatedInterfaceWithSameMethod
+ {
+ int SameMethod();
+ int DifferentMethod3();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5DD35432-4987-488D-94F1-7682D7E4405C")]
+ internal partial interface IHide3 : IHide2, UnrelatedInterfaceWithSameMethod
+ {
+ new int SameMethod();
+ new int DifferentMethod3();
+ }
+
+ [GeneratedComClass]
+ [Guid("2D36BD6D-C80E-4F00-86E9-8D1B4A0CB59A")]
+ /// <summary>
+ /// Implements IHides3 and returns the expected VTable index for each method.
+ /// </summary>
+ internal partial class HideBaseMethods : IHide3
+ {
+ int IHide.SameMethod() => 3;
+ int IHide.DifferentMethod() => 4;
+ int IHide2.SameMethod() => 5;
+ int IHide2.DifferentMethod2() => 6;
+ int IHide3.SameMethod() => 7;
+ int IHide3.DifferentMethod3() => 8;
+ int UnrelatedInterfaceWithSameMethod.SameMethod() => -1;
+ int UnrelatedInterfaceWithSameMethod.DifferentMethod3() => -1;
+ }
+}

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

@@ -17,9 +17,14 @@ internal sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interfa
  /// </summary>
  public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
 
+ /// <summary>
+ /// COM methods that require shadowing declarations on the derived interface.
+ /// </summary>
+ public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod && !m.IsHiddenOnDerivedInterface);
+
  /// <summary>
  /// COM methods that are declared on an interface the interface inherits from.
  /// </summary>
- public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+ public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.IsInheritedMethod);
  }
 }

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

@@ -127,7 +127,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .WithComparer(SyntaxEquivalentComparer.Instance)
  .SelectNormalized();
 
- var shadowingMethods = interfaceAndMethodsContexts
+ var shadowingMethodDeclarations = interfaceAndMethodsContexts
  .Select((data, ct) =>
  {
  var context = data.Interface.Info;
@@ -163,7 +163,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .Zip(nativeToManagedVtableMethods)
  .Zip(nativeToManagedVtables)
  .Zip(iUnknownDerivedAttributeApplication)
- .Zip(shadowingMethods)
+ .Zip(shadowingMethodDeclarations)
  .Select(static (data, ct) =>
  {
  var ((((((interfaceContext, interfaceInfo), managedToNativeStubs), nativeToManagedStubs), nativeToManagedVtable), iUnknownDerivedAttribute), shadowingMethod) = data;
@@ -352,7 +352,7 @@ private static IncrementalMethodStubGenerationContext CalculateStubInformation(M
 
  var containingSyntaxContext = new ContainingSyntaxContext(syntax);
 
- var methodSyntaxTemplate = new ContainingSyntax(syntax.Modifiers.StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
+ var methodSyntaxTemplate = new ContainingSyntax(new SyntaxTokenList(syntax.Modifiers.Where(static m => !m.IsKind(SyntaxKind.NewKeyword))).StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
 
  ImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> callConv = VirtualMethodPointerStubGenerator.GenerateCallConvSyntaxFromAttributes(
  suppressGCTransitionAttribute,
@@ -423,11 +423,42 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  var methodList = ImmutableArray.CreateBuilder<ComMethodContext>();
  while (methodIndex < methods.Length && methods[methodIndex].OwningInterface == iface)
  {
+ var method = methods[methodIndex];
+ if (method.MethodInfo.IsUserDefinedShadowingMethod)
+ {
+ bool shadowFound = false;
+ int shadowIndex = -1;
+ // Don't remove method, but make it so that it doesn't generate any stubs
+ for (int i = methodList.Count - 1; i > -1; i--)
+ {
+ var potentialShadowedMethod = methodList[i];
+ if (MethodEquals(method, potentialShadowedMethod))
+ {
+ shadowFound = true;
+ shadowIndex = i;
+ break;
+ }
+ }
+ if (shadowFound)
+ {
+ methodList[shadowIndex].IsHiddenOnDerivedInterface = true;
+ }
+ // We might not find the shadowed method if it's defined on a non-GeneratedComInterface-attributed interface. Thats okay and we can disregard it.
+ }
  methodList.Add(methods[methodIndex++]);
  }
  contextList.Add(new(iface, methodList.ToImmutable().ToSequenceEqual()));
  }
  return contextList.ToImmutable();
+
+ static bool MethodEquals(ComMethodContext a, ComMethodContext b)
+ {
+ if (a.MethodInfo.MethodName != b.MethodInfo.MethodName)
+ return false;
+ if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))
+ return true;
+ return false;
+ }
  }
 
  private static readonly InterfaceDeclarationSyntax ImplementationInterfaceTemplate = InterfaceDeclaration("InterfaceImplementation")
@@ -436,12 +467,12 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  private static InterfaceDeclarationSyntax GenerateImplementationInterface(ComInterfaceAndMethodsContext interfaceGroup, CancellationToken _)
  {
  var definingType = interfaceGroup.Interface.Info.Type;
- var shadowImplementations = interfaceGroup.ShadowingMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
+ var shadowImplementations = interfaceGroup.InheritedMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
  .Where(p => p.ManagedToUnmanagedStub is GeneratedStubCodeContext)
  .Select(ctx => ((GeneratedStubCodeContext)ctx.ManagedToUnmanagedStub).Stub.Node
  .WithExplicitInterfaceSpecifier(
  ExplicitInterfaceSpecifier(ParseName(definingType.FullTypeName))));
- var inheritedStubs = interfaceGroup.ShadowingMethods.Select(m => m.UnreachableExceptionStub);
+ var inheritedStubs = interfaceGroup.InheritedMethods.Select(m => m.UnreachableExceptionStub);
  return ImplementationInterfaceTemplate
  .AddBaseListTypes(SimpleBaseType(definingType.Syntax))
  .WithMembers(
@@ -560,7 +591,7 @@ private static InterfaceDeclarationSyntax GenerateImplementationVTable(ComInterf
  ParenthesizedExpression(
  BinaryExpression(SyntaxKind.MultiplyExpression,
  SizeOfExpression(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword)))),
- LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.ShadowingMethods.Count() + 3))))))));
+ LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));
  }
 
  var vtableSlotAssignments = VirtualMethodPointerStubGenerator.GenerateVirtualMethodTableSlotAssignments(

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

@@ -69,13 +69,15 @@ public ComMethodContext(Builder builder, ComInterfaceContext owningInterface, In
 
  public bool IsInheritedMethod => OriginalDeclaringInterface != OwningInterface;
 
+ public bool IsHiddenOnDerivedInterface { get; set; }
+
  private GeneratedMethodContextBase? _managedToUnmanagedStub;
 
  public GeneratedMethodContextBase ManagedToUnmanagedStub => _managedToUnmanagedStub ??= CreateManagedToUnmanagedStub();
 
  private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(OriginalDeclaringInterface.Info.Type);
  }
@@ -89,7 +91,7 @@ private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
 
  private GeneratedMethodContextBase CreateUnmanagedToManagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(GenerationContext.OriginalDefiningType);
  }

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

@@ -17,7 +17,8 @@ namespace Microsoft.Interop
  internal sealed record ComMethodInfo(
  MethodDeclarationSyntax Syntax,
  string MethodName,
- SequenceEqualImmutableArray<AttributeInfo> Attributes)
+ SequenceEqualImmutableArray<AttributeInfo> Attributes,
+ bool IsUserDefinedShadowingMethod)
  {
  /// <summary>
  /// Returns a list of tuples of ComMethodInfo, IMethodSymbol, and Diagnostic. If ComMethodInfo is null, Diagnostic will not be null, and vice versa.
@@ -123,7 +124,9 @@ internal sealed record ComMethodInfo(
  {
  attributeInfos.Add(AttributeInfo.From(attr));
  }
- var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual());
+
+ bool shadowsBaseMethod = comMethodDeclaringSyntax.Modifiers.Any(SyntaxKind.NewKeyword);
+ var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);
  return DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From((comMethodInfo, method));
  }
  }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/RcwAroundCcwTests.cs

@@ -386,5 +386,39 @@ public void IStringArrayMarshallingFails_Failing()
  obj.ByValueOutParam(strings);
  });
  }
+
+ [Fact]
+ public unsafe void IHideWorksAsExpected()
+ {
+ IHide obj = CreateWrapper<HideBaseMethods, IHide3>();
+
+ // IHide.SameMethod should be index 3
+ Assert.Equal(3, obj.SameMethod());
+ Assert.Equal(4, obj.DifferentMethod());
+
+ IHide2 obj2 = (IHide2)obj;
+
+ // IHide2.SameMethod should be index 5
+ Assert.Equal(5, obj2.SameMethod());
+ Assert.Equal(4, obj2.DifferentMethod());
+ Assert.Equal(6, obj2.DifferentMethod2());
+
+ IHide3 obj3 = (IHide3)obj;
+ // IHide3.SameMethod should be index 7
+ Assert.Equal(7, obj3.SameMethod());
+ Assert.Equal(4, obj3.DifferentMethod());
+ Assert.Equal(6, obj3.DifferentMethod2());
+ Assert.Equal(8, obj3.DifferentMethod3());
+
+ // Ensure each VTable method points to the correct method on HideBaseMethods
+ for (int i = 3; i < 9; i++)
+ {
+ var (__this, __vtable_native) = ((global::System.Runtime.InteropServices.Marshalling.IUnmanagedVirtualMethodTableProvider)obj3).GetVirtualMethodTableInfoForKey(typeof(global::SharedTypes.ComInterfaces.IHide3));
+ int __retVal;
+ int __invokeRetVal;
+ __invokeRetVal = ((delegate* unmanaged[MemberFunction]<void*, int*, int>)__vtable_native[i])(__this, &__retVal);
+ Assert.Equal(i, __retVal);
+ }
+ }
  }
 }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/CodeSnippets.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -109,8 +110,6 @@ public static StatelessCollectionAllShapes<TManagedElement> AllocateContainerFor
  }
  """;
 
- public static readonly string DisableRuntimeMarshalling = "[assembly:System.Runtime.CompilerServices.DisableRuntimeMarshalling]";
- public static readonly string UsingSystemRuntimeInteropServicesMarshalling = "using System.Runtime.InteropServices.Marshalling;";
  public const string IntMarshaller = """
  [CustomMarshaller(typeof(int), MarshalMode.Default, typeof(IntMarshaller))]
  internal static class IntMarshaller
@@ -433,6 +432,87 @@ partial interface INativeAPI
  {{_attributeProvider.AdditionalUserRequiredInterfaces("INativeAPI")}}
  """;
 
+ public string DerivedComInterfaceTypeWithShadowingMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method2();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method2();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsComAndNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeTwoLevelShadows => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface1: IComInterface
+ {
+ new void Method1();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface1
+ {
+ new void Method();
+ }
+ """;
+
  public string DerivedComInterfaceType => $$"""
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/Compiles.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using Microsoft.DotNet.XUnitExtensions.Attributes;
 using Microsoft.Interop.UnitTests;
 using Xunit;
 using VerifyComInterfaceGenerator = Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier<Microsoft.Interop.ComInterfaceGenerator>;
@@ -336,6 +335,10 @@ public static IEnumerable<object[]> ComInterfaceSnippetsToCompile()
  {
  CodeSnippets codeSnippets = new(new GeneratedComInterfaceAttributeProvider());
  yield return new object[] { ID(), codeSnippets.DerivedComInterfaceType };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeWithShadowingMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsComAndNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeTwoLevelShadows};
  yield return new object[] { ID(), codeSnippets.DerivedWithParametersDeclaredInOtherNamespace };
  yield return new object[] { ID(), codeSnippets.ComInterfaceParameters };
  }

src/libraries/System.Runtime.InteropServices/tests/TestAssets/SharedTypes/ComInterfaces/IHide.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;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+namespace SharedTypes.ComInterfaces
+{
+ [GeneratedComInterface]
+ [Guid("023EA72A-ECAA-4B65-9D96-2122CFADE16C")]
+ internal partial interface IHide
+ {
+ int SameMethod();
+ int DifferentMethod();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5293B3B1-4994-425C-803E-A21A5011E077")]
+ internal partial interface IHide2 : IHide
+ {
+ new int SameMethod();
+ int DifferentMethod2();
+ }
+
+ internal interface UnrelatedInterfaceWithSameMethod
+ {
+ int SameMethod();
+ int DifferentMethod3();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5DD35432-4987-488D-94F1-7682D7E4405C")]
+ internal partial interface IHide3 : IHide2, UnrelatedInterfaceWithSameMethod
+ {
+ new int SameMethod();
+ new int DifferentMethod3();
+ }
+
+ [GeneratedComClass]
+ [Guid("2D36BD6D-C80E-4F00-86E9-8D1B4A0CB59A")]
+ /// <summary>
+ /// Implements IHides3 and returns the expected VTable index for each method.
+ /// </summary>
+ internal partial class HideBaseMethods : IHide3
+ {
+ int IHide.SameMethod() => 3;
+ int IHide.DifferentMethod() => 4;
+ int IHide2.SameMethod() => 5;
+ int IHide2.DifferentMethod2() => 6;
+ int IHide3.SameMethod() => 7;
+ int IHide3.DifferentMethod3() => 8;
+ int UnrelatedInterfaceWithSameMethod.SameMethod() => -1;
+ int UnrelatedInterfaceWithSameMethod.DifferentMethod3() => -1;
+ }
+}

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

@@ -17,9 +17,14 @@ internal sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interfa
  /// </summary>
  public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
 
+ /// <summary>
+ /// COM methods that require shadowing declarations on the derived interface.
+ /// </summary>
+ public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod && !m.IsHiddenOnDerivedInterface);
+
  /// <summary>
  /// COM methods that are declared on an interface the interface inherits from.
  /// </summary>
- public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+ public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.IsInheritedMethod);
  }
 }

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

@@ -127,7 +127,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .WithComparer(SyntaxEquivalentComparer.Instance)
  .SelectNormalized();
 
- var shadowingMethods = interfaceAndMethodsContexts
+ var shadowingMethodDeclarations = interfaceAndMethodsContexts
  .Select((data, ct) =>
  {
  var context = data.Interface.Info;
@@ -163,7 +163,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .Zip(nativeToManagedVtableMethods)
  .Zip(nativeToManagedVtables)
  .Zip(iUnknownDerivedAttributeApplication)
- .Zip(shadowingMethods)
+ .Zip(shadowingMethodDeclarations)
  .Select(static (data, ct) =>
  {
  var ((((((interfaceContext, interfaceInfo), managedToNativeStubs), nativeToManagedStubs), nativeToManagedVtable), iUnknownDerivedAttribute), shadowingMethod) = data;
@@ -352,7 +352,7 @@ private static IncrementalMethodStubGenerationContext CalculateStubInformation(M
 
  var containingSyntaxContext = new ContainingSyntaxContext(syntax);
 
- var methodSyntaxTemplate = new ContainingSyntax(syntax.Modifiers.StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
+ var methodSyntaxTemplate = new ContainingSyntax(new SyntaxTokenList(syntax.Modifiers.Where(static m => !m.IsKind(SyntaxKind.NewKeyword))).StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
 
  ImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> callConv = VirtualMethodPointerStubGenerator.GenerateCallConvSyntaxFromAttributes(
  suppressGCTransitionAttribute,
@@ -423,11 +423,42 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  var methodList = ImmutableArray.CreateBuilder<ComMethodContext>();
  while (methodIndex < methods.Length && methods[methodIndex].OwningInterface == iface)
  {
+ var method = methods[methodIndex];
+ if (method.MethodInfo.IsUserDefinedShadowingMethod)
+ {
+ bool shadowFound = false;
+ int shadowIndex = -1;
+ // Don't remove method, but make it so that it doesn't generate any stubs
+ for (int i = methodList.Count - 1; i > -1; i--)
+ {
+ var potentialShadowedMethod = methodList[i];
+ if (MethodEquals(method, potentialShadowedMethod))
+ {
+ shadowFound = true;
+ shadowIndex = i;
+ break;
+ }
+ }
+ if (shadowFound)
+ {
+ methodList[shadowIndex].IsHiddenOnDerivedInterface = true;
+ }
+ // We might not find the shadowed method if it's defined on a non-GeneratedComInterface-attributed interface. Thats okay and we can disregard it.
+ }
  methodList.Add(methods[methodIndex++]);
  }
  contextList.Add(new(iface, methodList.ToImmutable().ToSequenceEqual()));
  }
  return contextList.ToImmutable();
+
+ static bool MethodEquals(ComMethodContext a, ComMethodContext b)
+ {
+ if (a.MethodInfo.MethodName != b.MethodInfo.MethodName)
+ return false;
+ if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))
+ return true;
+ return false;
+ }
  }
 
  private static readonly InterfaceDeclarationSyntax ImplementationInterfaceTemplate = InterfaceDeclaration("InterfaceImplementation")
@@ -436,12 +467,12 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  private static InterfaceDeclarationSyntax GenerateImplementationInterface(ComInterfaceAndMethodsContext interfaceGroup, CancellationToken _)
  {
  var definingType = interfaceGroup.Interface.Info.Type;
- var shadowImplementations = interfaceGroup.ShadowingMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
+ var shadowImplementations = interfaceGroup.InheritedMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
  .Where(p => p.ManagedToUnmanagedStub is GeneratedStubCodeContext)
  .Select(ctx => ((GeneratedStubCodeContext)ctx.ManagedToUnmanagedStub).Stub.Node
  .WithExplicitInterfaceSpecifier(
  ExplicitInterfaceSpecifier(ParseName(definingType.FullTypeName))));
- var inheritedStubs = interfaceGroup.ShadowingMethods.Select(m => m.UnreachableExceptionStub);
+ var inheritedStubs = interfaceGroup.InheritedMethods.Select(m => m.UnreachableExceptionStub);
  return ImplementationInterfaceTemplate
  .AddBaseListTypes(SimpleBaseType(definingType.Syntax))
  .WithMembers(
@@ -560,7 +591,7 @@ private static InterfaceDeclarationSyntax GenerateImplementationVTable(ComInterf
  ParenthesizedExpression(
  BinaryExpression(SyntaxKind.MultiplyExpression,
  SizeOfExpression(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword)))),
- LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.ShadowingMethods.Count() + 3))))))));
+ LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));
  }
 
  var vtableSlotAssignments = VirtualMethodPointerStubGenerator.GenerateVirtualMethodTableSlotAssignments(

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

@@ -69,13 +69,15 @@ public ComMethodContext(Builder builder, ComInterfaceContext owningInterface, In
 
  public bool IsInheritedMethod => OriginalDeclaringInterface != OwningInterface;
 
+ public bool IsHiddenOnDerivedInterface { get; set; }
+
  private GeneratedMethodContextBase? _managedToUnmanagedStub;
 
  public GeneratedMethodContextBase ManagedToUnmanagedStub => _managedToUnmanagedStub ??= CreateManagedToUnmanagedStub();
 
  private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(OriginalDeclaringInterface.Info.Type);
  }
@@ -89,7 +91,7 @@ private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
 
  private GeneratedMethodContextBase CreateUnmanagedToManagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(GenerationContext.OriginalDefiningType);
  }

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

@@ -17,7 +17,8 @@ namespace Microsoft.Interop
  internal sealed record ComMethodInfo(
  MethodDeclarationSyntax Syntax,
  string MethodName,
- SequenceEqualImmutableArray<AttributeInfo> Attributes)
+ SequenceEqualImmutableArray<AttributeInfo> Attributes,
+ bool IsUserDefinedShadowingMethod)
  {
  /// <summary>
  /// Returns a list of tuples of ComMethodInfo, IMethodSymbol, and Diagnostic. If ComMethodInfo is null, Diagnostic will not be null, and vice versa.
@@ -123,7 +124,9 @@ internal sealed record ComMethodInfo(
  {
  attributeInfos.Add(AttributeInfo.From(attr));
  }
- var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual());
+
+ bool shadowsBaseMethod = comMethodDeclaringSyntax.Modifiers.Any(SyntaxKind.NewKeyword);
+ var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);
  return DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From((comMethodInfo, method));
  }
  }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/RcwAroundCcwTests.cs

@@ -386,5 +386,39 @@ public void IStringArrayMarshallingFails_Failing()
  obj.ByValueOutParam(strings);
  });
  }
+
+ [Fact]
+ public unsafe void IHideWorksAsExpected()
+ {
+ IHide obj = CreateWrapper<HideBaseMethods, IHide3>();
+
+ // IHide.SameMethod should be index 3
+ Assert.Equal(3, obj.SameMethod());
+ Assert.Equal(4, obj.DifferentMethod());
+
+ IHide2 obj2 = (IHide2)obj;
+
+ // IHide2.SameMethod should be index 5
+ Assert.Equal(5, obj2.SameMethod());
+ Assert.Equal(4, obj2.DifferentMethod());
+ Assert.Equal(6, obj2.DifferentMethod2());
+
+ IHide3 obj3 = (IHide3)obj;
+ // IHide3.SameMethod should be index 7
+ Assert.Equal(7, obj3.SameMethod());
+ Assert.Equal(4, obj3.DifferentMethod());
+ Assert.Equal(6, obj3.DifferentMethod2());
+ Assert.Equal(8, obj3.DifferentMethod3());
+
+ // Ensure each VTable method points to the correct method on HideBaseMethods
+ for (int i = 3; i < 9; i++)
+ {
+ var (__this, __vtable_native) = ((global::System.Runtime.InteropServices.Marshalling.IUnmanagedVirtualMethodTableProvider)obj3).GetVirtualMethodTableInfoForKey(typeof(global::SharedTypes.ComInterfaces.IHide3));
+ int __retVal;
+ int __invokeRetVal;
+ __invokeRetVal = ((delegate* unmanaged[MemberFunction]<void*, int*, int>)__vtable_native[i])(__this, &__retVal);
+ Assert.Equal(i, __retVal);
+ }
+ }
  }
 }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/CodeSnippets.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -109,8 +110,6 @@ public static StatelessCollectionAllShapes<TManagedElement> AllocateContainerFor
  }
  """;
 
- public static readonly string DisableRuntimeMarshalling = "[assembly:System.Runtime.CompilerServices.DisableRuntimeMarshalling]";
- public static readonly string UsingSystemRuntimeInteropServicesMarshalling = "using System.Runtime.InteropServices.Marshalling;";
  public const string IntMarshaller = """
  [CustomMarshaller(typeof(int), MarshalMode.Default, typeof(IntMarshaller))]
  internal static class IntMarshaller
@@ -433,6 +432,87 @@ partial interface INativeAPI
  {{_attributeProvider.AdditionalUserRequiredInterfaces("INativeAPI")}}
  """;
 
+ public string DerivedComInterfaceTypeWithShadowingMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method2();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method2();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsComAndNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeTwoLevelShadows => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface1: IComInterface
+ {
+ new void Method1();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface1
+ {
+ new void Method();
+ }
+ """;
+
  public string DerivedComInterfaceType => $$"""
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/Compiles.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using Microsoft.DotNet.XUnitExtensions.Attributes;
 using Microsoft.Interop.UnitTests;
 using Xunit;
 using VerifyComInterfaceGenerator = Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier<Microsoft.Interop.ComInterfaceGenerator>;
@@ -336,6 +335,10 @@ public static IEnumerable<object[]> ComInterfaceSnippetsToCompile()
  {
  CodeSnippets codeSnippets = new(new GeneratedComInterfaceAttributeProvider());
  yield return new object[] { ID(), codeSnippets.DerivedComInterfaceType };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeWithShadowingMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsComAndNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeTwoLevelShadows};
  yield return new object[] { ID(), codeSnippets.DerivedWithParametersDeclaredInOtherNamespace };
  yield return new object[] { ID(), codeSnippets.ComInterfaceParameters };
  }

src/libraries/System.Runtime.InteropServices/tests/TestAssets/SharedTypes/ComInterfaces/IHide.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;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+namespace SharedTypes.ComInterfaces
+{
+ [GeneratedComInterface]
+ [Guid("023EA72A-ECAA-4B65-9D96-2122CFADE16C")]
+ internal partial interface IHide
+ {
+ int SameMethod();
+ int DifferentMethod();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5293B3B1-4994-425C-803E-A21A5011E077")]
+ internal partial interface IHide2 : IHide
+ {
+ new int SameMethod();
+ int DifferentMethod2();
+ }
+
+ internal interface UnrelatedInterfaceWithSameMethod
+ {
+ int SameMethod();
+ int DifferentMethod3();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5DD35432-4987-488D-94F1-7682D7E4405C")]
+ internal partial interface IHide3 : IHide2, UnrelatedInterfaceWithSameMethod
+ {
+ new int SameMethod();
+ new int DifferentMethod3();
+ }
+
+ [GeneratedComClass]
+ [Guid("2D36BD6D-C80E-4F00-86E9-8D1B4A0CB59A")]
+ /// <summary>
+ /// Implements IHides3 and returns the expected VTable index for each method.
+ /// </summary>
+ internal partial class HideBaseMethods : IHide3
+ {
+ int IHide.SameMethod() => 3;
+ int IHide.DifferentMethod() => 4;
+ int IHide2.SameMethod() => 5;
+ int IHide2.DifferentMethod2() => 6;
+ int IHide3.SameMethod() => 7;
+ int IHide3.DifferentMethod3() => 8;
+ int UnrelatedInterfaceWithSameMethod.SameMethod() => -1;
+ int UnrelatedInterfaceWithSameMethod.DifferentMethod3() => -1;
+ }
+}

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

@@ -17,9 +17,14 @@ internal sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interfa
  /// </summary>
  public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
 
+ /// <summary>
+ /// COM methods that require shadowing declarations on the derived interface.
+ /// </summary>
+ public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod && !m.IsHiddenOnDerivedInterface);
+
  /// <summary>
  /// COM methods that are declared on an interface the interface inherits from.
  /// </summary>
- public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+ public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.IsInheritedMethod);
  }
 }

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

@@ -127,7 +127,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .WithComparer(SyntaxEquivalentComparer.Instance)
  .SelectNormalized();
 
- var shadowingMethods = interfaceAndMethodsContexts
+ var shadowingMethodDeclarations = interfaceAndMethodsContexts
  .Select((data, ct) =>
  {
  var context = data.Interface.Info;
@@ -163,7 +163,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .Zip(nativeToManagedVtableMethods)
  .Zip(nativeToManagedVtables)
  .Zip(iUnknownDerivedAttributeApplication)
- .Zip(shadowingMethods)
+ .Zip(shadowingMethodDeclarations)
  .Select(static (data, ct) =>
  {
  var ((((((interfaceContext, interfaceInfo), managedToNativeStubs), nativeToManagedStubs), nativeToManagedVtable), iUnknownDerivedAttribute), shadowingMethod) = data;
@@ -352,7 +352,7 @@ private static IncrementalMethodStubGenerationContext CalculateStubInformation(M
 
  var containingSyntaxContext = new ContainingSyntaxContext(syntax);
 
- var methodSyntaxTemplate = new ContainingSyntax(syntax.Modifiers.StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
+ var methodSyntaxTemplate = new ContainingSyntax(new SyntaxTokenList(syntax.Modifiers.Where(static m => !m.IsKind(SyntaxKind.NewKeyword))).StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
 
  ImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> callConv = VirtualMethodPointerStubGenerator.GenerateCallConvSyntaxFromAttributes(
  suppressGCTransitionAttribute,
@@ -423,11 +423,42 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  var methodList = ImmutableArray.CreateBuilder<ComMethodContext>();
  while (methodIndex < methods.Length && methods[methodIndex].OwningInterface == iface)
  {
+ var method = methods[methodIndex];
+ if (method.MethodInfo.IsUserDefinedShadowingMethod)
+ {
+ bool shadowFound = false;
+ int shadowIndex = -1;
+ // Don't remove method, but make it so that it doesn't generate any stubs
+ for (int i = methodList.Count - 1; i > -1; i--)
+ {
+ var potentialShadowedMethod = methodList[i];
+ if (MethodEquals(method, potentialShadowedMethod))
+ {
+ shadowFound = true;
+ shadowIndex = i;
+ break;
+ }
+ }
+ if (shadowFound)
+ {
+ methodList[shadowIndex].IsHiddenOnDerivedInterface = true;
+ }
+ // We might not find the shadowed method if it's defined on a non-GeneratedComInterface-attributed interface. Thats okay and we can disregard it.
+ }
  methodList.Add(methods[methodIndex++]);
  }
  contextList.Add(new(iface, methodList.ToImmutable().ToSequenceEqual()));
  }
  return contextList.ToImmutable();
+
+ static bool MethodEquals(ComMethodContext a, ComMethodContext b)
+ {
+ if (a.MethodInfo.MethodName != b.MethodInfo.MethodName)
+ return false;
+ if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))
+ return true;
+ return false;
+ }
  }
 
  private static readonly InterfaceDeclarationSyntax ImplementationInterfaceTemplate = InterfaceDeclaration("InterfaceImplementation")
@@ -436,12 +467,12 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  private static InterfaceDeclarationSyntax GenerateImplementationInterface(ComInterfaceAndMethodsContext interfaceGroup, CancellationToken _)
  {
  var definingType = interfaceGroup.Interface.Info.Type;
- var shadowImplementations = interfaceGroup.ShadowingMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
+ var shadowImplementations = interfaceGroup.InheritedMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
  .Where(p => p.ManagedToUnmanagedStub is GeneratedStubCodeContext)
  .Select(ctx => ((GeneratedStubCodeContext)ctx.ManagedToUnmanagedStub).Stub.Node
  .WithExplicitInterfaceSpecifier(
  ExplicitInterfaceSpecifier(ParseName(definingType.FullTypeName))));
- var inheritedStubs = interfaceGroup.ShadowingMethods.Select(m => m.UnreachableExceptionStub);
+ var inheritedStubs = interfaceGroup.InheritedMethods.Select(m => m.UnreachableExceptionStub);
  return ImplementationInterfaceTemplate
  .AddBaseListTypes(SimpleBaseType(definingType.Syntax))
  .WithMembers(
@@ -560,7 +591,7 @@ private static InterfaceDeclarationSyntax GenerateImplementationVTable(ComInterf
  ParenthesizedExpression(
  BinaryExpression(SyntaxKind.MultiplyExpression,
  SizeOfExpression(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword)))),
- LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.ShadowingMethods.Count() + 3))))))));
+ LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));
  }
 
  var vtableSlotAssignments = VirtualMethodPointerStubGenerator.GenerateVirtualMethodTableSlotAssignments(

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

@@ -69,13 +69,15 @@ public ComMethodContext(Builder builder, ComInterfaceContext owningInterface, In
 
  public bool IsInheritedMethod => OriginalDeclaringInterface != OwningInterface;
 
+ public bool IsHiddenOnDerivedInterface { get; set; }
+
  private GeneratedMethodContextBase? _managedToUnmanagedStub;
 
  public GeneratedMethodContextBase ManagedToUnmanagedStub => _managedToUnmanagedStub ??= CreateManagedToUnmanagedStub();
 
  private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(OriginalDeclaringInterface.Info.Type);
  }
@@ -89,7 +91,7 @@ private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
 
  private GeneratedMethodContextBase CreateUnmanagedToManagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(GenerationContext.OriginalDefiningType);
  }

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

@@ -17,7 +17,8 @@ namespace Microsoft.Interop
  internal sealed record ComMethodInfo(
  MethodDeclarationSyntax Syntax,
  string MethodName,
- SequenceEqualImmutableArray<AttributeInfo> Attributes)
+ SequenceEqualImmutableArray<AttributeInfo> Attributes,
+ bool IsUserDefinedShadowingMethod)
  {
  /// <summary>
  /// Returns a list of tuples of ComMethodInfo, IMethodSymbol, and Diagnostic. If ComMethodInfo is null, Diagnostic will not be null, and vice versa.
@@ -123,7 +124,9 @@ internal sealed record ComMethodInfo(
  {
  attributeInfos.Add(AttributeInfo.From(attr));
  }
- var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual());
+
+ bool shadowsBaseMethod = comMethodDeclaringSyntax.Modifiers.Any(SyntaxKind.NewKeyword);
+ var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);
  return DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From((comMethodInfo, method));
  }
  }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/RcwAroundCcwTests.cs

@@ -386,5 +386,39 @@ public void IStringArrayMarshallingFails_Failing()
  obj.ByValueOutParam(strings);
  });
  }
+
+ [Fact]
+ public unsafe void IHideWorksAsExpected()
+ {
+ IHide obj = CreateWrapper<HideBaseMethods, IHide3>();
+
+ // IHide.SameMethod should be index 3
+ Assert.Equal(3, obj.SameMethod());
+ Assert.Equal(4, obj.DifferentMethod());
+
+ IHide2 obj2 = (IHide2)obj;
+
+ // IHide2.SameMethod should be index 5
+ Assert.Equal(5, obj2.SameMethod());
+ Assert.Equal(4, obj2.DifferentMethod());
+ Assert.Equal(6, obj2.DifferentMethod2());
+
+ IHide3 obj3 = (IHide3)obj;
+ // IHide3.SameMethod should be index 7
+ Assert.Equal(7, obj3.SameMethod());
+ Assert.Equal(4, obj3.DifferentMethod());
+ Assert.Equal(6, obj3.DifferentMethod2());
+ Assert.Equal(8, obj3.DifferentMethod3());
+
+ // Ensure each VTable method points to the correct method on HideBaseMethods
+ for (int i = 3; i < 9; i++)
+ {
+ var (__this, __vtable_native) = ((global::System.Runtime.InteropServices.Marshalling.IUnmanagedVirtualMethodTableProvider)obj3).GetVirtualMethodTableInfoForKey(typeof(global::SharedTypes.ComInterfaces.IHide3));
+ int __retVal;
+ int __invokeRetVal;
+ __invokeRetVal = ((delegate* unmanaged[MemberFunction]<void*, int*, int>)__vtable_native[i])(__this, &__retVal);
+ Assert.Equal(i, __retVal);
+ }
+ }
  }
 }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/CodeSnippets.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -109,8 +110,6 @@ public static StatelessCollectionAllShapes<TManagedElement> AllocateContainerFor
  }
  """;
 
- public static readonly string DisableRuntimeMarshalling = "[assembly:System.Runtime.CompilerServices.DisableRuntimeMarshalling]";
- public static readonly string UsingSystemRuntimeInteropServicesMarshalling = "using System.Runtime.InteropServices.Marshalling;";
  public const string IntMarshaller = """
  [CustomMarshaller(typeof(int), MarshalMode.Default, typeof(IntMarshaller))]
  internal static class IntMarshaller
@@ -433,6 +432,87 @@ partial interface INativeAPI
  {{_attributeProvider.AdditionalUserRequiredInterfaces("INativeAPI")}}
  """;
 
+ public string DerivedComInterfaceTypeWithShadowingMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method2();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method2();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsComAndNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeTwoLevelShadows => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface1: IComInterface
+ {
+ new void Method1();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface1
+ {
+ new void Method();
+ }
+ """;
+
  public string DerivedComInterfaceType => $$"""
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/Compiles.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using Microsoft.DotNet.XUnitExtensions.Attributes;
 using Microsoft.Interop.UnitTests;
 using Xunit;
 using VerifyComInterfaceGenerator = Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier<Microsoft.Interop.ComInterfaceGenerator>;
@@ -336,6 +335,10 @@ public static IEnumerable<object[]> ComInterfaceSnippetsToCompile()
  {
  CodeSnippets codeSnippets = new(new GeneratedComInterfaceAttributeProvider());
  yield return new object[] { ID(), codeSnippets.DerivedComInterfaceType };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeWithShadowingMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsComAndNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeTwoLevelShadows};
  yield return new object[] { ID(), codeSnippets.DerivedWithParametersDeclaredInOtherNamespace };
  yield return new object[] { ID(), codeSnippets.ComInterfaceParameters };
  }

src/libraries/System.Runtime.InteropServices/tests/TestAssets/SharedTypes/ComInterfaces/IHide.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;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+namespace SharedTypes.ComInterfaces
+{
+ [GeneratedComInterface]
+ [Guid("023EA72A-ECAA-4B65-9D96-2122CFADE16C")]
+ internal partial interface IHide
+ {
+ int SameMethod();
+ int DifferentMethod();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5293B3B1-4994-425C-803E-A21A5011E077")]
+ internal partial interface IHide2 : IHide
+ {
+ new int SameMethod();
+ int DifferentMethod2();
+ }
+
+ internal interface UnrelatedInterfaceWithSameMethod
+ {
+ int SameMethod();
+ int DifferentMethod3();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5DD35432-4987-488D-94F1-7682D7E4405C")]
+ internal partial interface IHide3 : IHide2, UnrelatedInterfaceWithSameMethod
+ {
+ new int SameMethod();
+ new int DifferentMethod3();
+ }
+
+ [GeneratedComClass]
+ [Guid("2D36BD6D-C80E-4F00-86E9-8D1B4A0CB59A")]
+ /// <summary>
+ /// Implements IHides3 and returns the expected VTable index for each method.
+ /// </summary>
+ internal partial class HideBaseMethods : IHide3
+ {
+ int IHide.SameMethod() => 3;
+ int IHide.DifferentMethod() => 4;
+ int IHide2.SameMethod() => 5;
+ int IHide2.DifferentMethod2() => 6;
+ int IHide3.SameMethod() => 7;
+ int IHide3.DifferentMethod3() => 8;
+ int UnrelatedInterfaceWithSameMethod.SameMethod() => -1;
+ int UnrelatedInterfaceWithSameMethod.DifferentMethod3() => -1;
+ }
+}

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

@@ -17,9 +17,14 @@ internal sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interfa
  /// </summary>
  public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
 
+ /// <summary>
+ /// COM methods that require shadowing declarations on the derived interface.
+ /// </summary>
+ public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod && !m.IsHiddenOnDerivedInterface);
+
  /// <summary>
  /// COM methods that are declared on an interface the interface inherits from.
  /// </summary>
- public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+ public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.IsInheritedMethod);
  }
 }

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

@@ -127,7 +127,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .WithComparer(SyntaxEquivalentComparer.Instance)
  .SelectNormalized();
 
- var shadowingMethods = interfaceAndMethodsContexts
+ var shadowingMethodDeclarations = interfaceAndMethodsContexts
  .Select((data, ct) =>
  {
  var context = data.Interface.Info;
@@ -163,7 +163,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .Zip(nativeToManagedVtableMethods)
  .Zip(nativeToManagedVtables)
  .Zip(iUnknownDerivedAttributeApplication)
- .Zip(shadowingMethods)
+ .Zip(shadowingMethodDeclarations)
  .Select(static (data, ct) =>
  {
  var ((((((interfaceContext, interfaceInfo), managedToNativeStubs), nativeToManagedStubs), nativeToManagedVtable), iUnknownDerivedAttribute), shadowingMethod) = data;
@@ -352,7 +352,7 @@ private static IncrementalMethodStubGenerationContext CalculateStubInformation(M
 
  var containingSyntaxContext = new ContainingSyntaxContext(syntax);
 
- var methodSyntaxTemplate = new ContainingSyntax(syntax.Modifiers.StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
+ var methodSyntaxTemplate = new ContainingSyntax(new SyntaxTokenList(syntax.Modifiers.Where(static m => !m.IsKind(SyntaxKind.NewKeyword))).StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
 
  ImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> callConv = VirtualMethodPointerStubGenerator.GenerateCallConvSyntaxFromAttributes(
  suppressGCTransitionAttribute,
@@ -423,11 +423,42 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  var methodList = ImmutableArray.CreateBuilder<ComMethodContext>();
  while (methodIndex < methods.Length && methods[methodIndex].OwningInterface == iface)
  {
+ var method = methods[methodIndex];
+ if (method.MethodInfo.IsUserDefinedShadowingMethod)
+ {
+ bool shadowFound = false;
+ int shadowIndex = -1;
+ // Don't remove method, but make it so that it doesn't generate any stubs
+ for (int i = methodList.Count - 1; i > -1; i--)
+ {
+ var potentialShadowedMethod = methodList[i];
+ if (MethodEquals(method, potentialShadowedMethod))
+ {
+ shadowFound = true;
+ shadowIndex = i;
+ break;
+ }
+ }
+ if (shadowFound)
+ {
+ methodList[shadowIndex].IsHiddenOnDerivedInterface = true;
+ }
+ // We might not find the shadowed method if it's defined on a non-GeneratedComInterface-attributed interface. Thats okay and we can disregard it.
+ }
  methodList.Add(methods[methodIndex++]);
  }
  contextList.Add(new(iface, methodList.ToImmutable().ToSequenceEqual()));
  }
  return contextList.ToImmutable();
+
+ static bool MethodEquals(ComMethodContext a, ComMethodContext b)
+ {
+ if (a.MethodInfo.MethodName != b.MethodInfo.MethodName)
+ return false;
+ if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))
+ return true;
+ return false;
+ }
  }
 
  private static readonly InterfaceDeclarationSyntax ImplementationInterfaceTemplate = InterfaceDeclaration("InterfaceImplementation")
@@ -436,12 +467,12 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  private static InterfaceDeclarationSyntax GenerateImplementationInterface(ComInterfaceAndMethodsContext interfaceGroup, CancellationToken _)
  {
  var definingType = interfaceGroup.Interface.Info.Type;
- var shadowImplementations = interfaceGroup.ShadowingMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
+ var shadowImplementations = interfaceGroup.InheritedMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
  .Where(p => p.ManagedToUnmanagedStub is GeneratedStubCodeContext)
  .Select(ctx => ((GeneratedStubCodeContext)ctx.ManagedToUnmanagedStub).Stub.Node
  .WithExplicitInterfaceSpecifier(
  ExplicitInterfaceSpecifier(ParseName(definingType.FullTypeName))));
- var inheritedStubs = interfaceGroup.ShadowingMethods.Select(m => m.UnreachableExceptionStub);
+ var inheritedStubs = interfaceGroup.InheritedMethods.Select(m => m.UnreachableExceptionStub);
  return ImplementationInterfaceTemplate
  .AddBaseListTypes(SimpleBaseType(definingType.Syntax))
  .WithMembers(
@@ -560,7 +591,7 @@ private static InterfaceDeclarationSyntax GenerateImplementationVTable(ComInterf
  ParenthesizedExpression(
  BinaryExpression(SyntaxKind.MultiplyExpression,
  SizeOfExpression(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword)))),
- LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.ShadowingMethods.Count() + 3))))))));
+ LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));
  }
 
  var vtableSlotAssignments = VirtualMethodPointerStubGenerator.GenerateVirtualMethodTableSlotAssignments(

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

@@ -69,13 +69,15 @@ public ComMethodContext(Builder builder, ComInterfaceContext owningInterface, In
 
  public bool IsInheritedMethod => OriginalDeclaringInterface != OwningInterface;
 
+ public bool IsHiddenOnDerivedInterface { get; set; }
+
  private GeneratedMethodContextBase? _managedToUnmanagedStub;
 
  public GeneratedMethodContextBase ManagedToUnmanagedStub => _managedToUnmanagedStub ??= CreateManagedToUnmanagedStub();
 
  private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(OriginalDeclaringInterface.Info.Type);
  }
@@ -89,7 +91,7 @@ private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
 
  private GeneratedMethodContextBase CreateUnmanagedToManagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(GenerationContext.OriginalDefiningType);
  }

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

@@ -17,7 +17,8 @@ namespace Microsoft.Interop
  internal sealed record ComMethodInfo(
  MethodDeclarationSyntax Syntax,
  string MethodName,
- SequenceEqualImmutableArray<AttributeInfo> Attributes)
+ SequenceEqualImmutableArray<AttributeInfo> Attributes,
+ bool IsUserDefinedShadowingMethod)
  {
  /// <summary>
  /// Returns a list of tuples of ComMethodInfo, IMethodSymbol, and Diagnostic. If ComMethodInfo is null, Diagnostic will not be null, and vice versa.
@@ -123,7 +124,9 @@ internal sealed record ComMethodInfo(
  {
  attributeInfos.Add(AttributeInfo.From(attr));
  }
- var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual());
+
+ bool shadowsBaseMethod = comMethodDeclaringSyntax.Modifiers.Any(SyntaxKind.NewKeyword);
+ var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);
  return DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From((comMethodInfo, method));
  }
  }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/RcwAroundCcwTests.cs

@@ -386,5 +386,39 @@ public void IStringArrayMarshallingFails_Failing()
  obj.ByValueOutParam(strings);
  });
  }
+
+ [Fact]
+ public unsafe void IHideWorksAsExpected()
+ {
+ IHide obj = CreateWrapper<HideBaseMethods, IHide3>();
+
+ // IHide.SameMethod should be index 3
+ Assert.Equal(3, obj.SameMethod());
+ Assert.Equal(4, obj.DifferentMethod());
+
+ IHide2 obj2 = (IHide2)obj;
+
+ // IHide2.SameMethod should be index 5
+ Assert.Equal(5, obj2.SameMethod());
+ Assert.Equal(4, obj2.DifferentMethod());
+ Assert.Equal(6, obj2.DifferentMethod2());
+
+ IHide3 obj3 = (IHide3)obj;
+ // IHide3.SameMethod should be index 7
+ Assert.Equal(7, obj3.SameMethod());
+ Assert.Equal(4, obj3.DifferentMethod());
+ Assert.Equal(6, obj3.DifferentMethod2());
+ Assert.Equal(8, obj3.DifferentMethod3());
+
+ // Ensure each VTable method points to the correct method on HideBaseMethods
+ for (int i = 3; i < 9; i++)
+ {
+ var (__this, __vtable_native) = ((global::System.Runtime.InteropServices.Marshalling.IUnmanagedVirtualMethodTableProvider)obj3).GetVirtualMethodTableInfoForKey(typeof(global::SharedTypes.ComInterfaces.IHide3));
+ int __retVal;
+ int __invokeRetVal;
+ __invokeRetVal = ((delegate* unmanaged[MemberFunction]<void*, int*, int>)__vtable_native[i])(__this, &__retVal);
+ Assert.Equal(i, __retVal);
+ }
+ }
  }
 }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/CodeSnippets.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -109,8 +110,6 @@ public static StatelessCollectionAllShapes<TManagedElement> AllocateContainerFor
  }
  """;
 
- public static readonly string DisableRuntimeMarshalling = "[assembly:System.Runtime.CompilerServices.DisableRuntimeMarshalling]";
- public static readonly string UsingSystemRuntimeInteropServicesMarshalling = "using System.Runtime.InteropServices.Marshalling;";
  public const string IntMarshaller = """
  [CustomMarshaller(typeof(int), MarshalMode.Default, typeof(IntMarshaller))]
  internal static class IntMarshaller
@@ -433,6 +432,87 @@ partial interface INativeAPI
  {{_attributeProvider.AdditionalUserRequiredInterfaces("INativeAPI")}}
  """;
 
+ public string DerivedComInterfaceTypeWithShadowingMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method2();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method2();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsComAndNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeTwoLevelShadows => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface1: IComInterface
+ {
+ new void Method1();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface1
+ {
+ new void Method();
+ }
+ """;
+
  public string DerivedComInterfaceType => $$"""
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/Compiles.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using Microsoft.DotNet.XUnitExtensions.Attributes;
 using Microsoft.Interop.UnitTests;
 using Xunit;
 using VerifyComInterfaceGenerator = Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier<Microsoft.Interop.ComInterfaceGenerator>;
@@ -336,6 +335,10 @@ public static IEnumerable<object[]> ComInterfaceSnippetsToCompile()
  {
  CodeSnippets codeSnippets = new(new GeneratedComInterfaceAttributeProvider());
  yield return new object[] { ID(), codeSnippets.DerivedComInterfaceType };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeWithShadowingMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsComAndNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeTwoLevelShadows};
  yield return new object[] { ID(), codeSnippets.DerivedWithParametersDeclaredInOtherNamespace };
  yield return new object[] { ID(), codeSnippets.ComInterfaceParameters };
  }

src/libraries/System.Runtime.InteropServices/tests/TestAssets/SharedTypes/ComInterfaces/IHide.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;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+namespace SharedTypes.ComInterfaces
+{
+ [GeneratedComInterface]
+ [Guid("023EA72A-ECAA-4B65-9D96-2122CFADE16C")]
+ internal partial interface IHide
+ {
+ int SameMethod();
+ int DifferentMethod();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5293B3B1-4994-425C-803E-A21A5011E077")]
+ internal partial interface IHide2 : IHide
+ {
+ new int SameMethod();
+ int DifferentMethod2();
+ }
+
+ internal interface UnrelatedInterfaceWithSameMethod
+ {
+ int SameMethod();
+ int DifferentMethod3();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5DD35432-4987-488D-94F1-7682D7E4405C")]
+ internal partial interface IHide3 : IHide2, UnrelatedInterfaceWithSameMethod
+ {
+ new int SameMethod();
+ new int DifferentMethod3();
+ }
+
+ [GeneratedComClass]
+ [Guid("2D36BD6D-C80E-4F00-86E9-8D1B4A0CB59A")]
+ /// <summary>
+ /// Implements IHides3 and returns the expected VTable index for each method.
+ /// </summary>
+ internal partial class HideBaseMethods : IHide3
+ {
+ int IHide.SameMethod() => 3;
+ int IHide.DifferentMethod() => 4;
+ int IHide2.SameMethod() => 5;
+ int IHide2.DifferentMethod2() => 6;
+ int IHide3.SameMethod() => 7;
+ int IHide3.DifferentMethod3() => 8;
+ int UnrelatedInterfaceWithSameMethod.SameMethod() => -1;
+ int UnrelatedInterfaceWithSameMethod.DifferentMethod3() => -1;
+ }
+}

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

@@ -17,9 +17,14 @@ internal sealed record ComInterfaceAndMethodsContext(ComInterfaceContext Interfa
  /// </summary>
  public IEnumerable<ComMethodContext> DeclaredMethods => Methods.Where(m => !m.IsInheritedMethod);
 
+ /// <summary>
+ /// COM methods that require shadowing declarations on the derived interface.
+ /// </summary>
+ public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod && !m.IsHiddenOnDerivedInterface);
+
  /// <summary>
  /// COM methods that are declared on an interface the interface inherits from.
  /// </summary>
- public IEnumerable<ComMethodContext> ShadowingMethods => Methods.Where(m => m.IsInheritedMethod);
+ public IEnumerable<ComMethodContext> InheritedMethods => Methods.Where(m => m.IsInheritedMethod);
  }
 }

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

@@ -127,7 +127,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .WithComparer(SyntaxEquivalentComparer.Instance)
  .SelectNormalized();
 
- var shadowingMethods = interfaceAndMethodsContexts
+ var shadowingMethodDeclarations = interfaceAndMethodsContexts
  .Select((data, ct) =>
  {
  var context = data.Interface.Info;
@@ -163,7 +163,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  .Zip(nativeToManagedVtableMethods)
  .Zip(nativeToManagedVtables)
  .Zip(iUnknownDerivedAttributeApplication)
- .Zip(shadowingMethods)
+ .Zip(shadowingMethodDeclarations)
  .Select(static (data, ct) =>
  {
  var ((((((interfaceContext, interfaceInfo), managedToNativeStubs), nativeToManagedStubs), nativeToManagedVtable), iUnknownDerivedAttribute), shadowingMethod) = data;
@@ -352,7 +352,7 @@ private static IncrementalMethodStubGenerationContext CalculateStubInformation(M
 
  var containingSyntaxContext = new ContainingSyntaxContext(syntax);
 
- var methodSyntaxTemplate = new ContainingSyntax(syntax.Modifiers.StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
+ var methodSyntaxTemplate = new ContainingSyntax(new SyntaxTokenList(syntax.Modifiers.Where(static m => !m.IsKind(SyntaxKind.NewKeyword))).StripAccessibilityModifiers(), SyntaxKind.MethodDeclaration, syntax.Identifier, syntax.TypeParameterList);
 
  ImmutableArray<FunctionPointerUnmanagedCallingConventionSyntax> callConv = VirtualMethodPointerStubGenerator.GenerateCallConvSyntaxFromAttributes(
  suppressGCTransitionAttribute,
@@ -423,11 +423,42 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  var methodList = ImmutableArray.CreateBuilder<ComMethodContext>();
  while (methodIndex < methods.Length && methods[methodIndex].OwningInterface == iface)
  {
+ var method = methods[methodIndex];
+ if (method.MethodInfo.IsUserDefinedShadowingMethod)
+ {
+ bool shadowFound = false;
+ int shadowIndex = -1;
+ // Don't remove method, but make it so that it doesn't generate any stubs
+ for (int i = methodList.Count - 1; i > -1; i--)
+ {
+ var potentialShadowedMethod = methodList[i];
+ if (MethodEquals(method, potentialShadowedMethod))
+ {
+ shadowFound = true;
+ shadowIndex = i;
+ break;
+ }
+ }
+ if (shadowFound)
+ {
+ methodList[shadowIndex].IsHiddenOnDerivedInterface = true;
+ }
+ // We might not find the shadowed method if it's defined on a non-GeneratedComInterface-attributed interface. Thats okay and we can disregard it.
+ }
  methodList.Add(methods[methodIndex++]);
  }
  contextList.Add(new(iface, methodList.ToImmutable().ToSequenceEqual()));
  }
  return contextList.ToImmutable();
+
+ static bool MethodEquals(ComMethodContext a, ComMethodContext b)
+ {
+ if (a.MethodInfo.MethodName != b.MethodInfo.MethodName)
+ return false;
+ if (a.GenerationContext.SignatureContext.ManagedParameters.SequenceEqual(b.GenerationContext.SignatureContext.ManagedParameters))
+ return true;
+ return false;
+ }
  }
 
  private static readonly InterfaceDeclarationSyntax ImplementationInterfaceTemplate = InterfaceDeclaration("InterfaceImplementation")
@@ -436,12 +467,12 @@ private static ImmutableArray<ComInterfaceAndMethodsContext> GroupComContextsFor
  private static InterfaceDeclarationSyntax GenerateImplementationInterface(ComInterfaceAndMethodsContext interfaceGroup, CancellationToken _)
  {
  var definingType = interfaceGroup.Interface.Info.Type;
- var shadowImplementations = interfaceGroup.ShadowingMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
+ var shadowImplementations = interfaceGroup.InheritedMethods.Select(m => (Method: m, ManagedToUnmanagedStub: m.ManagedToUnmanagedStub))
  .Where(p => p.ManagedToUnmanagedStub is GeneratedStubCodeContext)
  .Select(ctx => ((GeneratedStubCodeContext)ctx.ManagedToUnmanagedStub).Stub.Node
  .WithExplicitInterfaceSpecifier(
  ExplicitInterfaceSpecifier(ParseName(definingType.FullTypeName))));
- var inheritedStubs = interfaceGroup.ShadowingMethods.Select(m => m.UnreachableExceptionStub);
+ var inheritedStubs = interfaceGroup.InheritedMethods.Select(m => m.UnreachableExceptionStub);
  return ImplementationInterfaceTemplate
  .AddBaseListTypes(SimpleBaseType(definingType.Syntax))
  .WithMembers(
@@ -560,7 +591,7 @@ private static InterfaceDeclarationSyntax GenerateImplementationVTable(ComInterf
  ParenthesizedExpression(
  BinaryExpression(SyntaxKind.MultiplyExpression,
  SizeOfExpression(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword)))),
- LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.ShadowingMethods.Count() + 3))))))));
+ LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(interfaceMethods.InheritedMethods.Count() + 3))))))));
  }
 
  var vtableSlotAssignments = VirtualMethodPointerStubGenerator.GenerateVirtualMethodTableSlotAssignments(

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

@@ -69,13 +69,15 @@ public ComMethodContext(Builder builder, ComInterfaceContext owningInterface, In
 
  public bool IsInheritedMethod => OriginalDeclaringInterface != OwningInterface;
 
+ public bool IsHiddenOnDerivedInterface { get; set; }
+
  private GeneratedMethodContextBase? _managedToUnmanagedStub;
 
  public GeneratedMethodContextBase ManagedToUnmanagedStub => _managedToUnmanagedStub ??= CreateManagedToUnmanagedStub();
 
  private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(OriginalDeclaringInterface.Info.Type);
  }
@@ -89,7 +91,7 @@ private GeneratedMethodContextBase CreateManagedToUnmanagedStub()
 
  private GeneratedMethodContextBase CreateUnmanagedToManagedStub()
  {
- if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional))
+ if (GenerationContext.VtableIndexData.Direction is not (MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) || IsHiddenOnDerivedInterface)
  {
  return new SkippedStubContext(GenerationContext.OriginalDefiningType);
  }

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

@@ -17,7 +17,8 @@ namespace Microsoft.Interop
  internal sealed record ComMethodInfo(
  MethodDeclarationSyntax Syntax,
  string MethodName,
- SequenceEqualImmutableArray<AttributeInfo> Attributes)
+ SequenceEqualImmutableArray<AttributeInfo> Attributes,
+ bool IsUserDefinedShadowingMethod)
  {
  /// <summary>
  /// Returns a list of tuples of ComMethodInfo, IMethodSymbol, and Diagnostic. If ComMethodInfo is null, Diagnostic will not be null, and vice versa.
@@ -123,7 +124,9 @@ internal sealed record ComMethodInfo(
  {
  attributeInfos.Add(AttributeInfo.From(attr));
  }
- var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual());
+
+ bool shadowsBaseMethod = comMethodDeclaringSyntax.Modifiers.Any(SyntaxKind.NewKeyword);
+ var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);
  return DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From((comMethodInfo, method));
  }
  }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Tests/RcwAroundCcwTests.cs

@@ -386,5 +386,39 @@ public void IStringArrayMarshallingFails_Failing()
  obj.ByValueOutParam(strings);
  });
  }
+
+ [Fact]
+ public unsafe void IHideWorksAsExpected()
+ {
+ IHide obj = CreateWrapper<HideBaseMethods, IHide3>();
+
+ // IHide.SameMethod should be index 3
+ Assert.Equal(3, obj.SameMethod());
+ Assert.Equal(4, obj.DifferentMethod());
+
+ IHide2 obj2 = (IHide2)obj;
+
+ // IHide2.SameMethod should be index 5
+ Assert.Equal(5, obj2.SameMethod());
+ Assert.Equal(4, obj2.DifferentMethod());
+ Assert.Equal(6, obj2.DifferentMethod2());
+
+ IHide3 obj3 = (IHide3)obj;
+ // IHide3.SameMethod should be index 7
+ Assert.Equal(7, obj3.SameMethod());
+ Assert.Equal(4, obj3.DifferentMethod());
+ Assert.Equal(6, obj3.DifferentMethod2());
+ Assert.Equal(8, obj3.DifferentMethod3());
+
+ // Ensure each VTable method points to the correct method on HideBaseMethods
+ for (int i = 3; i < 9; i++)
+ {
+ var (__this, __vtable_native) = ((global::System.Runtime.InteropServices.Marshalling.IUnmanagedVirtualMethodTableProvider)obj3).GetVirtualMethodTableInfoForKey(typeof(global::SharedTypes.ComInterfaces.IHide3));
+ int __retVal;
+ int __invokeRetVal;
+ __invokeRetVal = ((delegate* unmanaged[MemberFunction]<void*, int*, int>)__vtable_native[i])(__this, &__retVal);
+ Assert.Equal(i, __retVal);
+ }
+ }
  }
 }

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/CodeSnippets.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -109,8 +110,6 @@ public static StatelessCollectionAllShapes<TManagedElement> AllocateContainerFor
  }
  """;
 
- public static readonly string DisableRuntimeMarshalling = "[assembly:System.Runtime.CompilerServices.DisableRuntimeMarshalling]";
- public static readonly string UsingSystemRuntimeInteropServicesMarshalling = "using System.Runtime.InteropServices.Marshalling;";
  public const string IntMarshaller = """
  [CustomMarshaller(typeof(int), MarshalMode.Default, typeof(IntMarshaller))]
  internal static class IntMarshaller
@@ -433,6 +432,87 @@ partial interface INativeAPI
  {{_attributeProvider.AdditionalUserRequiredInterfaces("INativeAPI")}}
  """;
 
+ public string DerivedComInterfaceTypeWithShadowingMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method2();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method2();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeShadowsComAndNonComMethod => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ interface IOtherInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface
+ {
+ new void Method();
+ }
+ """;
+
+ public string DerivedComInterfaceTypeTwoLevelShadows => $$"""
+ using System.Runtime.CompilerServices;
+ using System.Runtime.InteropServices;
+ using System.Runtime.InteropServices.Marshalling;
+
+ {{GeneratedComInterface()}}
+ partial interface IComInterface
+ {
+ void Method();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface1: IComInterface
+ {
+ new void Method1();
+ }
+ {{GeneratedComInterface()}}
+ partial interface IComInterface2 : IComInterface1
+ {
+ new void Method();
+ }
+ """;
+
  public string DerivedComInterfaceType => $$"""
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;

src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/Compiles.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using Microsoft.DotNet.XUnitExtensions.Attributes;
 using Microsoft.Interop.UnitTests;
 using Xunit;
 using VerifyComInterfaceGenerator = Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier<Microsoft.Interop.ComInterfaceGenerator>;
@@ -336,6 +335,10 @@ public static IEnumerable<object[]> ComInterfaceSnippetsToCompile()
  {
  CodeSnippets codeSnippets = new(new GeneratedComInterfaceAttributeProvider());
  yield return new object[] { ID(), codeSnippets.DerivedComInterfaceType };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeWithShadowingMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeShadowsComAndNonComMethod };
+ yield return new object[] { ID(), codeSnippets.DerivedComInterfaceTypeTwoLevelShadows};
  yield return new object[] { ID(), codeSnippets.DerivedWithParametersDeclaredInOtherNamespace };
  yield return new object[] { ID(), codeSnippets.ComInterfaceParameters };
  }

src/libraries/System.Runtime.InteropServices/tests/TestAssets/SharedTypes/ComInterfaces/IHide.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;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.Marshalling;
+
+namespace SharedTypes.ComInterfaces
+{
+ [GeneratedComInterface]
+ [Guid("023EA72A-ECAA-4B65-9D96-2122CFADE16C")]
+ internal partial interface IHide
+ {
+ int SameMethod();
+ int DifferentMethod();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5293B3B1-4994-425C-803E-A21A5011E077")]
+ internal partial interface IHide2 : IHide
+ {
+ new int SameMethod();
+ int DifferentMethod2();
+ }
+
+ internal interface UnrelatedInterfaceWithSameMethod
+ {
+ int SameMethod();
+ int DifferentMethod3();
+ }
+
+ [GeneratedComInterface]
+ [Guid("5DD35432-4987-488D-94F1-7682D7E4405C")]
+ internal partial interface IHide3 : IHide2, UnrelatedInterfaceWithSameMethod
+ {
+ new int SameMethod();
+ new int DifferentMethod3();
+ }
+
+ [GeneratedComClass]
+ [Guid("2D36BD6D-C80E-4F00-86E9-8D1B4A0CB59A")]
+ /// <summary>
+ /// Implements IHides3 and returns the expected VTable index for each method.
+ /// </summary>
+ internal partial class HideBaseMethods : IHide3
+ {
+ int IHide.SameMethod() => 3;
+ int IHide.DifferentMethod() => 4;
+ int IHide2.SameMethod() => 5;
+ int IHide2.DifferentMethod2() => 6;
+ int IHide3.SameMethod() => 7;
+ int IHide3.DifferentMethod3() => 8;
+ int UnrelatedInterfaceWithSameMethod.SameMethod() => -1;
+ int UnrelatedInterfaceWithSameMethod.DifferentMethod3() => -1;
+ }
+}