Generate real IDispatch when requested

src/CsWin32Generator/Program.cs

@@ -319,6 +319,12 @@ private Task<bool> GenerateCode(
                 {
                     superGenerator.AddGeneratorExclusion(trimmedLine[1..]);
                 }
+                else if (trimmedLine.Equals("IDispatch", StringComparison.Ordinal))
+                {
+                    // If IDispatch is explicitly requested then generate the full interface. By default
+                    // only a placeholder IDispatch is generated, this overrides it.
+                    superGenerator.GenerateIDispatch();
+                }
             }
         }
 

src/Microsoft.Windows.CsWin32/Generator.Com.cs

@@ -14,6 +14,10 @@ public partial class Generator
 
     private readonly HashSet<string> injectedPInvokeHelperMethodsToFriendlyOverloadsExtensions = new();
 
+    // If IDispatch is explicitly requested then we will generate the full IDispatch interface. SuperGenerator calls this when
+    // CsWin32Generator sees IDispatch in the NativeMethods.txt.
+    internal bool GenerateFullIDispatch { get; set; }
+
     // With runtime marshaling, IDispatch is implicitly generated when using InterfaceIsDual. The COM source generators
     // don't support this, so we generate a dummy IDispatch when using source generators mode. We don't generate a "real"
     // IDispatch because the interface would be expensive and not very useful. We just need to have placeholder vtable slots.
@@ -707,7 +711,10 @@ static ExpressionSyntax ThisPointer(PointerTypeSyntax? typedPointer = null)
 
         if (this.Reader.StringComparer.Equals(typeDef.Name, "IDispatch"))
         {
-            return this.GenerateIDispatch ? this.CreateIDispatchTypeDeclarationSyntax() : null;
+            if (!this.GenerateFullIDispatch)
+            {
+                return this.GenerateIDispatch ? this.CreateIDispatchTypeDeclarationSyntax() : null;
+            }
         }
 
         string actualIfaceName = this.Reader.GetString(typeDef.Name);

src/Microsoft.Windows.CsWin32/SuperGenerator.cs

@@ -229,6 +229,18 @@ public void AddGeneratorExclusion(string exclusion)
         }
     }
 
+    /// <summary>
+    /// Tells the generator to generate the "real" IDispatch interface fully. This only really has an
+    /// effect in COM source generator mode.
+    /// </summary>
+    public void GenerateIDispatch()
+    {
+        foreach (Generator generator in this.Generators.Values)
+        {
+            generator.GenerateFullIDispatch = true;
+        }
+    }
+
     /// <summary>
     /// Looks up the <see cref="Generator"/> that owns a referenced type.
     /// </summary>

test/CsWin32Generator.Tests/CsWin32GeneratorTests.cs

@@ -26,6 +26,11 @@ public async Task TestGenerateIDispatch()
 
         var idispatchType = this.FindGeneratedType("IDispatch");
         Assert.NotEmpty(idispatchType);
+
+        // And when generating IDispatch explicitly it should have "real" methods on it.
+        var methods = idispatchType.SelectMany(t => t.DescendantNodes().OfType<MethodDeclarationSyntax>());
+        var method = Assert.Single(methods, m => m.Identifier.Text == "GetTypeInfoCount");
+        Assert.Contains("(out uint pctinfo)", method.ParameterList.ToString());
     }
 
     [Fact]
@@ -39,6 +44,13 @@ public async Task TestGenerateIShellWindows()
 
         // Check that IShellWindows has IDispatch as a base
         Assert.Contains(ishellWindowsType, x => x.BaseList?.Types.Any(t => t.Type.ToString().Contains("IDispatch")) ?? false);
+
+        var idispatchType = this.FindGeneratedType("IDispatch");
+        Assert.NotEmpty(idispatchType);
+
+        // And when generating IDispatch implicitly it should not have "real" methods on it.
+        var methods = idispatchType.SelectMany(t => t.DescendantNodes().OfType<MethodDeclarationSyntax>());
+        Assert.DoesNotContain(methods, m => m.Identifier.Text == "GetTypeInfoCount");
     }
 
     [Fact]