com.wallstop-studios.dxmessaging 3.0.1 → 3.1.0

package/Editor/Settings/DxMessagingBaseCallIgnoreSync.cs

@@ -31,6 +31,39 @@ namespace DxMessaging.Editor.Settings
         private const string FormatComment =
             "# One fully-qualified type name per line. Lines starting with # are comments.";
 
+        /// <summary>
+        /// Test seam controlling WHEN deferred regeneration runs. Production schedules the work on
+        /// the next editor tick via <see cref="EditorApplication.delayCall"/>; tests substitute a
+        /// capturing scheduler so they can assert no synchronous AssetDatabase import happens and
+        /// then drive the deferred work deterministically without touching the filesystem.
+        /// </summary>
+        internal static Action<Action> DeferralScheduler { get; set; } =
+            work => EditorApplication.delayCall += () => work();
+
+        /// <summary>
+        /// Test seam for Unity editor state. Production uses Unity's update/compile flags; tests
+        /// substitute a deterministic busy/idle predicate to prove deferred work requeues.
+        /// </summary>
+        internal static Func<bool> CanMutateAssetDatabase { get; set; } =
+            DxMessaging.Editor.DxMessagingEditorIdle.CanMutateAssetDatabase;
+
+        /// <summary>
+        /// Test seam controlling WHAT regeneration does. Production performs the real
+        /// write + <see cref="AssetDatabase.ImportAsset"/> via <see cref="RegenerateSidecarCore"/>;
+        /// tests substitute a recorder so they can observe whether the apply happens synchronously
+        /// or only after the deferred tick, without writing the on-disk sidecar.
+        /// </summary>
+        internal static Action<DxMessagingSettings> SidecarApplier { get; set; } =
+            RegenerateSidecarCore;
+
+        /// <summary>
+        /// Test seam for the follow-up <c>csc.rsp</c> sync. Production schedules the
+        /// <c>-additionalfile</c> normalization after sidecar regeneration, which covers deferred
+        /// <c>OnValidate</c> writes that finish after <see cref="SetupCscRsp"/>'s startup pass.
+        /// </summary>
+        internal static Action CscRspAdditionalFileSyncScheduler { get; set; } =
+            ScheduleDefaultCscRspAdditionalFileSync;
+
         /// <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
@@ -39,11 +72,15 @@ namespace DxMessaging.Editor.Settings
         /// </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.
+        /// This is the entry point for explicit, user-driven edits (the "Ignore this type" button,
+        /// settings asset Inspector edits) and for EditMode tests: when Unity is idle the regen runs
+        /// synchronously for immediate feedback, and when Unity is mid-compile or mid-asset-import
+        /// it falls back to <see cref="RegenerateSidecarDeferred"/>. It MUST NOT be called from a
+        /// deserialization callback such as <c>ScriptableObject.OnValidate</c> -- those callbacks
+        /// can fire during the domain-load asset-import-worker window where
+        /// <see cref="EditorApplication.isUpdating"/> and <see cref="EditorApplication.isCompiling"/>
+        /// are both <c>false</c>, so this method would import synchronously and crash the editor
+        /// (issue #210). Use <see cref="RegenerateSidecarDeferred"/> from those callbacks instead.
         /// </remarks>
         public static void RegenerateSidecar(DxMessagingSettings settings)
         {
@@ -52,13 +89,97 @@ namespace DxMessaging.Editor.Settings
                 return;
             }
 
-            if (EditorApplication.isUpdating || EditorApplication.isCompiling)
+            if (!CanCurrentlyMutateAssetDatabase())
             {
-                EditorApplication.delayCall += () => RegenerateSidecarCore(settings);
+                RegenerateSidecarDeferred(settings);
                 return;
             }
 
