Refactor test Builder to use version-based contract resolution

TestPlaceholderTarget.Builder now defaults to CoreCLRContracts.Register and
supports AddContract<T>(version) for version-based resolution and
AddMockContract<T>(mock) for injecting test doubles. TestContractRegistry
supports Register, SetVersion, and SetMock with proper version lookup.

Migrated 5 Builder-pattern test files from factory lambdas to version-based
contract resolution.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: max-charlamb

src/native/managed/cdac/tests/AuxiliarySymbolsTests.cs

@@ -91,8 +91,8 @@ private static Target CreateTarget(
             .AddGlobals(
                 (Constants.Globals.AuxiliarySymbols, arrayAddress),
                 (Constants.Globals.AuxiliarySymbolCount, countFragment.Address))
-            .AddContract<IPlatformMetadata>(_ => Mock.Of<IPlatformMetadata>(p => p.GetCodePointerFlags() == default(CodePointerFlags)))
-            .AddContract<IAuxiliarySymbols>(static target => (IAuxiliarySymbols)new AuxiliarySymbols_1(target))
+            .AddMockContract<IPlatformMetadata>(Mock.Of<IPlatformMetadata>(p => p.GetCodePointerFlags() == default(CodePointerFlags)))
+            .AddContract<IAuxiliarySymbols>(version: 1)
             .Build();
     }
 

src/native/managed/cdac/tests/DebuggerTests.cs

@@ -65,7 +65,7 @@ private static TestPlaceholderTarget BuildTarget(
             builder.AddGlobals((Constants.Globals.MetadataUpdatesApplied, metadataFrag.Address));
         }
 
-        builder.AddContract<IDebugger>(target => (IDebugger)new Debugger_1(target));
+        builder.AddContract<IDebugger>(version: 1);
 
         return builder.Build();
     }
@@ -82,7 +82,7 @@ private static TestPlaceholderTarget BuildNullDebuggerTarget(MockTarget.Architec
         helpers.WritePointer(debuggerPtrFrag.Data, 0);
         memBuilder.AddHeapFragment(debuggerPtrFrag);
         builder.AddGlobals((Constants.Globals.Debugger, debuggerPtrFrag.Address));
-        builder.AddContract<IDebugger>(target => (IDebugger)new Debugger_1(target));
+        builder.AddContract<IDebugger>(version: 1);
 
         return builder.Build();
     }

src/native/managed/cdac/tests/GCTests.cs

@@ -142,8 +142,7 @@ public static TestPlaceholderTarget.Builder AddGCHeapWks(
         GCHeapBuilder config = new();
         configure(config);
         BuildWksHeap(targetBuilder, config);
-        targetBuilder.AddContract<IGC>(static target =>
-            (IGC)new GC_1(target));
+        targetBuilder.AddContract<IGC>(version: 1);
         return targetBuilder;
     }
 
@@ -155,8 +154,7 @@ public static TestPlaceholderTarget.Builder AddGCHeapSvr(
         GCHeapBuilder config = new();
         configure(config);
         heapAddress = BuildSvrHeap(targetBuilder, config);
-        targetBuilder.AddContract<IGC>(static target =>
-            (IGC)new GC_1(target));
+        targetBuilder.AddContract<IGC>(version: 1);
         return targetBuilder;
     }
 

src/native/managed/cdac/tests/ReJITTests.cs

@@ -40,8 +40,8 @@ private static ReJITContractContext CreateReJITContract(
         TestPlaceholderTarget target = targetBuilder
             .AddTypes(CreateContractTypes(rejitBuilder))
             .AddGlobals((nameof(Constants.Globals.ProfilerControlBlock), rejitBuilder.ProfilerControlBlockGlobalAddress))
-            .AddContract<IReJIT>(static target => (IReJIT)new ReJIT_1(target))
-            .AddContract<ICodeVersions>(_ => mockCodeVersions.Object)
+            .AddContract<IReJIT>(version: 1)
+            .AddMockContract<ICodeVersions>(mockCodeVersions.Object)
             .Build();
         return new ReJITContractContext(target.Contracts.ReJIT, target);
     }

src/native/managed/cdac/tests/TestPlaceholderTarget.cs

@@ -57,7 +57,8 @@ internal class Builder
         private readonly Dictionary<DataType, Target.TypeInfo> _types = new();
         private readonly List<(string Name, ulong Value)> _globals = new();
         private readonly List<(string Name, string Value)> _globalStrings = new();
