refactor(mocks): move Mock<T> control members to static Mock helpers

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_Inheriting_Multiple_Interfaces.verified.txt

@@ -75,19 +75,19 @@ namespace TUnit.Mocks.Generated
         public static global::TUnit.Mocks.VoidMockMethodCall Flush(this global::TUnit.Mocks.Mock<global::IReadWriter> mock)
         {
             var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
-            return new global::TUnit.Mocks.VoidMockMethodCall(mock.Engine, 0, "Flush", matchers);
+            return new global::TUnit.Mocks.VoidMockMethodCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "Flush", matchers);
         }
 
         public static global::TUnit.Mocks.MockMethodCall<string> Read(this global::TUnit.Mocks.Mock<global::IReadWriter> mock)
         {
             var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
-            return new global::TUnit.Mocks.MockMethodCall<string>(mock.Engine, 1, "Read", matchers);
+            return new global::TUnit.Mocks.MockMethodCall<string>(global::TUnit.Mocks.Mock.GetEngine(mock), 1, "Read", matchers);
         }
 
         public static IReadWriter_Write_M2_MockCall Write(this global::TUnit.Mocks.Mock<global::IReadWriter> mock, global::TUnit.Mocks.Arguments.Arg<string> data)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { data.Matcher };
-            return new IReadWriter_Write_M2_MockCall(mock.Engine, 2, "Write", matchers);
+            return new IReadWriter_Write_M2_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 2, "Write", matchers);
         }
     }
 

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Async_Methods.verified.txt

@@ -112,25 +112,25 @@ namespace TUnit.Mocks.Generated
         public static IAsyncService_GetValueAsync_M0_MockCall GetValueAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::TUnit.Mocks.Arguments.Arg<string> key)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { key.Matcher };
-            return new IAsyncService_GetValueAsync_M0_MockCall(mock.Engine, 0, "GetValueAsync", matchers);
+            return new IAsyncService_GetValueAsync_M0_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "GetValueAsync", matchers);
         }
 
         public static global::TUnit.Mocks.VoidMockMethodCall DoWorkAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock)
         {
             var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
-            return new global::TUnit.Mocks.VoidMockMethodCall(mock.Engine, 1, "DoWorkAsync", matchers);
+            return new global::TUnit.Mocks.VoidMockMethodCall(global::TUnit.Mocks.Mock.GetEngine(mock), 1, "DoWorkAsync", matchers);
         }
 
         public static IAsyncService_ComputeAsync_M2_MockCall ComputeAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::TUnit.Mocks.Arguments.Arg<int> input)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { input.Matcher };
-            return new IAsyncService_ComputeAsync_M2_MockCall(mock.Engine, 2, "ComputeAsync", matchers);
+            return new IAsyncService_ComputeAsync_M2_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 2, "ComputeAsync", matchers);
         }
 
         public static IAsyncService_InitializeAsync_M3_MockCall InitializeAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::TUnit.Mocks.Arguments.Arg<global::System.Threading.CancellationToken> ct)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { ct.Matcher };
-            return new IAsyncService_InitializeAsync_M3_MockCall(mock.Engine, 3, "InitializeAsync", matchers);
+            return new IAsyncService_InitializeAsync_M3_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 3, "InitializeAsync", matchers);
         }
     }
 

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Events.verified.txt

@@ -15,7 +15,7 @@ namespace TUnit.Mocks.Generated
     {
         extension(global::TUnit.Mocks.Mock<global::INotifier> mock)
         {
-            public INotifier_MockEvents Events => new(mock.Engine);
+            public INotifier_MockEvents Events => new(global::TUnit.Mocks.Mock.GetEngine(mock));
         }
 
         extension(INotifier_MockEvents events)
@@ -117,12 +117,12 @@ namespace TUnit.Mocks.Generated
         public static INotifier_Notify_M0_MockCall Notify(this global::TUnit.Mocks.Mock<global::INotifier> mock, global::TUnit.Mocks.Arguments.Arg<string> message)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { message.Matcher };
-            return new INotifier_Notify_M0_MockCall(mock.Engine, 0, "Notify", matchers);
+            return new INotifier_Notify_M0_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "Notify", matchers);
         }
 
         public static void RaiseItemAdded(this global::TUnit.Mocks.Mock<global::INotifier> mock, string e)
         {
-            ((global::TUnit.Mocks.IRaisable)mock.Engine.Raisable!).RaiseEvent("ItemAdded", (object?)e);
+            ((global::TUnit.Mocks.IRaisable)global::TUnit.Mocks.Mock.GetEngine(mock).Raisable!).RaiseEvent("ItemAdded", (object?)e);
         }
     }
 

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Generic_Methods.verified.txt