-            RegenerateSidecarCore(settings);
+            ApplySidecarAndScheduleCscRspSync(settings);
+        }
+
+        /// <summary>
+        /// Schedules sidecar regeneration for the next editor tick, NEVER writing or importing
+        /// synchronously. This is the only safe entry point from
+        /// <see cref="ScriptableObject.OnValidate"/> and other asset-deserialization callbacks.
+        /// </summary>
+        /// <param name="settings">The settings asset. May be <c>null</c> -- no-op in that case.</param>
+        /// <remarks>
+        /// A synchronous <see cref="AssetDatabase.ImportAsset"/> issued from within asset
+        /// deserialization re-enters the asset importer and hard-crashes the native editor
+        /// (<c>GuidReservations::Reserve</c> abort, issue #210, observed on Unity 6000.4+). The
+        /// dangerous window includes the domain-load asset-import worker, during which
+        /// <see cref="EditorApplication.isUpdating"/> and <see cref="EditorApplication.isCompiling"/>
+        /// are both <c>false</c> -- so the flag-based guard in <see cref="RegenerateSidecar"/> is
+        /// not sufficient on its own and this method defers unconditionally. The captured
+        /// <paramref name="settings"/> reference is safe to hold: <see cref="EditorApplication.delayCall"/>
+        /// is cleared on domain reload, so the callback never outlives its domain, and the
+        /// lifetime-aware null check covers the asset being destroyed (deleted) within the domain.
+        /// Scheduling here cannot throw, and the deferred regeneration self-guards via
+        /// <see cref="RegenerateSidecarCore"/>'s internal try/catch, so callers such as
+        /// <c>OnValidate</c> need no surrounding exception guard.
+        /// </remarks>
+        internal static void RegenerateSidecarDeferred(DxMessagingSettings settings)
+        {
+            if (settings == null)
+            {
+                return;
+            }
+
+            DxMessaging.Editor.DxMessagingEditorIdle.ScheduleAssetDatabaseMutation(
+                () =>
+                {
+                    if (settings == null)
+                    {
+                        return;
+                    }
+                    ApplySidecarAndScheduleCscRspSync(settings);
+                },
+                DeferralScheduler,
+                CanCurrentlyMutateAssetDatabase
+            );
+        }
+
+        private static bool CanCurrentlyMutateAssetDatabase()
+        {
+            Func<bool> canMutateAssetDatabase =
+                CanMutateAssetDatabase
+                ?? DxMessaging.Editor.DxMessagingEditorIdle.CanMutateAssetDatabase;
+            return canMutateAssetDatabase();
+        }
+
+        private static void ApplySidecarAndScheduleCscRspSync(DxMessagingSettings settings)
+        {
+            try
+            {
+                SidecarApplier(settings);
+            }
+            finally
+            {
+                ScheduleCscRspAdditionalFileSync();
+            }
+        }
+
+        private static void ScheduleCscRspAdditionalFileSync()
+        {
+            try
+            {
+                Action scheduler =
+                    CscRspAdditionalFileSyncScheduler ?? ScheduleDefaultCscRspAdditionalFileSync;
+                scheduler();
+            }
+            catch (Exception ex)
+            {
+                DxMessaging.Editor.DxMessagingEditorLog.LogWarning(
+                    "Failed to schedule csc.rsp base-call ignore additionalfile sync.",
+                    ex
+                );
+            }
+        }
+
+        private static void ScheduleDefaultCscRspAdditionalFileSync()
+        {
+            DxMessaging.Editor.SetupCscRsp.ScheduleAdditionalFileForIgnoreListSync();
         }
 
         private static void RegenerateSidecarCore(DxMessagingSettings settings)
@@ -88,8 +209,9 @@ namespace DxMessaging.Editor.Settings
             }
             catch (Exception ex)
             {
-                Debug.LogWarning(
-                    $"[DxMessaging] Failed to write base-call ignore sidecar at '{SidecarAssetPath}': {ex.Message}"
+                DxMessaging.Editor.DxMessagingEditorLog.LogWarning(
+                    $"Failed to write base-call ignore sidecar at '{SidecarAssetPath}'.",
+                    ex
                 );
             }
         }