-        private readonly List<(Type Type, Func<Target, IContract> Factory)> _contractFactories = new();
+        private readonly List<Action<TestContractRegistry>> _contractSetups = new();
+        private Action<ContractRegistry> _registrations = CoreCLRContracts.Register;
 
         public Builder(MockTarget.Architecture arch)
         {
@@ -86,9 +87,21 @@ public Builder AddGlobalStrings(params (string Name, string Value)[] globalStrin
             return this;
         }
 
-        public Builder AddContract<TContract>(Func<Target, TContract> factory) where TContract : IContract
+        public Builder UseRegistrations(Action<ContractRegistry> registrations)
         {
-            _contractFactories.Add((typeof(TContract), target => factory(target)));
+            _registrations = registrations;
+            return this;
+        }
+
+        public Builder AddContract<TContract>(int version) where TContract : IContract
+        {
+            _contractSetups.Add(registry => registry.SetVersion<TContract>(version));
+            return this;
+        }
+
+        public Builder AddMockContract<TContract>(TContract mock) where TContract : IContract
+        {
+            _contractSetups.Add(registry => registry.SetMock(mock));
             return this;
         }
 
@@ -102,8 +115,12 @@ public TestPlaceholderTarget Build()
                 _globalStrings.ToArray());
 
             var registry = new TestContractRegistry();
-            foreach (var (type, factory) in _contractFactories)
-                registry.Add(type, new Lazy<IContract>(() => factory(target)));
+            registry.SetTarget(target);
+            _registrations(registry);
+
+            foreach (var setup in _contractSetups)
+                setup(registry);
+
             target.SetContracts(registry);
 
             return target;
@@ -457,20 +474,48 @@ public void Clear()
 
     private sealed class TestContractRegistry : ContractRegistry
     {
-        private readonly Dictionary<Type, Lazy<IContract>> _contracts = new();
+        private readonly Dictionary<(Type, int), Func<Target, IContract>> _creators = new();
+        private readonly Dictionary<Type, int> _versions = new();
+        private readonly Dictionary<Type, IContract> _mocks = new();
+        private readonly Dictionary<Type, IContract> _resolved = new();
+        private Target _target;
+
+        public void SetTarget(Target target) => _target = target;
+
+        public void SetVersion<TContract>(int version) where TContract : IContract
+            => _versions[typeof(TContract)] = version;
 
-        public void Add(Type type, Lazy<IContract> contract) => _contracts[type] = contract;
+        public void SetMock<TContract>(TContract mock) where TContract : IContract
+            => _mocks[typeof(TContract)] = mock;
+
+        public override void Register<TContract>(int version, Func<Target, TContract> creator)
+            => _creators[(typeof(TContract), version)] = t => creator(t);
 
         public override TContract GetContract<TContract>()
         {
-            if (_contracts.TryGetValue(typeof(TContract), out var lazy))
-                return (TContract)lazy.Value;
+            if (_resolved.TryGetValue(typeof(TContract), out var cached))
+                return (TContract)cached;
 
-            throw new NotImplementedException($"Contract {typeof(TContract).Name} is not registered.");
-        }
+            IContract contract;
+            if (_mocks.TryGetValue(typeof(TContract), out var mock))
+            {
+                contract = mock;
+            }
+            else if (_versions.TryGetValue(typeof(TContract), out int version))
+            {
+                if (!_creators.TryGetValue((typeof(TContract), version), out var creator))
+                    throw new NotImplementedException($"No implementation registered for contract '{typeof(TContract).Name}' version {version}.");
 
-        public override void Register<TContract>(int version, Func<Target, TContract> creator)
-            => throw new NotSupportedException("TestContractRegistry does not support dynamic registration. Use SetContracts to configure contracts for testing.");
+                contract = creator(_target);
+            }
+            else
+            {
+                throw new NotImplementedException($"Contract {typeof(TContract).Name} is not registered. Use AddContract<T>(version) or AddMockContract<T>(mock) on the Builder.");
+            }
+
+            _resolved[typeof(TContract)] = contract;
+            return (TContract)contract;
+        }
 
         public override void Flush() { }
     }

src/native/managed/cdac/tests/ThreadTests.cs

@@ -25,7 +25,7 @@ private static TestPlaceholderTarget CreateTarget(
                 (nameof(Constants.Globals.ThreadStore), threadBuilder.ThreadStoreGlobalAddress),
                 (nameof(Constants.Globals.FinalizerThread), threadBuilder.FinalizerThreadGlobalAddress),
                 (nameof(Constants.Globals.GCThread), threadBuilder.GCThreadGlobalAddress))
-            .AddContract<IThread>(static target => (IThread)new Thread_1(target))
+            .AddContract<IThread>(version: 1)
             .Build();