@@ -75,19 +75,19 @@ namespace TUnit.Mocks.Generated
         public static global::TUnit.Mocks.MockMethodCall<T> GetById<T>(this global::TUnit.Mocks.Mock<global::IRepository> mock, global::TUnit.Mocks.Arguments.Arg<int> id) where T : class
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { id.Matcher };
-            return new global::TUnit.Mocks.MockMethodCall<T>(mock.Engine, 0, "GetById", matchers);
+            return new global::TUnit.Mocks.MockMethodCall<T>(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "GetById", matchers);
         }
 
         public static global::TUnit.Mocks.VoidMockMethodCall Save<T>(this global::TUnit.Mocks.Mock<global::IRepository> mock, global::TUnit.Mocks.Arguments.Arg<T> entity) where T : class, new()
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { entity.Matcher };
-            return new global::TUnit.Mocks.VoidMockMethodCall(mock.Engine, 1, "Save", matchers);
+            return new global::TUnit.Mocks.VoidMockMethodCall(global::TUnit.Mocks.Mock.GetEngine(mock), 1, "Save", matchers);
         }
 
         public static global::TUnit.Mocks.MockMethodCall<TResult> Transform<TInput, TResult>(this global::TUnit.Mocks.Mock<global::IRepository> mock, global::TUnit.Mocks.Arguments.Arg<TInput> input) where TInput : notnull where TResult : struct
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { input.Matcher };
-            return new global::TUnit.Mocks.MockMethodCall<TResult>(mock.Engine, 2, "Transform", matchers);
+            return new global::TUnit.Mocks.MockMethodCall<TResult>(global::TUnit.Mocks.Mock.GetEngine(mock), 2, "Transform", matchers);
         }
     }
 }

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Mixed_Members.verified.txt

@@ -15,7 +15,7 @@ namespace TUnit.Mocks.Generated
     {
         extension(global::TUnit.Mocks.Mock<global::IService> mock)
         {
-            public IService_MockEvents Events => new(mock.Engine);
+            public IService_MockEvents Events => new(global::TUnit.Mocks.Mock.GetEngine(mock));
         }
 
         extension(IService_MockEvents events)
@@ -141,27 +141,27 @@ namespace TUnit.Mocks.Generated
         public static IService_GetAsync_M3_MockCall GetAsync(this global::TUnit.Mocks.Mock<global::IService> mock, global::TUnit.Mocks.Arguments.Arg<int> id)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { id.Matcher };
-            return new IService_GetAsync_M3_MockCall(mock.Engine, 3, "GetAsync", matchers);
+            return new IService_GetAsync_M3_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 3, "GetAsync", matchers);
         }
 
         public static IService_Process_M4_MockCall Process(this global::TUnit.Mocks.Mock<global::IService> mock, global::TUnit.Mocks.Arguments.Arg<string> data)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { data.Matcher };
-            return new IService_Process_M4_MockCall(mock.Engine, 4, "Process", matchers);
+            return new IService_Process_M4_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 4, "Process", matchers);
         }
 
         extension(global::TUnit.Mocks.Mock<global::IService> mock)
         {
             public global::TUnit.Mocks.PropertyMockCall<string> Name
-                => new(mock.Engine, 0, 1, "Name", true, true);
+                => new(global::TUnit.Mocks.Mock.GetEngine(mock), 0, 1, "Name", true, true);
 
             public global::TUnit.Mocks.PropertyMockCall<int> Count
-                => new(mock.Engine, 2, 0, "Count", true, false);
+                => new(global::TUnit.Mocks.Mock.GetEngine(mock), 2, 0, "Count", true, false);
         }
 
         public static void RaiseStatusChanged(this global::TUnit.Mocks.Mock<global::IService> mock, string e)
         {
-            ((global::TUnit.Mocks.IRaisable)mock.Engine.Raisable!).RaiseEvent("StatusChanged", (object?)e);
+            ((global::TUnit.Mocks.IRaisable)global::TUnit.Mocks.Mock.GetEngine(mock).Raisable!).RaiseEvent("StatusChanged", (object?)e);
         }
     }
 

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Out_Ref_Parameters.verified.txt

@@ -1,4 +1,4 @@
-// <auto-generated/>
+// <auto-generated/>
 #nullable enable
 
 namespace TUnit.Mocks.Generated
@@ -83,13 +83,13 @@ namespace TUnit.Mocks.Generated
         public static IDictionary_TryGetValue_M0_MockCall TryGetValue(this global::TUnit.Mocks.Mock<global::IDictionary> mock, global::TUnit.Mocks.Arguments.Arg<string> key)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { key.Matcher };
