com.wallstop-studios.dxmessaging 2.2.0 → 3.1.0

package/Editor/SetupCscRsp.cs

@@ -7,6 +7,7 @@ namespace DxMessaging.Editor
     using System.IO;
     using System.Linq;
     using System.Security.Cryptography;
+    using DxMessaging.Editor.Settings;
     using UnityEditor;
     using UnityEngine;
     using Object = UnityEngine.Object;
@@ -30,9 +31,19 @@ namespace DxMessaging.Editor
         private static readonly string SourceGeneratorDllName =
             "WallstopStudios.DxMessaging.SourceGenerators.dll";
 
+        // The analyzer DLL is a SEPARATE assembly, but both compiler-host DLLs are pinned to
+        // Unity 2021-compatible Roslyn 3.8.0. They 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 =
         {
             SourceGeneratorDllName,
+            AnalyzerDllName,
             "Microsoft.CodeAnalysis.dll",
             "Microsoft.CodeAnalysis.CSharp.dll",
             "System.Text.Encodings.Web.dll",
@@ -44,15 +55,53 @@ namespace DxMessaging.Editor
             "System.Threading.Tasks.Extensions.dll",
             "System.Numerics.Vectors.dll",
             "System.Text.Encoding.CodePages.dll",
-            "Microsoft.Bcl.AsyncInterfaces.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
+        )
+        {
+            SourceGeneratorDllName,
+            AnalyzerDllName,
         };
 
         private static readonly HashSet<string> DllNames = new(StringComparer.OrdinalIgnoreCase);
 
         static SetupCscRsp()
         {
-            EditorApplication.delayCall += EnsureDLLsExistInAssets;
-            EditorApplication.delayCall += EnsureCscRsp;
+            ScheduleSetupStep(EnsureDLLsExistInAssets, "copy analyzer DLLs into Assets");
+            ScheduleSetupStep(EnsureCscRsp, "clean csc.rsp analyzer entries");
+            ScheduleAdditionalFileForIgnoreListSync();
+        }
+
+        internal static void ScheduleAdditionalFileForIgnoreListSync()
+        {
+            ScheduleSetupStep(
+                EnsureAdditionalFileForIgnoreList,
+                "sync csc.rsp base-call ignore additionalfile entry"
+            );
+        }
+
+        private static void ScheduleSetupStep(Action work, string description)
+        {
+            DxMessagingEditorIdle.ScheduleAssetDatabaseMutation(() =>
+                RunSetupStep(work, description)
+            );
+        }
+
+        private static void RunSetupStep(Action work, string description)
+        {
+            try
+            {
+                work();
+            }
+            catch (Exception ex)
+            {
+                DxMessagingEditorLog.LogError($"SetupCscRsp failed to {description}.", ex);
+            }
         }
 
         private static void EnsureDLLsExistInAssets()
@@ -107,7 +156,7 @@ namespace DxMessaging.Editor
                             AssetDatabase.ImportAsset(outputAsset);
                         }
 
