com.wallstop-studios.dxmessaging 3.0.1 → 3.1.0

package/Editor/SetupCscRsp.cs

@@ -31,10 +31,9 @@ namespace DxMessaging.Editor
         private static readonly string SourceGeneratorDllName =
             "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.
+        // 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
@@ -73,9 +72,36 @@ namespace DxMessaging.Editor
 
         static SetupCscRsp()
         {
-            EditorApplication.delayCall += EnsureDLLsExistInAssets;
-            EditorApplication.delayCall += EnsureCscRsp;
-            EditorApplication.delayCall += EnsureAdditionalFileForIgnoreList;
+            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()
@@ -149,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;
                             }
 
@@ -176,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
                         );
                     }
                 }
@@ -214,9 +248,14 @@ namespace DxMessaging.Editor
         }
 
         /// <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
+        /// <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
@@ -229,72 +268,12 @@ namespace DxMessaging.Editor
 
                 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,18 +288,88 @@ 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>
         /// 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"/> 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()
         {
@@ -339,74 +388,12 @@ 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
-                    )
-                )
-                {
-                    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
-                            && 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;
-                        }
-                    }
-                    else
-                    {
-                        newLines.Add(trimmedLine);
-                    }
-                }
-
-                bool needsAppend = sidecarExists && !foundDesired;
-                if (needsAppend)
-                {
-                    newLines.Add(desiredLine);
-                }
-
-                bool modified = foundStale || needsAppend;
+                string[] newLines = SynchronizeAdditionalFileForIgnoreListLines(
+                    File.ReadAllLines(RspFilePath),
+                    sidecarRelativePath,
+                    sidecarExists,
+                    out bool modified
+                );
 
                 if (modified)
                 {
@@ -422,46 +409,225 @@ 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))
+                {
+                    continue;
+                }
+
+                if (IsResponseFileComment(trimmedLine))
                 {
-                    string absoluteDirectory = Path.IsPathRooted(directory)
-                        ? directory
-                        : Path.GetFullPath(Path.Combine(projectRoot, directory));
+                    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;
         }
     }
 }

package/Editor/SetupCscRsp.cs.meta

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

package/Editor/Testing/MessagingComponentEditorHarness.cs

@@ -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
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant: