com.wallstop-studios.dxmessaging 2.2.0 → 3.0.1

package/Editor/Settings/DxMessagingBaseCallIgnoreSync.cs

@@ -0,0 +1,190 @@
+namespace DxMessaging.Editor.Settings
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Text;
+    using UnityEditor;
+    using UnityEngine;
+
+    /// <summary>
+    /// Synchronizes the <see cref="DxMessagingSettings._baseCallIgnoredTypes"/> list to a sidecar
+    /// text file shipped to the Roslyn analyzer via <c>csc.rsp</c>'s <c>-additionalfile</c> switch.
+    /// </summary>
+    /// <remarks>
+    /// The sidecar is a build-derived view: never hand-edited, always regenerated from the
+    /// ScriptableObject. The analyzer reads it because it cannot parse Unity-serialized YAML.
+    /// </remarks>
+    public static class DxMessagingBaseCallIgnoreSync
+    {
+        /// <summary>
+        /// Project-relative path to the auto-generated sidecar file. Other Editor scripts
+        /// (e.g., <see cref="SetupCscRsp"/>) reference this constant when wiring
+        /// <c>-additionalfile</c> entries.
+        /// </summary>
+        public const string SidecarAssetPath = "Assets/Editor/DxMessaging.BaseCallIgnore.txt";
+
+        private const string HeaderComment =
+            "# Auto-generated from Assets/Editor/DxMessagingSettings.asset; edit there instead.";
+        private const string FormatComment =
+            "# One fully-qualified type name per line. Lines starting with # are comments.";
+
+        /// <summary>
+        /// Regenerates the sidecar text file from the supplied settings asset. Writes only when
+        /// the on-disk content differs from what would be written, matching the
+        /// <c>FilesDiffer</c>-style policy used elsewhere in this Editor assembly to avoid
+        /// AssetDatabase churn during domain reload.
+        /// </summary>
+        /// <param name="settings">The settings asset. May be <c>null</c> -- no-op in that case.</param>
+        /// <remarks>
+        /// When called while Unity is mid-compile or mid-asset-import (e.g., from a
+        /// <c>ScriptableObject.OnValidate</c> that fires during a domain reload), the actual
+        /// regen is deferred via <see cref="EditorApplication.delayCall"/> so we don't trip
+        /// AssetDatabase reentrancy guards. Direct calls from EditMode tests run synchronously
+        /// because tests don't execute during update/compile.
+        /// </remarks>
+        public static void RegenerateSidecar(DxMessagingSettings settings)
+        {
+            if (settings == null)
+            {
+                return;
+            }
+
+            if (EditorApplication.isUpdating || EditorApplication.isCompiling)
+            {
+                EditorApplication.delayCall += () => RegenerateSidecarCore(settings);
+                return;
+            }
+
+            RegenerateSidecarCore(settings);
+        }
+
+        private static void RegenerateSidecarCore(DxMessagingSettings settings)
+        {
+            if (settings == null)
+            {
+                return;
+            }
+
+            try
+            {
+                string newContent = BuildContent(settings._baseCallIgnoredTypes);
+                string absolutePath = GetAbsolutePath();
+                EnsureParentDirectoryExists(absolutePath);
+
+                if (File.Exists(absolutePath))
+                {
+                    string existing = File.ReadAllText(absolutePath);
+                    if (string.Equals(existing, newContent, StringComparison.Ordinal))
+                    {
+                        return;
+                    }
+                }
+
+                File.WriteAllText(absolutePath, newContent);
+                AssetDatabase.ImportAsset(SidecarAssetPath);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning(
+                    $"[DxMessaging] Failed to write base-call ignore sidecar at '{SidecarAssetPath}': {ex.Message}"
+                );
+            }
+        }
+
+        /// <summary>
+        /// Reads the sidecar file and returns its non-comment, non-blank entries.
+        /// Tolerant of a missing file (returns an empty list) and of <c>#</c>-prefixed comment lines.
+        /// </summary>
+        public static IReadOnlyList<string> ReadSidecar()
+        {
+            try
+            {
+                string absolutePath = GetAbsolutePath();
+                if (!File.Exists(absolutePath))
+                {
+                    return Array.Empty<string>();
+                }
+
+                List<string> entries = new();
+                foreach (string rawLine in File.ReadAllLines(absolutePath))
+                {
+                    if (string.IsNullOrWhiteSpace(rawLine))
+                    {
+                        continue;
+                    }
+                    string trimmed = rawLine.Trim();
+                    if (trimmed.Length == 0 || trimmed[0] == '#')
+                    {
+                        continue;
+                    }
+                    entries.Add(trimmed);
+                }
+                return entries;
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning(
+                    $"[DxMessaging] Failed to read base-call ignore sidecar at '{SidecarAssetPath}': {ex.Message}"
+                );
+                return Array.Empty<string>();
+            }
+        }
+
+        internal static string BuildContent(IList<string> ignoredTypes)
+        {
+            StringBuilder builder = new();
+            builder.Append(HeaderComment).Append('\n');
+            builder.Append(FormatComment).Append('\n');
+
+            if (ignoredTypes == null)
+            {
+                return builder.ToString();
+            }
+
+            // Deterministic order for git-friendly diffs; deduplicate while preserving the user's
+            // typed casing where possible (Ordinal sort with Ordinal-set dedupe).
+            HashSet<string> seen = new(StringComparer.Ordinal);
+            List<string> sorted = new(ignoredTypes.Count);
+            foreach (string entry in ignoredTypes)
+            {
+                if (string.IsNullOrWhiteSpace(entry))
+                {
+                    continue;
+                }
+                string trimmed = entry.Trim();
+                if (seen.Add(trimmed))
+                {
+                    sorted.Add(trimmed);
+                }
+            }
+            sorted.Sort(StringComparer.Ordinal);
+
+            foreach (string entry in sorted)
+            {
+                builder.Append(entry).Append('\n');
+            }
+            return builder.ToString();
+        }
+
+        private static string GetAbsolutePath()
+        {
+            // Application.dataPath ends in "/Assets"; SidecarAssetPath begins with "Assets/".
+            string projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."))
+                .Replace("\\", "/");
+            return Path.Combine(projectRoot, SidecarAssetPath).Replace("\\", "/");
+        }
+
+        private static void EnsureParentDirectoryExists(string absolutePath)
+        {
+            string directory = Path.GetDirectoryName(absolutePath);
+            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+        }
+    }
+#endif
+}