@@ -126,8 +248,9 @@ namespace DxMessaging.Editor.Settings
             }
             catch (Exception ex)
             {
-                Debug.LogWarning(
-                    $"[DxMessaging] Failed to read base-call ignore sidecar at '{SidecarAssetPath}': {ex.Message}"
+                DxMessaging.Editor.DxMessagingEditorLog.LogWarning(
+                    $"Failed to read base-call ignore sidecar at '{SidecarAssetPath}'.",
+                    ex
                 );
                 return Array.Empty<string>();
             }

package/Editor/Settings/DxMessagingSettings.cs

@@ -25,7 +25,7 @@ namespace DxMessaging.Editor.Settings
         [SerializeField]
         [HideInInspector]
         [FormerlySerializedAs("_enableDiagnosticsInEditor")]
-        private bool _legacyEnableDiagnosticsInEditor;
+        internal bool _legacyEnableDiagnosticsInEditor;
 
         [SerializeField]
         internal int _messageBufferSize = IMessageBus.DefaultMessageBufferSize;
@@ -47,8 +47,12 @@ namespace DxMessaging.Editor.Settings
         /// </summary>
         public DiagnosticsTarget DiagnosticsTargets
         {
-            get => _diagnosticsTargets;
-            set => _diagnosticsTargets = value;
+            get => EffectiveDiagnosticsTargets;
+            set
+            {
+                _diagnosticsTargets = value;
+                _legacyEnableDiagnosticsInEditor = false;
+            }
         }
 
         /// <summary>
@@ -128,8 +132,8 @@ namespace DxMessaging.Editor.Settings
         /// </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.
+        /// <see cref="DxMessaging.Editor.Analyzers.DxMessagingConsoleHarvester.ScheduleRescanWhenIdle"/>
+        /// so the inspector overlay refreshes without waiting for the next compile.
         /// </para>
         /// </remarks>
         public bool UseConsoleBridge
@@ -143,24 +147,51 @@ namespace DxMessaging.Editor.Settings
                 }
                 _useConsoleBridge = value;
                 EditorUtility.SetDirty(this);
-                EditorApplication.delayCall += DxMessaging
-                    .Editor
-                    .Analyzers
-                    .DxMessagingConsoleHarvester
-                    .RescanNow;
+                DxMessaging.Editor.Analyzers.DxMessagingConsoleHarvester.ScheduleRescanWhenIdle();
             }
         }
 
         /// <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.
+        /// Fully-qualified type names excluded from the base-call check. Editable on the settings
+        /// asset Inspector 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.
+        /// Diagnostics target value after applying legacy serialized fields in memory. This does
+        /// not mark the settings asset dirty or persist the migration.
         /// </summary>
-        internal static DxMessagingSettings GetOrCreateSettings()
+        internal DiagnosticsTarget EffectiveDiagnosticsTargets
+        {
+            get
+            {
+                if (
+                    _diagnosticsTargets == DiagnosticsTarget.Off
+                    && _legacyEnableDiagnosticsInEditor
+                )
+                {
+                    return DiagnosticsTarget.Editor;
+                }
+                return _diagnosticsTargets;
+            }
+        }
+
+        /// <summary>
+        /// Loads the settings asset without creating, saving, or migrating it. Returns
+        /// <c>null</c> when no asset exists.
+        /// </summary>
+        /// <remarks>
+        /// Unlike <see cref="GetOrCreateSettings"/>, this performs NO <c>AssetDatabase</c> mutation
+        /// (<c>CreateAsset</c>/<c>SaveAssets</c>/durable legacy migration), so it is safe to call
+        /// during the domain-load asset-import window -- e.g. from an <c>[InitializeOnLoad]</c>
+        /// static constructor -- where a synchronous mutation re-enters the importer and crashes
+        /// the native editor (issue #210). Legacy serialized fields are still reflected through
+        /// effective property getters so passive callers see the intended value while the durable
+        /// migration waits for a safe editor-idle tick. Callers that need the asset
+        /// created/migrated must schedule <see cref="GetOrCreateSettings"/> off that window (e.g.
+        /// via <see cref="DxMessaging.Editor.DxMessagingEditorIdle.ScheduleAssetDatabaseMutation"/>).
+        /// </remarks>
+        internal static DxMessagingSettings LoadSettingsPassive()
         {
             DxMessagingSettings settings = AssetDatabase.LoadAssetAtPath<DxMessagingSettings>(
                 SettingsPath
@@ -175,6 +206,21 @@ namespace DxMessaging.Editor.Settings
                     .FirstOrDefault(asset => asset != null);
             }
 
+            return settings;
+        }
+
+        /// <summary>
+        /// Loads the settings asset if present, otherwise creates it with sensible defaults.
+        /// </summary>
+        /// <remarks>
+        /// Performs <c>AssetDatabase</c> mutations (create on first run, legacy-field migration), so
+        /// it MUST NOT be called synchronously during the domain-load asset-import window (issue
+        /// #210). Use <see cref="LoadSettingsPassive"/> for mutation-free reads in that context.
+        /// </remarks>
+        internal static DxMessagingSettings GetOrCreateSettings()
+        {
+            DxMessagingSettings settings = LoadSettingsPassive();
+
             if (settings == null)
             {
                 settings = CreateInstance<DxMessagingSettings>();
@@ -191,13 +237,8 @@ namespace DxMessaging.Editor.Settings
                 AssetDatabase.SaveAssets();
             }
 
-            if (
-                settings._diagnosticsTargets == DiagnosticsTarget.Off
-                && settings._legacyEnableDiagnosticsInEditor
-            )
+            if (settings.ApplyLegacyDiagnosticsMigration())
             {
-                settings._diagnosticsTargets = DiagnosticsTarget.Editor;
-                settings._legacyEnableDiagnosticsInEditor = false;
                 EditorUtility.SetDirty(settings);
                 AssetDatabase.SaveAssets();
             }
@@ -205,6 +246,21 @@ namespace DxMessaging.Editor.Settings
             return settings;
         }
 