-            return new IDictionary_TryGetValue_M0_MockCall(mock.Engine, 0, "TryGetValue", matchers);
+            return new IDictionary_TryGetValue_M0_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "TryGetValue", matchers);
         }
 
         public static IDictionary_Swap_M1_MockCall Swap(this global::TUnit.Mocks.Mock<global::IDictionary> mock, global::TUnit.Mocks.Arguments.Arg<int> a, global::TUnit.Mocks.Arguments.Arg<int> b)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { a.Matcher, b.Matcher };
-            return new IDictionary_Swap_M1_MockCall(mock.Engine, 1, "Swap", matchers);
+            return new IDictionary_Swap_M1_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 1, "Swap", matchers);
         }
     }
 

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Overloaded_Methods.verified.txt

@@ -80,25 +80,25 @@ namespace TUnit.Mocks.Generated
         public static IFormatter_Format_M0_MockCall Format(this global::TUnit.Mocks.Mock<global::IFormatter> mock, global::TUnit.Mocks.Arguments.Arg<string> value)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { value.Matcher };
-            return new IFormatter_Format_M0_MockCall(mock.Engine, 0, "Format", matchers);
+            return new IFormatter_Format_M0_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "Format", matchers);
         }
 
         public static IFormatter_Format_M1_MockCall Format(this global::TUnit.Mocks.Mock<global::IFormatter> mock, global::TUnit.Mocks.Arguments.Arg<int> value)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { value.Matcher };
-            return new IFormatter_Format_M1_MockCall(mock.Engine, 1, "Format", matchers);
+            return new IFormatter_Format_M1_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 1, "Format", matchers);
         }
 
         public static IFormatter_Format_M2_MockCall Format(this global::TUnit.Mocks.Mock<global::IFormatter> mock, global::TUnit.Mocks.Arguments.Arg<string> template, global::TUnit.Mocks.Arguments.Arg<string> arg1)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { template.Matcher, arg1.Matcher };
-            return new IFormatter_Format_M2_MockCall(mock.Engine, 2, "Format", matchers);
+            return new IFormatter_Format_M2_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 2, "Format", matchers);
         }
 
         public static IFormatter_Format_M3_MockCall Format(this global::TUnit.Mocks.Mock<global::IFormatter> mock, global::TUnit.Mocks.Arguments.Arg<string> template, global::TUnit.Mocks.Arguments.Arg<string> arg1, global::TUnit.Mocks.Arguments.Arg<string> arg2)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { template.Matcher, arg1.Matcher, arg2.Matcher };
-            return new IFormatter_Format_M3_MockCall(mock.Engine, 3, "Format", matchers);
+            return new IFormatter_Format_M3_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 3, "Format", matchers);
         }
     }
 

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Properties.verified.txt

@@ -76,13 +76,13 @@ namespace TUnit.Mocks.Generated
         extension(global::TUnit.Mocks.Mock<global::IRepository> mock)
         {
             public global::TUnit.Mocks.PropertyMockCall<string> Name
-                => new(mock.Engine, 0, 1, "Name", true, true);
+                => new(global::TUnit.Mocks.Mock.GetEngine(mock), 0, 1, "Name", true, true);
 
             public global::TUnit.Mocks.PropertyMockCall<int> Count
-                => new(mock.Engine, 2, 0, "Count", true, false);
+                => new(global::TUnit.Mocks.Mock.GetEngine(mock), 2, 0, "Count", true, false);
 
             public global::TUnit.Mocks.PropertyMockCall<bool> IsOpen
-                => new(mock.Engine, 0, 4, "IsOpen", false, true);
+                => new(global::TUnit.Mocks.Mock.GetEngine(mock), 0, 4, "IsOpen", false, true);
         }
     }
 }

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_RefStruct_Parameters.verified.txt

@@ -86,34 +86,34 @@ namespace TUnit.Mocks.Generated
         public static global::TUnit.Mocks.VoidMockMethodCall Process(this global::TUnit.Mocks.Mock<global::IBufferProcessor> mock, global::TUnit.Mocks.Arguments.RefStructArg<global::System.ReadOnlySpan<byte>> data)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { data.Matcher };
-            return new global::TUnit.Mocks.VoidMockMethodCall(mock.Engine, 0, "Process", matchers);
+            return new global::TUnit.Mocks.VoidMockMethodCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "Process", matchers);
         }
         #else
         public static global::TUnit.Mocks.VoidMockMethodCall Process(this global::TUnit.Mocks.Mock<global::IBufferProcessor> mock)
         {
             var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
-            return new global::TUnit.Mocks.VoidMockMethodCall(mock.Engine, 0, "Process", matchers);
+            return new global::TUnit.Mocks.VoidMockMethodCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "Process", matchers);
         }
         #endif
 
         #if NET9_0_OR_GREATER
         public static global::TUnit.Mocks.MockMethodCall<int> Parse(this global::TUnit.Mocks.Mock<global::IBufferProcessor> mock, global::TUnit.Mocks.Arguments.RefStructArg<global::System.ReadOnlySpan<char>> text)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { text.Matcher };
