com.wallstop-studios.dxmessaging 3.0.1 → 3.2.0

package/Editor/SetupCscRsp.cs

@@ -5,12 +5,9 @@ namespace DxMessaging.Editor
     using System;
     using System.Collections.Generic;
     using System.IO;
-    using System.Linq;
-    using System.Security.Cryptography;
     using DxMessaging.Editor.Settings;
     using UnityEditor;
     using UnityEngine;
-    using Object = UnityEngine.Object;
 
     [InitializeOnLoad]
     public static class SetupCscRsp
@@ -22,279 +19,297 @@ namespace DxMessaging.Editor
             )
             .Replace("\\", "/");
 
-        private static readonly string[] AnalyzerDirectories =
-        {
-            "Packages/com.wallstop-studios.dxmessaging/Editor/Analyzers/",
-            "Library/PackageCache/com.wallstop-studios.dxmessaging/Editor/Analyzers/",
-        };
+        // Older package versions copied the analyzer + Roslyn runtime DLLs into the consumer
+        // project here so the source generator applied project-wide. The generator now ships
+        // under the package's Runtime/Analyzers folder (Unity scopes it natively to the runtime
+        // assembly and everything that references it, including the predefined Assembly-CSharp),
+        // so this in-project copy is redundant and is removed on upgrade.
+        internal const string LegacyAnalyzerCopyFolder =
+            "Assets/Plugins/Editor/WallstopStudios.DxMessaging";
 
-        private static readonly string SourceGeneratorDllName =
+        private const string LegacySourceGeneratorDllName =
             "WallstopStudios.DxMessaging.SourceGenerators.dll";
 
-        // The analyzer DLL is a SEPARATE assembly compiled against Roslyn 3.8.0 because Unity 2021's
-        // analyzer loader silently rejects analyzer DLLs built against Roslyn 4.x. The source-
-        // generator DLL above stays at Roslyn 4.x because it uses IIncrementalGenerator (4.0+).
-        // Both DLLs ship side-by-side and both need the RoslynAnalyzer label.
-        private static readonly string AnalyzerDllName = "WallstopStudios.DxMessaging.Analyzer.dll";
-
-        // The analyzer DLLs and shared Roslyn surface ship unconditionally; they're light enough
-        // and required for DXMSG002–DXMSG009 to function at all. The list intentionally references
-        // a few transitive Roslyn deps that may or may not physically ship with the package; the
-        // copy loop below silently skips any name that isn't on disk.
-        private static readonly string[] RequiredDllNames =
+        // Released 2.x legacy folders predate the companion analyzer DLL, so the source generator
+        // is the required package-owned marker. Unknown DLLs still make the folder unsafe.
+        private static readonly HashSet<string> RequiredLegacyAnalyzerCopyDlls = new(
+            StringComparer.OrdinalIgnoreCase
+        )
+        {
+            LegacySourceGeneratorDllName,
+        };
+
+        private static readonly HashSet<string> KnownLegacyAnalyzerCopyDlls = new(
+            StringComparer.OrdinalIgnoreCase
+        )
         {
-            SourceGeneratorDllName,
-            AnalyzerDllName,
+            LegacySourceGeneratorDllName,
+            "WallstopStudios.DxMessaging.Analyzer.dll",
             "Microsoft.CodeAnalysis.dll",
             "Microsoft.CodeAnalysis.CSharp.dll",
-            "System.Text.Encodings.Web.dll",
-            "System.Reflection.Metadata.dll",
-            "System.Runtime.CompilerServices.Unsafe.dll",
+            "System.Buffers.dll",
             "System.Collections.Immutable.dll",
             "System.Memory.dll",
-            "System.Buffers.dll",
-            "System.Threading.Tasks.Extensions.dll",
             "System.Numerics.Vectors.dll",
+            "System.Reflection.Metadata.dll",
+            "System.Runtime.CompilerServices.Unsafe.dll",
             "System.Text.Encoding.CodePages.dll",
+            "System.Text.Encodings.Web.dll",
+            "System.Threading.Tasks.Extensions.dll",
         };
 
-        // DLLs that must be tagged with Unity's "RoslynAnalyzer" asset label so Unity's compiler
-        // pipeline picks them up as analyzer/source-generator hosts. Other DLLs in the same folder
-        // (Roslyn runtime, immutable collections) are plain Editor-only plugin DLLs.
-        private static readonly HashSet<string> AnalyzerLabeledDllNames = new(
-            StringComparer.OrdinalIgnoreCase
-        )
+        private static bool loggedSkippedLegacyAnalyzerCopyCleanup;
+
+        static SetupCscRsp()
         {
-            SourceGeneratorDllName,
-            AnalyzerDllName,
-        };
+            // Backstop only: the primary removal happens pre-compile in LegacyAnalyzerCopyCleanup.
+            // This catches projects whose legacy copy predates the upgrade and triggers no import.
+            ScheduleSetupStep(
+                () => TryRemoveLegacyAnalyzerCopy(),
+                "remove redundant in-project analyzer copy"
+            );
+            ScheduleSetupStep(EnsureCscRsp, "clean csc.rsp analyzer entries");
+            ScheduleAdditionalFileForIgnoreListSync();
+        }
 
-        private static readonly HashSet<string> DllNames = new(StringComparer.OrdinalIgnoreCase);
+        internal static void ScheduleAdditionalFileForIgnoreListSync()
+        {
+            ScheduleSetupStep(
+                EnsureAdditionalFileForIgnoreList,
+                "sync csc.rsp base-call ignore additionalfile entry"
+            );
+        }
 
-        static SetupCscRsp()
+        private static void ScheduleSetupStep(Action work, string description)
         {
-            EditorApplication.delayCall += EnsureDLLsExistInAssets;
-            EditorApplication.delayCall += EnsureCscRsp;
-            EditorApplication.delayCall += EnsureAdditionalFileForIgnoreList;
+            DxMessagingEditorIdle.ScheduleAssetDatabaseMutation(() =>
+                RunSetupStep(work, description)
+            );
         }
 
-        private static void EnsureDLLsExistInAssets()
+        private static void RunSetupStep(Action work, string description)
         {
-            DllNames.Clear();
-            foreach (
-                string dllGuid in AssetDatabase.FindAssets("t:DefaultAsset", new[] { "Assets" })
+            try
+            {
+                work();
+            }
+            catch (Exception ex)
+            {
+                DxMessagingEditorLog.LogError($"SetupCscRsp failed to {description}.", ex);
+            }
+        }
+
+        /// <summary>
+        /// Deletes the redundant in-project analyzer copy that older package versions deployed to
+        /// <see cref="LegacyAnalyzerCopyFolder"/>. The source generator now ships under the
+        /// package's <c>Runtime/Analyzers</c> folder and applies automatically, so the copy is no
+        /// longer needed -- and, critically, leaving it in place makes BOTH copies generate into
+        /// every DxMessaging-referencing assembly, emitting each member twice (CS0102). Removing it
+        /// is therefore an upgrade requirement, not just cleanup.
+        /// </summary>
+        /// <remarks>
+        /// Called from <see cref="LegacyAnalyzerCopyCleanup"/> (an <c>AssetPostprocessor</c>) so the
+        /// removal lands during the asset import that PRECEDES script compilation -- before the two
+        /// copies can both feed the compiler -- and again from the <c>[InitializeOnLoad]</c> static
+        /// constructor as a post-compile backstop. Idempotent (a no-op once the folder is gone) and
+        /// conservative: it leaves the folder untouched if it holds anything other than the analyzer
+        /// DLLs this package deployed there. Returns <c>true</c> only when it actually deleted the
+        /// folder.
+        /// </remarks>
+        internal static bool TryRemoveLegacyAnalyzerCopy()
+        {
+            if (!AssetDatabase.IsValidFolder(LegacyAnalyzerCopyFolder))
+            {
+                return false;
+            }
+
+            // The only shape this package ever created here is a flat set of analyzer / Roslyn
+            // DLLs plus their auto-generated .meta sidecars. Inspect the on-disk folder and bail
+            // out if a consumer repurposed it for anything else.
+            string absoluteFolder = Path.GetFullPath(
+                Path.Combine(Application.dataPath, "..", LegacyAnalyzerCopyFolder)
+            );
+            if (!Directory.Exists(absoluteFolder))
+            {
+                return false;
+            }
+
+            // A real subdirectory means a consumer repurposed this folder for their own content;
+            // preserve it. The package only ever wrote a flat set of analyzer DLLs here, so the
+            // safe-to-remove check below sees only files (a subfolder named "x.dll" can never be
+            // mistaken for a DLL).
+            string[] files = Directory.GetFiles(absoluteFolder);
+            if (Directory.GetDirectories(absoluteFolder).Length > 0)
+            {
+                LogSkippedLegacyAnalyzerCopyCleanupIfNeeded(files);
+                return false;
+            }
+
+            if (!IsLegacyAnalyzerCopySafeToRemove(files))
+            {
+                LogSkippedLegacyAnalyzerCopyCleanupIfNeeded(files);
+                return false;
+            }
+
+            if (AssetDatabase.DeleteAsset(LegacyAnalyzerCopyFolder))
+            {
+                Debug.Log(
+                    "DxMessaging: removed the redundant in-project analyzer copy at "
+                        + LegacyAnalyzerCopyFolder
+                        + ". The source generator now ships under the package's Runtime/Analyzers "
+                        + "folder and applies automatically; nothing needs to live under Assets."
+                );
+                return true;
+            }
+
+            return false;
+        }
+
+        private static void LogSkippedLegacyAnalyzerCopyCleanupIfNeeded(IEnumerable<string> files)
+        {
+            if (
+                loggedSkippedLegacyAnalyzerCopyCleanup
+                || !ContainsKnownLegacyAnalyzerCopyEntry(files)
             )
             {
-                string dllPath = AssetDatabase.GUIDToAssetPath(dllGuid);
-                if (!dllPath.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
+                return;
+            }
+
+            loggedSkippedLegacyAnalyzerCopyCleanup = true;
+            Debug.LogWarning(
+                "DxMessaging: found a legacy in-project analyzer copy at "
+                    + LegacyAnalyzerCopyFolder
+                    + " but did not remove it because the folder contains content outside "
+                    + "the exact known package payload or is missing the required "
+                    + "DxMessaging source-generator DLL. Move consumer-owned files out of that folder, "
+                    + "then delete the stale DxMessaging analyzer DLLs manually to avoid "
+                    + "double-loading analyzers."
+            );
+        }
+
+        /// <summary>
+        /// True when the legacy analyzer-copy folder contains the first-party source generator and
+        /// every entry is one of the exact analyzer/dependency DLLs this package deployed there or
+        /// a matching <c>.dll.meta</c> sidecar. A subfolder, a foreign DLL, or any other file makes
+        /// this false so the folder is preserved rather than deleted.
+        /// </summary>
+        internal static bool IsLegacyAnalyzerCopySafeToRemove(IEnumerable<string> folderEntries)
+        {
+            HashSet<string> presentRequiredDlls = new(StringComparer.OrdinalIgnoreCase);
+            HashSet<string> seenEntryNames = new(StringComparer.OrdinalIgnoreCase);
+            foreach (string entry in folderEntries ?? Array.Empty<string>())
+            {
+                if (string.IsNullOrEmpty(entry))
                 {
                     continue;
                 }
 
-                if (!dllPath.Contains("Assets/Plugins", StringComparison.OrdinalIgnoreCase))
+                string name = GetLegacyAnalyzerCopyEntryName(entry);
+                if (string.IsNullOrEmpty(name) || !seenEntryNames.Add(name))
                 {
-                    string dllName = Path.GetFileName(dllPath);
-                    DllNames.Add(dllName);
+                    return false;
                 }
-            }
 
-            foreach (string requiredDllName in RequiredDllNames)
-            {
-                if (DllNames.Contains(requiredDllName))
+                if (name.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
                 {
+                    if (!KnownLegacyAnalyzerCopyDlls.Contains(name))
+                    {
+                        return false;
+                    }
+
+                    if (RequiredLegacyAnalyzerCopyDlls.Contains(name))
+                    {
+                        presentRequiredDlls.Add(name);
+                    }
+
                     continue;
                 }
 
-                foreach (string relativeDirectory in AnalyzerDirectories)
+                if (name.EndsWith(".dll.meta", StringComparison.OrdinalIgnoreCase))
                 {
-                    try
+                    string dllName = name.Substring(0, name.Length - ".meta".Length);
+                    if (!KnownLegacyAnalyzerCopyDlls.Contains(dllName))
                     {
-                        string sourceFile = $"{relativeDirectory}{requiredDllName}";
-                        if (!File.Exists(sourceFile))
-                        {
-                            continue;
-                        }
-
-                        const string pluginsDirectory =
-                            "Assets/Plugins/Editor/WallstopStudios.DxMessaging/";
-                        string outputAsset = $"{pluginsDirectory}{requiredDllName}";
-                        if (!Directory.Exists(pluginsDirectory))
-                        {
-                            Directory.CreateDirectory(pluginsDirectory);
-                            AssetDatabase.Refresh();
-                        }
-                        bool needsCopy = FilesDiffer(sourceFile, outputAsset);
-                        if (needsCopy)
-                        {
-                            File.Copy(sourceFile, outputAsset, true);
-                            AssetDatabase.ImportAsset(outputAsset);
-                        }
-
-                        if (AnalyzerLabeledDllNames.Contains(requiredDllName))
-                        {
-                            Object loadedDll = AssetDatabase.LoadMainAssetAtPath(outputAsset);
-                            if (loadedDll != null)
-                            {
-                                string[] existingLabels = AssetDatabase.GetLabels(loadedDll);
-                                if (!existingLabels.Contains("RoslynAnalyzer"))
-                                {
-                                    List<string> newLabels = existingLabels.ToList();
-                                    newLabels.Add("RoslynAnalyzer");
-                                    AssetDatabase.SetLabels(loadedDll, newLabels.ToArray());
-                                }
-                            }
-                        }
-
-                        if (AssetImporter.GetAtPath(outputAsset) is PluginImporter importer)
-                        {
-                            bool importerDirty = false;
-
-                            if (importer.GetCompatibleWithAnyPlatform())
-                            {
-                                importer.SetCompatibleWithAnyPlatform(false);
-                                importerDirty = true;
-                            }
-
-                            if (importer.GetExcludeFromAnyPlatform("Editor"))
-                            {
-                                importer.SetExcludeFromAnyPlatform("Editor", false);
-                                importerDirty = true;
-                            }
-
-                            if (!importer.GetExcludeFromAnyPlatform("Standalone"))
-                            {
-                                importer.SetExcludeFromAnyPlatform("Standalone", true);
-                                importerDirty = true;
-                            }
-
-                            if (importerDirty || needsCopy)
-                            {
-                                importer.SaveAndReimport();
-                            }
-                        }
-
-                        DllNames.Add(requiredDllName);
-                        break;
-                    }
-                    catch (Exception e)
-                    {
-                        Debug.LogError(
-                            $"Failed to copy {requiredDllName} to Assets, failed with {e}."
-                        );
+                        return false;
                     }
+
+                    continue;
                 }
-            }
 
-            if (DllNames.Count > 0)
-            {
-                AssetDatabase.Refresh();
+                return false;
             }
+
+            return presentRequiredDlls.Count == RequiredLegacyAnalyzerCopyDlls.Count;
         }
 
-        private static bool FilesDiffer(string sourcePath, string destinationPath)
+        private static string GetLegacyAnalyzerCopyEntryName(string entry)
         {
-            if (!File.Exists(destinationPath))
-            {
-                return true;
-            }
+            string normalizedEntry = entry.Replace("\\", "/");
+            int lastSeparator = normalizedEntry.LastIndexOf('/');
+            return lastSeparator >= 0
+                ? normalizedEntry.Substring(lastSeparator + 1)
+                : normalizedEntry;
+        }
 
-            FileInfo sourceInfo = new(sourcePath);
-            FileInfo destinationInfo = new(destinationPath);
-            if (sourceInfo.Length != destinationInfo.Length)
+        private static bool ContainsKnownLegacyAnalyzerCopyEntry(IEnumerable<string> folderEntries)
+        {
+            foreach (string entry in folderEntries ?? Array.Empty<string>())
             {
-                return true;
+                if (string.IsNullOrEmpty(entry))
+                {
+                    continue;
+                }
+
+                string name = GetLegacyAnalyzerCopyEntryName(entry);
+                if (KnownLegacyAnalyzerCopyDlls.Contains(name))
+                {
+                    return true;
+                }
+
+                if (!name.EndsWith(".dll.meta", StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                string dllName = name.Substring(0, name.Length - ".meta".Length);
+                if (KnownLegacyAnalyzerCopyDlls.Contains(dllName))
+                {
+                    return true;
+                }
             }
 
-            using FileStream sourceStream = File.OpenRead(sourcePath);
-            using FileStream destinationStream = File.OpenRead(destinationPath);
-            using SHA256 sha256 = SHA256.Create();
-            byte[] sourceHash = sha256.ComputeHash(sourceStream);
-            byte[] destinationHash = sha256.ComputeHash(destinationStream);
-            return !sourceHash.AsSpan().SequenceEqual(destinationHash);
+            return false;
         }
 
         /// <summary>
-        /// Synchronizes <c>csc.rsp</c> with the current set of analyzer arguments derived from the
-        /// on-disk DLL roster.
+        /// Removes stale DxMessaging analyzer <c>-a:</c> entries from <c>csc.rsp</c>.
         /// </summary>
+        /// <remarks>
+        /// DxMessaging analyzers are activated solely through the RoslynAnalyzer-labeled
+        /// DLLs shipped under the package's <c>Runtime/Analyzers</c> folder, which Unity
+        /// scopes to the runtime assembly and every assembly that references it (including
+        /// the predefined Assembly-CSharp). A stray <c>-a:</c> registration here (for
+        /// example, one left behind by an older package version that copied analyzers into
+        /// the project) double-loads the source generator, and registering dependency DLLs
+        /// as analyzers makes Unity's compiler path fragile, so this method strips them.
+        /// </remarks>
         private static void EnsureCscRsp()
         {
             try
             {
                 if (!File.Exists(RspFilePath))
                 {
-                    File.WriteAllText(RspFilePath, string.Empty);
-                    AssetDatabase.ImportAsset("csc.rsp");
+                    return;
                 }
 
                 string rspContent = File.ReadAllText(RspFilePath);
 
-                // Get current valid analyzer arguments
-                HashSet<string> currentAnalyzerArgs = new(
-                    GetAnalyzerArguments(),
-                    StringComparer.OrdinalIgnoreCase
+                string[] newLines = CleanDxMessagingAnalyzerLines(
+                    rspContent.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries),
+                    out bool foundStaleEntries
                 );
 
-                // Parse existing lines and filter out stale DxMessaging analyzer entries
-                List<string> newLines = new();
-                bool foundStaleEntries = false;
-
-                foreach (
-                    string line in rspContent.Split(
-                        new[] { '\r', '\n' },
-                        StringSplitOptions.RemoveEmptyEntries
-                    )
-                )
-                {
-                    string trimmedLine = line.Trim();
-
-                    // Check if this is a DxMessaging analyzer line
-                    bool isDxMessagingAnalyzer =
-                        trimmedLine.StartsWith("-a:", StringComparison.OrdinalIgnoreCase)
-                        && (
-                            trimmedLine.Contains(
-                                "com.wallstop-studios.dxmessaging",
-                                StringComparison.OrdinalIgnoreCase
-                            )
-                            || trimmedLine.Contains(
-                                "WallstopStudios.DxMessaging",
-                                StringComparison.OrdinalIgnoreCase
-                            )
-                        );
-
-                    if (isDxMessagingAnalyzer)
-                    {
-                        // Only keep if it's in the current valid set
-                        if (currentAnalyzerArgs.Contains(trimmedLine))
-                        {
-                            newLines.Add(trimmedLine);
-                        }
-                        else
-                        {
-                            foundStaleEntries = true;
-                        }
-                    }
-                    else
-                    {
-                        // Keep all non-DxMessaging lines as-is
-                        newLines.Add(trimmedLine);
-                    }
-                }
-
-                // Add any new analyzer arguments that aren't already present
-                bool foundNewEntries = false;
-                foreach (string analyzerArgument in currentAnalyzerArgs)
-                {
-                    if (!newLines.Contains(analyzerArgument, StringComparer.OrdinalIgnoreCase))
-                    {
-                        newLines.Add(analyzerArgument);
-                        foundNewEntries = true;
-                    }
-                }
-
-                bool modified = foundStaleEntries || foundNewEntries;
-
-                if (modified)
+                if (foundStaleEntries)
                 {
                     // Write the cleaned up content
                     string newContent = string.Join(Environment.NewLine, newLines);
@@ -309,8 +324,77 @@ namespace DxMessaging.Editor
             }
             catch (IOException ex)
             {
-                Debug.LogError($"Failed to modify csc.rsp: {ex}");
+                DxMessagingEditorLog.LogError("Failed to modify csc.rsp.", ex);
+            }
+        }
+
+        internal static string[] CleanDxMessagingAnalyzerLines(
+            IEnumerable<string> lines,
+            out bool foundStaleEntries
+        )
+        {
+            List<string> newLines = new();
+            foundStaleEntries = false;
+
+            foreach (string line in lines ?? Array.Empty<string>())
+            {
+                string trimmedLine = line?.Trim();
+                if (string.IsNullOrEmpty(trimmedLine))
+                {
+                    continue;
+                }
+
+                if (IsResponseFileComment(trimmedLine))
+                {
+                    newLines.Add(trimmedLine);
+                    continue;
+                }
+
+                List<string> retainedArguments = new();
+                bool removedFromLine = false;
+                foreach (string argument in SplitResponseFileArguments(trimmedLine))
+                {
+                    if (IsDxMessagingAnalyzerArgument(argument))
+                    {
+                        foundStaleEntries = true;
+                        removedFromLine = true;
+                        continue;
+                    }
+
+                    retainedArguments.Add(argument);
+                }
+
+                if (removedFromLine)
+                {
+                    if (retainedArguments.Count > 0)
+                    {
+                        newLines.Add(string.Join(" ", retainedArguments));
+                    }
+                    continue;
+                }
+
+                newLines.Add(trimmedLine);
             }
+
+            return newLines.ToArray();
+        }
+
+        private static bool IsDxMessagingAnalyzerArgument(string trimmedLine)
+        {
+            return (
+                    TryGetCompilerOptionValue(trimmedLine, "a", out string _)
+                    || TryGetCompilerOptionValue(trimmedLine, "analyzer", out string _)
+                )
+                && (
+                    trimmedLine.Contains(
+                        "com.wallstop-studios.dxmessaging",
+                        StringComparison.OrdinalIgnoreCase
+                    )
+                    || trimmedLine.Contains(
+                        "WallstopStudios.DxMessaging",
+                        StringComparison.OrdinalIgnoreCase
+                    )
+                );
         }
 
         /// <summary>
@@ -319,19 +403,14 @@ namespace DxMessaging.Editor
         /// entries pointing at moved or deleted sidecar paths are removed.
         /// </summary>
         /// <remarks>
-        /// The sidecar is generated by <see cref="DxMessagingBaseCallIgnoreSync"/> only when there
-        /// is content to write. csc happily runs without it, so this method does NOT auto-create.
+        /// The sidecar is generated by <see cref="DxMessagingBaseCallIgnoreSync"/>. csc happily
+        /// runs without it, so this method does NOT auto-create; sidecar writes schedule this sync
+        /// again after deferred regeneration completes.
         /// </remarks>
         private static void EnsureAdditionalFileForIgnoreList()
         {
             try
             {
-                if (!File.Exists(RspFilePath))
-                {
-                    File.WriteAllText(RspFilePath, string.Empty);
-                    AssetDatabase.ImportAsset("csc.rsp");
-                }
-
                 string sidecarRelativePath = DxMessagingBaseCallIgnoreSync.SidecarAssetPath;
                 string projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."))
                     .Replace("\\", "/");
@@ -339,74 +418,28 @@ namespace DxMessaging.Editor
                     .Replace("\\", "/");
 
                 bool sidecarExists = File.Exists(sidecarAbsolutePath);
-                string desiredLine = $"-additionalfile:\"{sidecarRelativePath}\"";
-
-                string rspContent = File.ReadAllText(RspFilePath);
-                List<string> newLines = new();
-                bool foundDesired = false;
-                bool foundStale = false;
-
-                foreach (
-                    string line in rspContent.Split(
-                        new[] { '\r', '\n' },
-                        StringSplitOptions.RemoveEmptyEntries
-                    )
-                )
+                if (!File.Exists(RspFilePath))
                 {
-                    string trimmedLine = line.Trim();
-
-                    bool isDxMessagingAdditionalFile =
-                        trimmedLine.StartsWith(
-                            "-additionalfile:",
-                            StringComparison.OrdinalIgnoreCase
-                        )
-                        && trimmedLine.Contains("DxMessaging.", StringComparison.OrdinalIgnoreCase)
-                        && trimmedLine.Contains(
-                            "BaseCallIgnore",
-                            StringComparison.OrdinalIgnoreCase
-                        );
-
-                    if (isDxMessagingAdditionalFile)
+                    if (!sidecarExists)
                     {
-                        if (
-                            sidecarExists
-                            && string.Equals(
-                                trimmedLine,
-                                desiredLine,
-                                StringComparison.OrdinalIgnoreCase
-                            )
-                        )
-                        {
-                            if (!foundDesired)
-                            {
-                                newLines.Add(trimmedLine);
-                                foundDesired = true;
-                            }
-                            else
-                            {
-                                // Drop duplicate.
-                                foundStale = true;
-                            }
-                        }
-                        else
-                        {
-                            // Stale entry pointing at a moved/renamed/deleted sidecar; drop it.
-                            foundStale = true;
-                        }
+                        return;
                     }
-                    else
-                    {
-                        newLines.Add(trimmedLine);
-                    }
-                }
 
-                bool needsAppend = sidecarExists && !foundDesired;
-                if (needsAppend)
-                {
-                    newLines.Add(desiredLine);
+                    File.WriteAllText(
+                        RspFilePath,
+                        FormatAdditionalFileArgument(sidecarRelativePath) + Environment.NewLine
+                    );
+                    AssetDatabase.ImportAsset("csc.rsp");
+                    Debug.Log("Updated csc.rsp additionalfile entries.");
+                    return;
                 }
 
-                bool modified = foundStale || needsAppend;
+                string[] newLines = SynchronizeAdditionalFileForIgnoreListLines(
+                    File.ReadAllLines(RspFilePath),
+                    sidecarRelativePath,
+                    sidecarExists,
+                    out bool modified
+                );
 
                 if (modified)
                 {
@@ -422,46 +455,248 @@ namespace DxMessaging.Editor
             }
             catch (IOException ex)
             {
-                Debug.LogError($"Failed to update csc.rsp additionalfile entry: {ex}");
+                DxMessagingEditorLog.LogError("Failed to update csc.rsp additionalfile entry.", ex);
             }
         }
 
-        private static IEnumerable<string> GetAnalyzerArguments()
+        internal static string[] SynchronizeAdditionalFileForIgnoreListLines(
+            IEnumerable<string> lines,
+            string sidecarRelativePath,
+            bool sidecarExists,
+            out bool modified
+        )
         {
-            HashSet<string> yielded = new(StringComparer.OrdinalIgnoreCase);
-            string projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
+            string desiredLine = FormatAdditionalFileArgument(sidecarRelativePath);
+            List<string> newLines = new();
+            bool foundDesired = false;
+            bool foundStale = false;
 
-            foreach (string directory in AnalyzerDirectories)
+            foreach (string line in lines ?? Array.Empty<string>())
             {
-                foreach (string dllName in RequiredDllNames)
+                string trimmedLine = line?.Trim();
+                if (string.IsNullOrEmpty(trimmedLine))
                 {
-                    string absoluteDirectory = Path.IsPathRooted(directory)
-                        ? directory
-                        : Path.GetFullPath(Path.Combine(projectRoot, directory));
+                    continue;
+                }
+
+                if (IsResponseFileComment(trimmedLine))
+                {
+                    newLines.Add(trimmedLine);
+                    continue;
+                }
 
-                    string absoluteAnalyzerPath = Path.Combine(absoluteDirectory, dllName);
-                    if (!File.Exists(absoluteAnalyzerPath))
+                List<string> retainedArguments = new();
+                bool removedFromLine = false;
+                foreach (string argument in SplitResponseFileArguments(trimmedLine))
+                {
+                    if (!IsDxMessagingBaseCallIgnoreAdditionalFile(argument))
                     {
+                        retainedArguments.Add(argument);
                         continue;
                     }
 
-                    string projectRelativePath = FileUtil.GetProjectRelativePath(
-                        absoluteAnalyzerPath
-                    );
-                    if (string.IsNullOrEmpty(projectRelativePath))
+                    bool isDesired =
+                        sidecarExists
+                        && IsAdditionalFileArgumentForPath(argument, sidecarRelativePath);
+                    if (!isDesired)
                     {
+                        // Stale entry pointing at a moved/renamed/deleted sidecar; drop it.
+                        foundStale = true;
+                        removedFromLine = true;
                         continue;
                     }
 
-                    string normalizedRelativePath = projectRelativePath.Replace("\\", "/");
-                    if (!yielded.Add(normalizedRelativePath))
+                    if (foundDesired)
                     {
+                        // Drop duplicate.
+                        foundStale = true;
+                        removedFromLine = true;
                         continue;
                     }
 
-                    yield return $"-a:\"{normalizedRelativePath}\"";
+                    retainedArguments.Add(desiredLine);
+                    foundDesired = true;
+                    if (!string.Equals(argument, desiredLine, StringComparison.Ordinal))
+                    {
+                        foundStale = true;
+                        removedFromLine = true;
+                    }
+                }
+
+                if (retainedArguments.Count > 0)
+                {
+                    newLines.Add(string.Join(" ", retainedArguments));
+                    continue;
+                }
+
+                if (!removedFromLine)
+                {
+                    newLines.Add(trimmedLine);
+                }
+            }
+
+            bool needsAppend = sidecarExists && !foundDesired;
+            if (needsAppend)
+            {
+                newLines.Add(desiredLine);
+            }
+
+            modified = foundStale || needsAppend;
+            return newLines.ToArray();
+        }
+
+        private static string FormatAdditionalFileArgument(string sidecarRelativePath)
+        {
+            return $"-additionalfile:\"{sidecarRelativePath}\"";
+        }
+
+        private static bool IsResponseFileComment(string trimmedLine)
+        {
+            return trimmedLine.StartsWith("#", StringComparison.Ordinal);
+        }
+
+        private static bool IsDxMessagingBaseCallIgnoreAdditionalFile(string trimmedLine)
+        {
+            return TryGetCompilerOptionValue(trimmedLine, "additionalfile", out string value)
+                && value.Contains("DxMessaging.", StringComparison.OrdinalIgnoreCase)
+                && value.Contains("BaseCallIgnore", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static bool IsAdditionalFileArgumentForPath(
+            string argument,
+            string sidecarRelativePath
+        )
+        {
+            if (!TryGetCompilerOptionValue(argument, "additionalfile", out string value))
+            {
+                return false;
+            }
+
+            string unquotedValue = UnquoteWholeArgument(value.Trim());
+            return string.Equals(
+                unquotedValue.Replace("\\", "/"),
+                sidecarRelativePath,
+                StringComparison.OrdinalIgnoreCase
+            );
+        }
+
+        private static bool TryGetCompilerOptionValue(
+            string argument,
+            string optionName,
+            out string value
+        )
+        {
+            value = string.Empty;
+            if (string.IsNullOrEmpty(argument) || string.IsNullOrEmpty(optionName))
+            {
+                return false;
+            }
+
+            string unquotedArgument = UnquoteWholeArgument(argument.Trim());
+            if (unquotedArgument.Length <= optionName.Length + 1)
+            {
+                return false;
+            }
+
+            if (unquotedArgument[0] != '-' && unquotedArgument[0] != '/')
+            {
+                return false;
+            }
+
+            if (unquotedArgument[optionName.Length + 1] != ':')
+            {
+                return false;
+            }
+
+            if (
+                string.Compare(
+                    unquotedArgument,
+                    1,
+                    optionName,
+                    0,
+                    optionName.Length,
+                    StringComparison.OrdinalIgnoreCase
+                ) != 0
+            )
+            {
+                return false;
+            }
+
+            value = unquotedArgument.Substring(optionName.Length + 2);
+            return true;
+        }
+
+        private static string UnquoteWholeArgument(string argument)
+        {
+            if (argument.Length >= 2 && argument[0] == '"' && argument[argument.Length - 1] == '"')
+            {
+                return argument.Substring(1, argument.Length - 2).Replace("\"\"", "\"");
+            }
+
+            return argument;
+        }
+
+        private static List<string> SplitResponseFileArguments(string line)
+        {
+            List<string> arguments = new();
+            if (string.IsNullOrWhiteSpace(line))
+            {
+                return arguments;
+            }
+
+            System.Text.StringBuilder current = new();
+            bool inQuotes = false;
+            foreach (char character in line)
+            {
+                if (character == '"')
+                {
+                    inQuotes = !inQuotes;
+                    current.Append(character);
+                    continue;
                 }
+
+                if (char.IsWhiteSpace(character) && !inQuotes)
+                {
+                    if (current.Length > 0)
+                    {
+                        arguments.Add(current.ToString());
+                        current.Clear();
+                    }
+                    continue;
+                }
+
+                current.Append(character);
+            }
+
+            if (current.Length > 0)
+            {
+                arguments.Add(current.ToString());
             }
+
+            return arguments;
+        }
+    }
+
+    /// <summary>
+    /// Removes the legacy in-project analyzer copy (via
+    /// <see cref="SetupCscRsp.TryRemoveLegacyAnalyzerCopy"/>) during the asset import that PRECEDES
+    /// script compilation. This is the primary upgrade path: deleting the redundant copy before the
+    /// compiler runs prevents it and the package's Runtime/Analyzers copy from both generating into
+    /// the same assembly (which would emit each member twice -- CS0102). It is a cheap no-op in the
+    /// steady state: once the folder is gone, <c>AssetDatabase.IsValidFolder</c> short-circuits on
+    /// every subsequent import.
+    /// </summary>
+    internal sealed class LegacyAnalyzerCopyCleanup : AssetPostprocessor
+    {
+        // Classic four-argument signature so this compiles on every supported Unity (2021.3+).
+        private static void OnPostprocessAllAssets(
+            string[] importedAssets,
+            string[] deletedAssets,
+            string[] movedAssets,
+            string[] movedFromAssetPaths
+        )
+        {
+            SetupCscRsp.TryRemoveLegacyAnalyzerCopy();
         }
     }
 }