chore: Move asmdef reference migration policy into Domain

Assets/Tests/Editor/ThirdPartyToolMigrationRulesTests.cs

@@ -55,6 +55,86 @@ public void ThirdPartyToolMigrationContentResult_WhenRemovedSignaturesIsNull_Thr
                 null));
         }
 
+        [Test]
+        public void ThirdPartyToolMigrationAsmdefReferenceMigrationResult_WhenReferencesIsNull_Throws()
+        {
+            // Verifies that asmdef migration results fail fast when migrated references are missing.
+            Assert.Throws<ArgumentNullException>(() => new ThirdPartyToolMigrationAsmdefReferenceMigrationResult(
+                null,
+                0));
+        }
+
+        [Test]
+        public void MigrateAsmdefReferences_WhenLegacyEditorReferenceNeedsDomain_AddsRequiredReferences()
+        {
+            // Verifies that pure asmdef reference policy expands legacy editor references with required V3 assemblies.
+            ThirdPartyToolMigrationAsmdefReferenceMigrationResult result =
+                ThirdPartyToolMigrationAsmdefReferenceRules.MigrateAsmdefReferences(
+                    new[] { ThirdPartyToolMigrationRuleCatalog.LegacyEditorAssemblyName },
+                    hasLegacyCSharpSource: false,
+                    requiresToolContractsReference: false,
+                    requiresApplicationReference: false,
+                    requiresDomainReference: true,
+                    requiresFirstPartyScreenshotReference: false);
+
+            Assert.That(result.Changed, Is.True);
+            Assert.That(result.ReplacementCount, Is.EqualTo(1));
+            Assert.That(result.References, Is.EqualTo(new[]
+            {
+                ThirdPartyToolMigrationRuleCatalog.CurrentToolContractsGuidReference,
+                ThirdPartyToolMigrationRuleCatalog.CurrentDomainGuidReference
+            }));
+        }
+
+        [Test]
+        public void MigrateAsmdefReferences_WhenRequiredReferenceIsMissing_AddsReferenceWithoutJson()
+        {
+            // Verifies that pure asmdef reference policy can add required references without JSON mutation.
+            ThirdPartyToolMigrationAsmdefReferenceMigrationResult result =
+                ThirdPartyToolMigrationAsmdefReferenceRules.MigrateAsmdefReferences(
+                    Array.Empty<string>(),
+                    hasLegacyCSharpSource: false,
+                    requiresToolContractsReference: true,
+                    requiresApplicationReference: false,
+                    requiresDomainReference: false,
+                    requiresFirstPartyScreenshotReference: false);
+
+            Assert.That(result.Changed, Is.True);
+            Assert.That(result.ReplacementCount, Is.EqualTo(1));
+            Assert.That(result.References, Is.EqualTo(new[]
+            {
+                ThirdPartyToolMigrationRuleCatalog.CurrentToolContractsGuidReference
+            }));
+        }
+
+        [Test]
+        public void MigrateAsmdefReferences_WhenCurrentNamesAlreadyExist_DoesNotAddDuplicateGuids()
+        {
+            // Verifies that pure asmdef reference policy deduplicates name and GUID forms of current references.
+            ThirdPartyToolMigrationAsmdefReferenceMigrationResult result =
+                ThirdPartyToolMigrationAsmdefReferenceRules.MigrateAsmdefReferences(
+                    new[]
+                    {
+                        ThirdPartyToolMigrationRuleCatalog.CurrentToolContractsAssemblyName,
+                        ThirdPartyToolMigrationRuleCatalog.CurrentApplicationAssemblyName,
+                        ThirdPartyToolMigrationRuleCatalog.CurrentDomainAssemblyName
+                    },
+                    hasLegacyCSharpSource: false,
+                    requiresToolContractsReference: true,
+                    requiresApplicationReference: true,
+                    requiresDomainReference: true,
+                    requiresFirstPartyScreenshotReference: false);
+
+            Assert.That(result.Changed, Is.False);
+            Assert.That(result.ReplacementCount, Is.EqualTo(0));
+            Assert.That(result.References, Is.EqualTo(new[]
+            {
+                ThirdPartyToolMigrationRuleCatalog.CurrentToolContractsAssemblyName,
+                ThirdPartyToolMigrationRuleCatalog.CurrentApplicationAssemblyName,
+                ThirdPartyToolMigrationRuleCatalog.CurrentDomainAssemblyName
+            }));
+        }
+
         [Test]
         public void MigrateCSharpSource_WhenLegacyToolApiIsUsed_RewritesToV3Contracts()
         {

Packages/src/Editor/Domain/ThirdPartyToolMigrationAsmdefReferenceRules.cs

@@ -43,6 +43,67 @@ public static string[] GetMigratedAsmdefReferences(
             return new[] { reference };
         }
 
+        /// <summary>
+        /// Resolves the final asmdef reference list without JSON mutation concerns.
+        /// </summary>
+        public static ThirdPartyToolMigrationAsmdefReferenceMigrationResult MigrateAsmdefReferences(
+            string[] references,
+            bool hasLegacyCSharpSource,
+            bool requiresToolContractsReference,
+            bool requiresApplicationReference,
+            bool requiresDomainReference,
+            bool requiresFirstPartyScreenshotReference)
+        {
+            Debug.Assert(references != null, "references must not be null");
+
+            string[] sourceReferences = references ?? throw new ArgumentNullException(nameof(references));
+            int replacementCount = 0;
+            HashSet<string> addedReferences = new(StringComparer.Ordinal);
+            List<string> migratedReferences = new();
+            foreach (string sourceReference in sourceReferences)
+            {
+                string reference = sourceReference ?? string.Empty;
+                string[] migratedReferenceItems = GetMigratedAsmdefReferences(
+                    reference,
+                    hasLegacyCSharpSource,
+                    requiresApplicationReference,
+                    requiresDomainReference,
+                    requiresFirstPartyScreenshotReference);
+                bool referenceChanged = migratedReferenceItems.Length != 1 ||
+                    !string.Equals(migratedReferenceItems[0], reference, StringComparison.Ordinal);
+                if (referenceChanged)
+                {
+                    replacementCount++;
+                }
+
+                foreach (string migratedReference in migratedReferenceItems)
+                {
+                    string migratedReferenceKey = GetCurrentAsmdefReferenceKey(migratedReference);
+                    if (!addedReferences.Add(migratedReferenceKey))
+                    {
+                        continue;
+                    }
+
+                    migratedReferences.Add(migratedReference);
+                }
+            }
+
+            replacementCount += AppendRequiredCurrentAsmdefReferences(
+                migratedReferences,
+                addedReferences,
+                hasLegacyCSharpSource || requiresToolContractsReference,
+                requiresApplicationReference,
+                requiresDomainReference,
+                requiresFirstPartyScreenshotReference);
+
+            string[] resultReferences = replacementCount == 0
+                ? sourceReferences
+                : migratedReferences.ToArray();
+            return new ThirdPartyToolMigrationAsmdefReferenceMigrationResult(
+                resultReferences,
+                replacementCount);
+        }
+
         private static string[] GetMigratedLegacyEditorReferences(
             bool requiresApplicationReference,
             bool requiresDomainReference,
@@ -84,6 +145,72 @@ private static void AddRequiredMigratedLegacyEditorReference(
             references.Add(reference);
         }
 
+        private static int AppendRequiredCurrentAsmdefReferences(
+            List<string> references,
+            HashSet<string> addedReferences,
+            bool requiresToolContractsReference,
+            bool requiresApplicationReference,
+            bool requiresDomainReference,
+            bool requiresFirstPartyScreenshotReference)
+        {
+            Debug.Assert(references != null, "references must not be null");
+            Debug.Assert(addedReferences != null, "addedReferences must not be null");
+
+            int replacementCount = 0;
+            if (requiresToolContractsReference)
+            {
+                replacementCount += AppendRequiredCurrentAsmdefReference(
+                    references,
+                    addedReferences,
+                    CurrentToolContractsGuidReference);
+            }
+
+            if (requiresApplicationReference)
+            {
+                replacementCount += AppendRequiredCurrentAsmdefReference(
+                    references,
+                    addedReferences,
+                    CurrentApplicationGuidReference);
+            }
+
+            if (requiresDomainReference)
+            {
+                replacementCount += AppendRequiredCurrentAsmdefReference(
+                    references,
+                    addedReferences,
+                    CurrentDomainGuidReference);
+            }
+
+            if (requiresFirstPartyScreenshotReference)
+            {
+                replacementCount += AppendRequiredCurrentAsmdefReference(
+                    references,
+                    addedReferences,
+                    CurrentFirstPartyToolsScreenshotGuidReference);
+            }
+
+            return replacementCount;
+        }
+
+        private static int AppendRequiredCurrentAsmdefReference(
+            List<string> references,
+            HashSet<string> addedReferences,
+            string reference)
+        {
+            Debug.Assert(references != null, "references must not be null");
+            Debug.Assert(addedReferences != null, "addedReferences must not be null");
+            Debug.Assert(!string.IsNullOrEmpty(reference), "reference must not be null or empty");
+
+            string referenceKey = GetCurrentAsmdefReferenceKey(reference);
+            if (!addedReferences.Add(referenceKey))
+            {
+                return 0;
+            }
+
+            references.Add(reference);
+            return 1;
+        }
+
         public static string GetCurrentAsmdefReferenceKey(string reference)
         {
             Debug.Assert(!string.IsNullOrEmpty(reference), "reference must not be null or empty");

Packages/src/Editor/Domain/ThirdPartyToolMigrationRuleData.cs

@@ -106,4 +106,25 @@ public ThirdPartyToolMigrationContentResult(
         public RemovedLegacyPlayerLoopTimingSignature[] RemovedPlayerLoopTimingSignatures { get; }
         public bool Changed => ReplacementCount > 0;
     }
+
+    /// <summary>
+    /// Describes migrated asmdef references resolved by pure migration policy.
+    /// </summary>
+    public readonly struct ThirdPartyToolMigrationAsmdefReferenceMigrationResult
+    {
+        public ThirdPartyToolMigrationAsmdefReferenceMigrationResult(
+            string[] references,
+            int replacementCount)
+        {
+            Debug.Assert(references != null, "references must not be null");
+            Debug.Assert(replacementCount >= 0, "replacementCount must not be negative");
+
+            References = references ?? throw new ArgumentNullException(nameof(references));
+            ReplacementCount = replacementCount;
+        }
+
+        public string[] References { get; }
+        public int ReplacementCount { get; }
+        public bool Changed => ReplacementCount > 0;
+    }
 }