-            return new global::TUnit.Mocks.MockMethodCall<int>(mock.Engine, 1, "Parse", matchers);
+            return new global::TUnit.Mocks.MockMethodCall<int>(global::TUnit.Mocks.Mock.GetEngine(mock), 1, "Parse", matchers);
         }
         #else
         public static global::TUnit.Mocks.MockMethodCall<int> Parse(this global::TUnit.Mocks.Mock<global::IBufferProcessor> mock)
         {
             var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
-            return new global::TUnit.Mocks.MockMethodCall<int>(mock.Engine, 1, "Parse", matchers);
+            return new global::TUnit.Mocks.MockMethodCall<int>(global::TUnit.Mocks.Mock.GetEngine(mock), 1, "Parse", matchers);
         }
         #endif
 
         public static global::TUnit.Mocks.MockMethodCall<string> GetName(this global::TUnit.Mocks.Mock<global::IBufferProcessor> mock)
         {
             var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
-            return new global::TUnit.Mocks.MockMethodCall<string>(mock.Engine, 2, "GetName", matchers);
+            return new global::TUnit.Mocks.MockMethodCall<string>(global::TUnit.Mocks.Mock.GetEngine(mock), 2, "GetName", matchers);
         }
     }
 }

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Multi_Method_Interface.verified.txt

@@ -75,19 +75,19 @@ namespace TUnit.Mocks.Generated
         public static ICalculator_Add_M0_MockCall Add(this global::TUnit.Mocks.Mock<global::ICalculator> mock, global::TUnit.Mocks.Arguments.Arg<int> a, global::TUnit.Mocks.Arguments.Arg<int> b)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { a.Matcher, b.Matcher };
-            return new ICalculator_Add_M0_MockCall(mock.Engine, 0, "Add", matchers);
+            return new ICalculator_Add_M0_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "Add", matchers);
         }
 
         public static ICalculator_Subtract_M1_MockCall Subtract(this global::TUnit.Mocks.Mock<global::ICalculator> mock, global::TUnit.Mocks.Arguments.Arg<int> a, global::TUnit.Mocks.Arguments.Arg<int> b)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { a.Matcher, b.Matcher };
-            return new ICalculator_Subtract_M1_MockCall(mock.Engine, 1, "Subtract", matchers);
+            return new ICalculator_Subtract_M1_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 1, "Subtract", matchers);
         }
 
-        public static global::TUnit.Mocks.VoidMockMethodCall Reset_(this global::TUnit.Mocks.Mock<global::ICalculator> mock)
+        public static global::TUnit.Mocks.VoidMockMethodCall Reset(this global::TUnit.Mocks.Mock<global::ICalculator> mock)
         {
             var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
-            return new global::TUnit.Mocks.VoidMockMethodCall(mock.Engine, 2, "Reset", matchers);
+            return new global::TUnit.Mocks.VoidMockMethodCall(global::TUnit.Mocks.Mock.GetEngine(mock), 2, "Reset", matchers);
         }
     }
 

TUnit.Mocks.SourceGenerator.Tests/Snapshots/Simple_Interface_With_One_Method.verified.txt

@@ -65,7 +65,7 @@ namespace TUnit.Mocks.Generated
         public static IGreeter_Greet_M0_MockCall Greet(this global::TUnit.Mocks.Mock<global::IGreeter> mock, global::TUnit.Mocks.Arguments.Arg<string> name)
         {
             var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { name.Matcher };
-            return new IGreeter_Greet_M0_MockCall(mock.Engine, 0, "Greet", matchers);
+            return new IGreeter_Greet_M0_MockCall(global::TUnit.Mocks.Mock.GetEngine(mock), 0, "Greet", matchers);
         }
     }
 

TUnit.Mocks.SourceGenerator/Builders/MockEventsBuilder.cs

@@ -31,7 +31,7 @@ public static string Build(MockTypeModel model)
                 // Extension property on Mock<T> — non-nullable, only present when type has events
                 using (writer.Block($"extension(global::TUnit.Mocks.Mock<{model.FullyQualifiedName}> mock)"))
                 {
-                    writer.AppendLine($"public {safeName}_MockEvents Events => new(mock.Engine);");
+                    writer.AppendLine($"public {safeName}_MockEvents Events => new(global::TUnit.Mocks.Mock.GetEngine(mock));");
                 }
 
                 writer.AppendLine();