fix: ambiguous reference error when mocking overlapping interface combinations (#477)

Fixes ambiguous reference compiler errors by deduplicating generated setup/verify extension properties when multiple mock combinations share the same interfaces for a given base type.

### Key Changes:
- Track generated (base type, interface) pairs during generation and avoid emitting duplicates.
- Generate mocks in ascending “additional implementation count” order to prefer simpler combinations first.
- Add tests covering both the generator output and the runtime fallback behavior in web-related matching.

Author: Copilot

Source/Mockolate.SourceGenerators/MockGenerator.cs

@@ -34,10 +34,16 @@ void IIncrementalGenerator.Initialize(IncrementalGeneratorInitializationContext
 			(spc, source) => Execute([..source.Distinct(),], spc));
 	}
 
+#pragma warning disable S3776 // Cognitive Complexity of methods should not be too high
 	private static void Execute(ImmutableArray<MockClass> mocksToGenerate, SourceProductionContext context)
 	{
 		(string Name, MockClass MockClass)[] namedMocksToGenerate = CreateNames(mocksToGenerate);
-		foreach ((string Name, MockClass MockClass) mockToGenerate in namedMocksToGenerate)
+		HashSet<(string? BaseNamespace, string BaseClassName, string? Namespace, string ClassName)>
+			generatedAdditionalInterfacesByBaseType = new();
+
+		foreach ((string Name, MockClass MockClass) mockToGenerate in namedMocksToGenerate
+			         .OrderBy(m => m.MockClass.AdditionalImplementations.Count)
+			         .ThenBy(m => m.Name))
 		{
 			if (!IsValidMockDeclaration(mockToGenerate.MockClass))
 			{
@@ -48,10 +54,20 @@ private static void Execute(ImmutableArray<MockClass> mocksToGenerate, SourcePro
 				SourceText.From(Sources.Sources.ForMock(mockToGenerate.Name, mockToGenerate.MockClass), Encoding.UTF8));
 			if (mockToGenerate.MockClass.AdditionalImplementations.Any() && mockToGenerate.MockClass.Delegate is null)
 			{
-				context.AddSource($"MockFor{mockToGenerate.Name}Extensions.g.cs",
-					SourceText.From(
-						Sources.Sources.ForMockCombinationExtensions(mockToGenerate.Name, mockToGenerate.MockClass, mockToGenerate.MockClass.DistinctAdditionalImplementations()),
-						Encoding.UTF8));
+				Class[] interfacesToGenerate = mockToGenerate.MockClass.DistinctAdditionalImplementations()
+					.Where(impl => generatedAdditionalInterfacesByBaseType .Add(
+						(mockToGenerate.MockClass.Namespace, mockToGenerate.MockClass.ClassName,
+							impl.Namespace, impl.ClassName)))
+					.ToArray();
+
+				if (interfacesToGenerate.Length > 0)
+				{
+					context.AddSource($"MockFor{mockToGenerate.Name}Extensions.g.cs",
+						SourceText.From(
+							Sources.Sources.ForMockCombinationExtensions(mockToGenerate.Name, mockToGenerate.MockClass,
+								interfacesToGenerate),
+							Encoding.UTF8));
+				}
 			}
 		}
 
@@ -118,6 +134,7 @@ private static void Execute(ImmutableArray<MockClass> mocksToGenerate, SourcePro
 		context.AddSource("MockBehaviorExtensions.g.cs",
 			SourceText.From(Sources.Sources.MockBehaviorExtensions(mocksToGenerate), Encoding.UTF8));
 	}
+#pragma warning restore S3776 // Cognitive Complexity of methods should not be too high
 
 	private static List<(string Name, Class Class)> GetDistinctExtensions(ImmutableArray<MockClass> mocksToGenerate)
 	{

Tests/Mockolate.Internal.Tests/WebTests.cs

@@ -31,13 +31,30 @@ public async Task HttpContentParameter_MatchesWithNullContent_ShouldReturnFalse(
 		await That(result).IsFalse();
 	}
 
+	[Fact]
+	public async Task WhenParameterDoesNotImplementIHttpRequestMessagePropertyParameter_ShouldFallbackToParameterMatch()
+	{
+		ItExtensions.IHttpContentParameter parameter =
+			Mock.Create<ItExtensions.IHttpContentParameter, IParameter>();
+		parameter.SetupIParameterMock.Method.Matches(It.IsAny<object?>()).Returns(true);
+
+		ItExtensions.IStringContentBodyParameter sut = parameter.WithString("foo");
+
+		bool result = ((IHttpRequestMessagePropertyParameter<HttpContent?>)sut).Matches(null, null);
+
+		await That(result).IsTrue();
+		await That(parameter.VerifyOnIParameterMock.Invoked
+				.Matches(It.IsNull<object?>()))
+			.Once();
+	}
+
 	[Fact]
 	public async Task WhenParameterImplementsIHttpRequestMessagePropertyParameter_ShouldUseThisMatch()
 	{
 		ItExtensions.IHttpContentParameter parameter =
 			Mock.Create<ItExtensions.IHttpContentParameter, IParameter,
 				IHttpRequestMessagePropertyParameter<HttpContent?>>();
-		parameter.SetupIParameterMock.Method.Matches(It.IsAny<object?>()).Returns(true);
+		parameter.SetupIParameterMock.Method.Matches(It.IsAny<object?>()).Returns(false);
 		parameter.SetupIHttpRequestMessagePropertyParameter_HttpContent_Mock.Method
 			.Matches(It.IsAny<HttpContent?>(), It.IsAny<HttpRequestMessage?>()).Returns(true);
 
@@ -49,6 +66,9 @@ public async Task WhenParameterImplementsIHttpRequestMessagePropertyParameter_Sh
 		await That(parameter.VerifyOnIHttpRequestMessagePropertyParameter_HttpContent_Mock.Invoked
 				.Matches(It.IsNull<HttpContent?>(), It.IsNull<HttpRequestMessage?>()))
 			.Once();
+		await That(parameter.VerifyOnIParameterMock.Invoked
+				.Matches(It.IsNull<object?>()))
+			.Never();
 	}
 
 	[Fact]

Tests/Mockolate.SourceGenerators.Tests/MockGeneratorTests.cs

@@ -421,4 +421,57 @@ public static void Main(string[] args)
 		await That(result.Sources).ContainsKey("MockForHttpMessageHandler.g.cs").And
 			.ContainsKey("MockForHttpClient.g.cs");
 	}
+
+	[Fact]
+	public async Task WhenSameTypeImplementsDifferentCombinationsOfSameInterface_ShouldNotGenerateDuplicates()
+	{
+		GeneratorResult result = Generator
+			.Run("""
+			     using System;
+			     using System.Threading;
+			     using System.Threading.Tasks;
+			     using Mockolate;
+
+			     namespace MyCode
+			     {
+			         public class Program
+			         {
+			             public static void Main(string[] args)
+			             {
+			     			_ = Mock.Create<IBaseInterface, ICommonInterface>();
+			     			_ = Mock.Create<IBaseInterface, ICommonInterface, IAdditionalInterface1>();
+			     			_ = Mock.Create<IBaseInterface, IAdditionalInterface2, ICommonInterface>();
+			     			_ = Mock.Create<IBaseInterface, IAdditionalInterface1, IAdditionalInterface2, ICommonInterface>();
+			             }
+			         }
+
+			         public interface IBaseInterface { }
+			         public interface ICommonInterface { }
+			         public interface IAdditionalInterface1 { }
+			         public interface IAdditionalInterface2 { }
+			     }
+			     """);
+
+		await That(result.Sources)
+			.ContainsKey("MockForIBaseInterface_ICommonInterfaceExtensions.g.cs").And
+			.ContainsKey("MockForIBaseInterface_ICommonInterface_IAdditionalInterface1Extensions.g.cs").And
+			.ContainsKey("MockForIBaseInterface_IAdditionalInterface2_ICommonInterfaceExtensions.g.cs").And
+			.DoesNotContainKey("MockForIBaseInterface_IAdditionalInterface1_IAdditionalInterface2_ICommonInterfaceExtensions.g.cs");
+		
+		await That(result.Sources["MockForIBaseInterface_ICommonInterfaceExtensions.g.cs"])
+			.Contains("SetupICommonInterfaceMock").And
+			.Contains("VerifyOnICommonInterfaceMock");
+		
+		await That(result.Sources["MockForIBaseInterface_ICommonInterface_IAdditionalInterface1Extensions.g.cs"])
+			.DoesNotContain("SetupICommonInterfaceMock").And
+			.DoesNotContain("VerifyOnICommonInterfaceMock").And
+			.Contains("SetupIAdditionalInterface1Mock").And
+			.Contains("VerifyOnIAdditionalInterface1Mock");
+		
+		await That(result.Sources["MockForIBaseInterface_IAdditionalInterface2_ICommonInterfaceExtensions.g.cs"])
+			.DoesNotContain("SetupICommonInterfaceMock").And
+			.DoesNotContain("VerifyOnICommonInterfaceMock").And
+			.Contains("SetupIAdditionalInterface2Mock").And
+			.Contains("VerifyOnIAdditionalInterface2Mock");
+	}
 }