+        internal bool ApplyLegacyDiagnosticsMigration()
+        {
+            if (!_legacyEnableDiagnosticsInEditor)
+            {
+                return false;
+            }
+
+            if (_diagnosticsTargets == DiagnosticsTarget.Off)
+            {
+                _diagnosticsTargets = DiagnosticsTarget.Editor;
+            }
+            _legacyEnableDiagnosticsInEditor = false;
+            return true;
+        }
+
         /// <summary>
         /// Returns a serialized wrapper for use in SettingsProvider inspectors.
         /// </summary>
@@ -216,10 +272,7 @@ namespace DxMessaging.Editor.Settings
         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>();
-            }
+            EnsureIgnoreListInitialized();
             // 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
@@ -227,12 +280,22 @@ namespace DxMessaging.Editor.Settings
         }
 
         private void OnValidate()
+        {
+            EnsureIgnoreListInitialized();
+            // Issue #210: OnValidate fires during asset deserialization, including the domain-load
+            // asset-import-worker window where EditorApplication.isUpdating/isCompiling are both
+            // false. Writing + importing the sidecar synchronously there re-enters the asset
+            // importer and hard-crashes the native editor (GuidReservations::Reserve abort on Unity
+            // 6000.4+). Always defer to the next editor tick; never import synchronously from here.
+            DxMessagingBaseCallIgnoreSync.RegenerateSidecarDeferred(this);
+        }
+
+        private void EnsureIgnoreListInitialized()
         {
             if (_baseCallIgnoredTypes == null)
             {
                 _baseCallIgnoredTypes = new List<string>();
             }
-            TryRegenerateSidecar();
         }
 
         /// <summary>
@@ -245,10 +308,7 @@ namespace DxMessaging.Editor.Settings
             {
                 return;
             }
-            if (_baseCallIgnoredTypes == null)
-            {
-                _baseCallIgnoredTypes = new List<string>();
-            }
+            EnsureIgnoreListInitialized();
             if (
                 _baseCallIgnoredTypes.Any(entry =>
                     string.Equals(entry, fullyQualifiedTypeName, System.StringComparison.Ordinal)
@@ -296,8 +356,9 @@ namespace DxMessaging.Editor.Settings
             }
             catch (System.Exception ex)
             {
-                Debug.LogWarning(
-                    $"[DxMessaging] Failed to regenerate base-call ignore sidecar: {ex.Message}"
+                DxMessaging.Editor.DxMessagingEditorLog.LogWarning(
+                    "Failed to regenerate base-call ignore sidecar.",
+                    ex
                 );
             }
         }

package/Editor/Settings/DxMessagingSettings.cs.meta

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

package/Editor/Settings/DxMessagingSettingsProvider.cs.meta

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