-                        if (requiredDllName == SourceGeneratorDllName)
+                        if (AnalyzerLabeledDllNames.Contains(requiredDllName))
                         {
                             Object loadedDll = AssetDatabase.LoadMainAssetAtPath(outputAsset);
                             if (loadedDll != null)
@@ -126,21 +175,28 @@ namespace DxMessaging.Editor
                         {
                             bool importerDirty = false;
 
+                            // A RoslynAnalyzer-labeled DLL must be EXCLUDED from every
+                            // build platform, including the Editor, so Unity treats it as a
+                            // C# compiler analyzer rather than a managed precompiled
+                            // assembly. The same-named DLL is importable from two locations
+                            // (the package's own Editor/Analyzers copy and this Assets
+                            // copy); if either is an Editor-enabled precompiled assembly,
+                            // Unity 2021 aborts with "Multiple precompiled assemblies with
+                            // the same name". The Roslyn runtime dependencies in the same
+                            // folder already ship Editor-disabled and never collide -- this
+                            // converges the analyzer DLLs onto that proven-safe shape.
+                            // NOTE: SetExcludeFromAnyPlatform is a no-op once
+                            // CompatibleWithAnyPlatform is false, so the Editor platform is
+                            // disabled through the effective SetCompatibleWithEditor API.
                             if (importer.GetCompatibleWithAnyPlatform())
                             {
                                 importer.SetCompatibleWithAnyPlatform(false);
                                 importerDirty = true;
                             }
 
-                            if (importer.GetExcludeFromAnyPlatform("Editor"))
-                            {
-                                importer.SetExcludeFromAnyPlatform("Editor", false);
-                                importerDirty = true;
-                            }
-
-                            if (!importer.GetExcludeFromAnyPlatform("Standalone"))
+                            if (importer.GetCompatibleWithEditor())
                             {
-                                importer.SetExcludeFromAnyPlatform("Standalone", true);
+                                importer.SetCompatibleWithEditor(false);
                                 importerDirty = true;
                             }
 
@@ -153,10 +209,11 @@ namespace DxMessaging.Editor
                         DllNames.Add(requiredDllName);
                         break;
                     }
-                    catch (Exception e)
+                    catch (Exception ex)
                     {
-                        Debug.LogError(
-                            $"Failed to copy {requiredDllName} to Assets, failed with {e}."
+                        DxMessagingEditorLog.LogError(
+                            $"Failed to copy {requiredDllName} to Assets.",
+                            ex
                         );
                     }
                 }
@@ -190,6 +247,15 @@ namespace DxMessaging.Editor
             return !sourceHash.AsSpan().SequenceEqual(destinationHash);
         }
 
+        /// <summary>
+        /// Removes stale DxMessaging analyzer <c>-a:</c> entries from <c>csc.rsp</c>.
+        /// </summary>
+        /// <remarks>
+        /// DxMessaging analyzers are activated solely through the RoslynAnalyzer-labeled
+        /// <c>Assets/Plugins/Editor/WallstopStudios.DxMessaging</c> copy. A second
+        /// <c>-a:</c> registration here double-loads the analyzer/source-generator, and
+        /// registering dependency DLLs as analyzers makes Unity's compiler path fragile.
+        /// </remarks>
         private static void EnsureCscRsp()
         {
             try
@@ -201,66 +267,367 @@ namespace DxMessaging.Editor
                 }
 
                 string rspContent = File.ReadAllText(RspFilePath);
-                bool modified = false;
-                foreach (string analyzerArgument in GetAnalyzerArguments())
+
+                string[] newLines = CleanDxMessagingAnalyzerLines(
+                    rspContent.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries),
+                    out bool foundStaleEntries
+                );
+
+                if (foundStaleEntries)
                 {
-                    if (rspContent.Contains(analyzerArgument, StringComparison.OrdinalIgnoreCase))
+                    // Write the cleaned up content
+                    string newContent = string.Join(Environment.NewLine, newLines);
+                    if (!string.IsNullOrEmpty(newContent))
                     {
+                        newContent += Environment.NewLine;
+                    }
+                    File.WriteAllText(RspFilePath, newContent);
+                    AssetDatabase.ImportAsset("csc.rsp");
+                    Debug.Log("Updated csc.rsp.");
+                }
+            }
+            catch (IOException 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;
                     }
 