package/Editor/Settings/DxMessagingBaseCallIgnoreSync.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 99dc9d314eff4388bba3679e20ca06c8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Settings/DxMessagingSettings.cs

@@ -1,6 +1,7 @@
 namespace DxMessaging.Editor.Settings
 {
 #if UNITY_EDITOR
+    using System.Collections.Generic;
     using System.Linq;
     using Core.MessageBus;
     using UnityEditor;
@@ -32,6 +33,15 @@ namespace DxMessaging.Editor.Settings
         [SerializeField]
         internal bool _suppressDomainReloadWarning = true;
 
+        [SerializeField]
+        internal List<string> _baseCallIgnoredTypes = new();
+
+        [SerializeField]
+        internal bool _baseCallCheckEnabled = true;
+
+        [SerializeField]
+        internal bool _useConsoleBridge;
+
         /// <summary>
         /// Controls <see cref="DiagnosticsTarget"/> values applied to <see cref="IMessageBus.GlobalDiagnosticsTargets"/>.
         /// </summary>
@@ -59,6 +69,94 @@ namespace DxMessaging.Editor.Settings
             set => _suppressDomainReloadWarning = value;
         }
 
+        /// <summary>
+        /// Master toggle for the <c>MessageAwareComponent</c> base-call check (DXMSG006/007/008).
+        /// When <c>false</c>, the Inspector overlay and per-type warnings are silenced; the underlying
+        /// compile-time analyzer warnings remain unless explicitly suppressed via <c>.editorconfig</c>.
+        /// </summary>
+        /// <remarks>
+        /// S3: toggling from <c>false</c> back to <c>true</c> pokes
+        /// <see cref="DxMessaging.Editor.Analyzers.DxMessagingConsoleHarvester"/> on the next editor
+        /// tick so the snapshot repopulates without waiting for the user to clear/re-emit warnings
+        /// or to manually invoke <c>Tools/Wallstop Studios/DxMessaging/Rescan Base-Call Warnings</c>. The round-trip
+        /// is intentionally indirect (delayCall > RescanNow) to keep this property setter cheap and
+        /// safe to invoke from any editor context -- including OnValidate, where AssetDatabase may
+        /// be transitional.
+        /// </remarks>
+        public bool BaseCallCheckEnabled
+        {
+            get => _baseCallCheckEnabled;
+            set
+            {
+                bool previous = _baseCallCheckEnabled;
+                _baseCallCheckEnabled = value;
+                if (!previous && value)
+                {
+                    // A master-toggle flip doesn't need a synchronous reflective harvest right now;
+                    // the polled tick (~250ms) will pick up the sentinel cheaply on the editor's
+                    // own update thread, avoiding a heavy reflection sweep on the main thread when
+                    // the user has just clicked a checkbox. Indirected through delayCall so the
+                    // setter is safe to invoke from any editor context (OnValidate, button click,
+                    // etc.) without risking AssetDatabase reentrancy.
+                    EditorApplication.delayCall += DxMessaging
+                        .Editor
+                        .Analyzers
+                        .DxMessagingConsoleHarvester
+                        .RequestRescan;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Opt-in toggle for the legacy console-scrape bridge that augments the IL-reflection
+        /// scanner's snapshot with warnings harvested from <c>UnityEditor.LogEntries</c> and from
+        /// <c>CompilationPipeline.assemblyCompilationFinished</c>.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// Default <c>false</c>. The IL-reflection scanner
+        /// (<see cref="DxMessaging.Editor.Analyzers.BaseCallTypeScanner"/>) is the deterministic,
+        /// always-on primary source -- it walks every loaded <c>MessageAwareComponent</c> subclass
+        /// and inspects each override's IL body for the base-call shape, which is reliable across
+        /// Unity 2021 cache hits, incremental compiles, and arbitrary domain-reload sequences.
+        /// </para>
+        /// <para>
+        /// The legacy bridge predates the IL scanner and was the source of the intermittent
+        /// "missing warnings" bug on Unity 2021. Enable it ONLY if you want the union of both
+        /// data sources -- for example, to surface a regression in the IL byte-walker that is
+        /// already correctly captured by the compile-time analyzer's console output.
+        /// </para>
+        /// <para>
+        /// Toggling this property is observable via a deferred
+        /// <see cref="DxMessaging.Editor.Analyzers.DxMessagingConsoleHarvester.RescanNow"/> so the
+        /// inspector overlay refreshes without waiting for the next compile.
+        /// </para>
+        /// </remarks>
+        public bool UseConsoleBridge
+        {
+            get => _useConsoleBridge;
+            set
+            {
+                if (_useConsoleBridge == value)
+                {
+                    return;
+                }
+                _useConsoleBridge = value;
+                EditorUtility.SetDirty(this);
+                EditorApplication.delayCall += DxMessaging
+                    .Editor
+                    .Analyzers
+                    .DxMessagingConsoleHarvester
+                    .RescanNow;
+            }
+        }
+
+        /// <summary>
+        /// Fully-qualified type names excluded from the base-call check. Editable via the Project Settings UI
+        /// or via the Inspector overlay's "Ignore this type" button.
+        /// </summary>
+        public IReadOnlyList<string> BaseCallIgnoredTypes => _baseCallIgnoredTypes;
+
         /// <summary>
         /// Loads the settings asset if present, otherwise creates it with sensible defaults.
         /// </summary>
@@ -83,6 +181,8 @@ namespace DxMessaging.Editor.Settings
                 settings._diagnosticsTargets = DiagnosticsTarget.Off;
                 settings._messageBufferSize = IMessageBus.DefaultMessageBufferSize;
                 settings._suppressDomainReloadWarning = true;
+                settings._baseCallCheckEnabled = true;
+                settings._baseCallIgnoredTypes = new List<string>();
                 if (!AssetDatabase.IsValidFolder("Assets/Editor"))
                 {
                     AssetDatabase.CreateFolder("Assets", "Editor");
@@ -112,6 +212,95 @@ namespace DxMessaging.Editor.Settings
         {
             return new SerializedObject(GetOrCreateSettings());
         }
+
+        private void OnEnable()
+        {
+            // Defensive: the field can be null if the asset was saved before this field existed.
+            if (_baseCallIgnoredTypes == null)
+            {
+                _baseCallIgnoredTypes = new List<string>();
+            }
+            // Intentionally NOT regenerating the sidecar here. OnEnable fires on every domain reload
+            // and play-mode entry; the sidecar on disk is already consistent with what we'd write
+            // (RegenerateSidecar is idempotent, but ImportAsset still produces churn). Regen runs
+            // only from OnValidate (user-driven edits) and from explicit Add/RemoveIgnoredType calls.
+        }
+
+        private void OnValidate()
+        {
+            if (_baseCallIgnoredTypes == null)
+            {
+                _baseCallIgnoredTypes = new List<string>();
+            }
+            TryRegenerateSidecar();
+        }
+
+        /// <summary>
+        /// Adds <paramref name="fullyQualifiedTypeName"/> to the ignore list, marks the asset
+        /// dirty, saves, and regenerates the sidecar. No-op when the entry is already present.
+        /// </summary>
+        internal void AddIgnoredType(string fullyQualifiedTypeName)
+        {
+            if (string.IsNullOrWhiteSpace(fullyQualifiedTypeName))
+            {
+                return;
+            }
+            if (_baseCallIgnoredTypes == null)
+            {
+                _baseCallIgnoredTypes = new List<string>();
+            }
+            if (
+                _baseCallIgnoredTypes.Any(entry =>
+                    string.Equals(entry, fullyQualifiedTypeName, System.StringComparison.Ordinal)
+                )
+            )
+            {
+                return;
+            }
+            _baseCallIgnoredTypes.Add(fullyQualifiedTypeName);
+            EditorUtility.SetDirty(this);
+            AssetDatabase.SaveAssets();
+            TryRegenerateSidecar();
+        }
+
+        /// <summary>
+        /// Removes <paramref name="fullyQualifiedTypeName"/> from the ignore list, marks the asset
+        /// dirty, saves, and regenerates the sidecar. No-op when the entry is absent.
+        /// </summary>
+        internal void RemoveIgnoredType(string fullyQualifiedTypeName)
+        {
+            if (string.IsNullOrWhiteSpace(fullyQualifiedTypeName))
+            {
+                return;
+            }
+            if (_baseCallIgnoredTypes == null)
+            {
+                return;
+            }
+            int removed = _baseCallIgnoredTypes.RemoveAll(entry =>
+                string.Equals(entry, fullyQualifiedTypeName, System.StringComparison.Ordinal)
+            );
+            if (removed > 0)
+            {
+                EditorUtility.SetDirty(this);
+                AssetDatabase.SaveAssets();
+                TryRegenerateSidecar();
+            }
+        }
+
+        private void TryRegenerateSidecar()
+        {
+            try
+            {
+                DxMessagingBaseCallIgnoreSync.RegenerateSidecar(this);
+            }
+            catch (System.Exception ex)
+            {
+                Debug.LogWarning(
+                    $"[DxMessaging] Failed to regenerate base-call ignore sidecar: {ex.Message}"
+                );
+            }
+        }
     }
 #endif
 }

package/Editor/Settings/DxMessagingSettings.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 477d53eef70c4496b945199c62169dfb
+fileFormatVersion: 2
+guid: 477d53eef70c4496b945199c62169dfb
 timeCreated: 1749668079

package/Editor/Settings/DxMessagingSettingsProvider.cs

@@ -10,7 +10,7 @@ namespace DxMessaging.Editor.Settings
     /// Project Settings provider for DxMessaging configuration.
     /// </summary>
     /// <remarks>
-    /// Exposes toggles for global diagnostics mode and message buffer size under Project Settings → DxMessaging.
+    /// Exposes toggles for global diagnostics mode and message buffer size under Project Settings > Wallstop Studios > DxMessaging.
     /// </remarks>
     public sealed class DxMessagingSettingsProvider : SettingsProvider
     {
@@ -41,53 +41,70 @@ namespace DxMessaging.Editor.Settings
         /// <param name="searchContext">Search text provided by the Project Settings window.</param>
         public override void OnGUI(string searchContext)
         {
-            SerializedProperty targetsProp = _messagingSettings.FindProperty(
-                nameof(DxMessagingSettings._diagnosticsTargets)
-            );
-            DiagnosticsTarget currentTargets = (DiagnosticsTarget)targetsProp.enumValueFlag;
-            DiagnosticsTarget updatedTargets = (DiagnosticsTarget)
-                EditorGUILayout.EnumFlagsField(
+            float previousLabelWidth = EditorGUIUtility.labelWidth;
+            EditorGUIUtility.labelWidth = 240f;
+            try
+            {
+                SerializedProperty targetsProp = _messagingSettings.FindProperty(
+                    nameof(DxMessagingSettings._diagnosticsTargets)
+                );
+                DiagnosticsTarget currentTargets = (DiagnosticsTarget)targetsProp.enumValueFlag;
+                DiagnosticsTarget updatedTargets = (DiagnosticsTarget)
+                    EditorGUILayout.EnumFlagsField(
+                        new GUIContent(
+                            "Diagnostics Targets",
+                            "Select where global diagnostics should be enabled by default. Combine flags for multiple targets."
+                        ),
+                        currentTargets
+                    );
+                if (updatedTargets != currentTargets)
+                {
+                    targetsProp.enumValueFlag = (int)updatedTargets;
+                }
+                EditorGUILayout.PropertyField(
+                    _messagingSettings.FindProperty(nameof(DxMessagingSettings._messageBufferSize)),
                     new GUIContent(
-                        "Diagnostics Targets",
-                        "Select where global diagnostics should be enabled by default. Combine flags for multiple targets."
+                        "Message Buffer Size",
+                        "Number of emissions kept per bus/token when diagnostics mode is active."
+                    )
+                );
+                EditorGUILayout.PropertyField(
+                    _messagingSettings.FindProperty(
+                        nameof(DxMessagingSettings._suppressDomainReloadWarning)
                     ),
-                    currentTargets
+                    new GUIContent(
+                        "Suppress Domain Reload Warning",
+                        "Disable the warning shown when Enter Play Mode Options skips domain reload; DxMessaging still resets its statics."
+                    )
                 );
-            if (updatedTargets != currentTargets)
+
+                _messagingSettings.ApplyModifiedProperties();
+            }
+            finally
             {
-                targetsProp.enumValueFlag = (int)updatedTargets;
+                EditorGUIUtility.labelWidth = previousLabelWidth;
             }
-            EditorGUILayout.PropertyField(
-                _messagingSettings.FindProperty(nameof(DxMessagingSettings._messageBufferSize)),
-                new GUIContent(
-                    "Message Buffer Size",
-                    "Number of emissions kept per bus/token when diagnostics mode is active."
-                )
-            );
-            EditorGUILayout.PropertyField(
-                _messagingSettings.FindProperty(
-                    nameof(DxMessagingSettings._suppressDomainReloadWarning)
-                ),
-                new GUIContent(
-                    "Suppress Domain Reload Warning",
-                    "Disable the warning shown when Enter Play Mode Options skips domain reload; DxMessaging still resets its statics."
-                )
-            );
-
-            _messagingSettings.ApplyModifiedProperties();
         }
 
-        [SettingsProvider]
         /// <summary>
         /// Factory used by Unity to register the DxMessaging project settings page.
         /// </summary>
         /// <returns>Configured settings provider instance.</returns>
+        [SettingsProvider]
         public static SettingsProvider CreateDxMessagingSettingsProvider()
         {
-            DxMessagingSettingsProvider provider = new("Project/DxMessaging")
+            DxMessagingSettingsProvider provider = new("Project/Wallstop Studios/DxMessaging")
             {
                 keywords = new HashSet<string>(
-                    new[] { "DxMessaging", "Diagnostics", "MessageBus", "Targets" }
+                    new[]
+                    {
+                        "DxMessaging",
+                        "Diagnostics",
+                        "MessageBus",
+                        "Targets",
+                        "Wallstop",
+                        "Wallstop Studios",
+                    }
                 ),
             };
 

package/Editor/Settings/DxMessagingSettingsProvider.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: e4353b92a69a4703abc268fb885a1224
+fileFormatVersion: 2
+guid: e4353b92a69a4703abc268fb885a1224
 timeCreated: 1749668115

package/Editor/Settings.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 73f79e95899848a9b4307c19174b4a45
+fileFormatVersion: 2
+guid: 73f79e95899848a9b4307c19174b4a45
 timeCreated: 1749668065