-                    File.AppendAllText(RspFilePath, analyzerArgument + Environment.NewLine);
-                    modified = true;
+                    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>
+        /// Ensures <c>csc.rsp</c> contains a single <c>-additionalfile:</c> line pointing at the
+        /// base-call ignore sidecar, when (and only when) that sidecar physically exists. Stale
+        /// entries pointing at moved or deleted sidecar paths are removed.
+        /// </summary>
+        /// <remarks>
+        /// 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("\\", "/");
+                string sidecarAbsolutePath = Path.Combine(projectRoot, sidecarRelativePath)
+                    .Replace("\\", "/");
+
+                bool sidecarExists = File.Exists(sidecarAbsolutePath);
+                string[] newLines = SynchronizeAdditionalFileForIgnoreListLines(
+                    File.ReadAllLines(RspFilePath),
+                    sidecarRelativePath,
+                    sidecarExists,
+                    out bool modified
+                );
+
                 if (modified)
                 {
+                    string newContent = string.Join(Environment.NewLine, newLines);
+                    if (!string.IsNullOrEmpty(newContent))
+                    {
+                        newContent += Environment.NewLine;
+                    }
+                    File.WriteAllText(RspFilePath, newContent);
                     AssetDatabase.ImportAsset("csc.rsp");
-                    Debug.Log("Updated csc.rsp.");
+                    Debug.Log("Updated csc.rsp additionalfile entries.");
                 }
             }
             catch (IOException ex)
             {
-                Debug.LogError($"Failed to modify csc.rsp: {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;
+                }
 
-                    string absoluteAnalyzerPath = Path.Combine(absoluteDirectory, dllName);
-                    if (!File.Exists(absoluteAnalyzerPath))
+                if (IsResponseFileComment(trimmedLine))
+                {
+                    newLines.Add(trimmedLine);
+                    continue;
+                }
+
+                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;
         }
     }
 }

package/Editor/SetupCscRsp.cs.meta

@@ -1,3 +1,11 @@
-fileFormatVersion: 2
-guid: 54bd01ff5fd34bbc9950a1c7230a15d8
-timeCreated: 1730841461
+fileFormatVersion: 2
+guid: 54bd01ff5fd34bbc9950a1c7230a15d8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/Testing/MessagingComponentEditorHarness.cs

@@ -7,7 +7,7 @@ namespace DxMessaging.Editor.Testing
     using Core;
     using Core.Diagnostics;
     using Core.MessageBus;
-    using Unity;
+    using DxMessaging.Unity;
     using UnityEngine;
 
     /// <summary>
@@ -39,7 +39,7 @@ namespace DxMessaging.Editor.Testing
             }
 
             List<ListenerDiagnosticsView> listenerViews = component
-                ._registeredListeners.OrderBy(pair => pair.Key.GetInstanceID())
+                ._registeredListeners.OrderBy(pair => InstanceId.StableId(pair.Key))
                 .Select(pair => CreateListenerView(pair.Key, pair.Value))
                 .ToList();
 

package/Editor/Testing/MessagingComponentEditorHarness.cs.meta

@@ -1,3 +1,11 @@
-fileFormatVersion: 2
-guid: 2624c9e8eb5243ebb71545774f411c2c
-timeCreated: 1761880591
+fileFormatVersion: 2
+guid: 2624c9e8eb5243ebb71545774f411c2c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/Testing.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: a61780c8ba084b29bb44fdefc9b7fcf2
-timeCreated: 1761880591
+fileFormatVersion: 2
+guid: a61780c8ba084b29bb44fdefc9b7fcf2
+timeCreated: 1761880591

package/Editor/WallstopStudios.DxMessaging.Editor.asmdef

@@ -1,14 +1,14 @@
-{
-  "name": "WallstopStudios.DxMessaging.Editor",
-  "rootNamespace": "DxMessaging.Editor",
-  "references": ["WallstopStudios.DxMessaging"],
-  "includePlatforms": ["Editor"],
-  "excludePlatforms": [],
-  "allowUnsafeCode": false,
-  "overrideReferences": false,
-  "precompiledReferences": [],
-  "autoReferenced": true,
-  "defineConstraints": [],
-  "versionDefines": [],
-  "noEngineReferences": false
-}
+{
+  "name": "WallstopStudios.DxMessaging.Editor",
+  "rootNamespace": "DxMessaging.Editor",
+  "references": ["WallstopStudios.DxMessaging"],
+  "includePlatforms": ["Editor"],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "precompiledReferences": [],
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}

package/Editor/WallstopStudios.DxMessaging.Editor.asmdef.meta

@@ -1,7 +1,7 @@
-fileFormatVersion: 2
-guid: 4be90ea11db262f43913b0e065a25c7f
-AssemblyDefinitionImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 4be90ea11db262f43913b0e065a25c7f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor.meta

@@ -1,8 +1,8 @@
-fileFormatVersion: 2
-guid: 41dce8be641afe34ca8363865b8cd5d9
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 41dce8be641afe34ca8363865b8cd5d9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: