Refactor multiple function objects into a single one in InputActionReference.cs

Author: jfreire-unity

Packages/com.unity.inputsystem/InputSystem/Editor/InputSystemEditorInitializer.cs

@@ -276,9 +276,33 @@ private static void RegisterAssetDatabaseHooks()
             InputActionAsset.s_OnMarkAsDirty = DirtyAssetTracker.TrackDirtyInputActionAsset;
             InputManager.s_GetProjectWideActions = () => ProjectWideActionsBuildProvider.actionsToIncludeInPlayerBuild;
 
-            InputActionReference.s_IsSubAsset = AssetDatabase.IsSubAsset;
-            InputActionReference.s_GetAssetPath = AssetDatabase.GetAssetPath;
-            InputActionReference.s_LoadMainAssetAtPath = AssetDatabase.LoadMainAssetAtPath;
+            InputActionReference.s_CheckImmutableReference = CheckImmutableInputActionReference;
+        }
+
+        /// <summary>
+        /// Prevents accidental mutation of the source asset if this <see cref="InputActionReference"/> is a
+        /// persisted sub-asset within a .inputactions <see cref="InputActionAsset"/>.
+        /// </summary>
+        private static void CheckImmutableInputActionReference(InputActionReference reference)
+        {
+            if (!AssetDatabase.IsSubAsset(reference))
+                return;
+
+            var path = AssetDatabase.GetAssetPath(reference);
+            if (path == null)
+                return;
+
+            var mainAsset = AssetDatabase.LoadMainAssetAtPath(path);
+            if (!mainAsset || mainAsset is not InputActionAsset)
+                return;
+
+            throw new InvalidOperationException(
+                "Attempting to modify an immutable InputActionReference instance " +
+                "that is part of an .inputactions asset. This is not allowed since it would modify the source " +
+                "asset in which the reference is serialized and potentially corrupt it. " +
+                "Instead use InputActionReference.Create(action) to create a new mutable " +
+                "in-memory instance or serialize it as a separate asset if the intent is for changes to " +
+                "survive domain reloads.");
         }
 
 #if UNITY_INPUT_SYSTEM_ENABLE_UI || PACKAGE_DOCS_GENERATION

Packages/com.unity.inputsystem/InputSystem/Runtime/Actions/InputActionReference.cs

@@ -137,7 +137,9 @@ public void Set(InputActionAsset asset, string mapName, string actionName)
 
         private void SetInternal(InputActionAsset assetArg, InputAction actionArg)
         {
-            CheckImmutableReference();
+#if UNITY_EDITOR
+            s_CheckImmutableReference?.Invoke(this);
+#endif
 
             // If we are setting the reference in edit-mode, we want the state to be reflected in the serialized
             // object and hence assign serialized fields. This is a destructive operation.
@@ -207,13 +209,6 @@ public static InputActionReference Create(InputAction action)
         /// This method is used to clear the Action references when exiting PlayMode since those objects are no
         /// longer valid.
         /// </remarks>
-        #if UNITY_EDITOR
-        // Callbacks set by Editor to check asset status without direct UnityEditor dependency
-        internal static Func<Object, bool> s_IsSubAsset;
-        internal static Func<Object, string> s_GetAssetPath;
-        internal static Func<string, Object> s_LoadMainAssetAtPath;
-        #endif
-
         internal static void InvalidateAll()
         {
             // It might be possible that Object.FindObjectOfTypeAll(true) would be sufficient here since we only
@@ -224,6 +219,14 @@ internal static void InvalidateAll()
                 ((InputActionReference)obj).Invalidate();
         }
 
+#if UNITY_EDITOR
+        /// <summary>
+        /// Set by the editor to prevent mutating <see cref="InputActionReference"/> sub-assets inside
+        /// <see cref="InputActionAsset"/> files. Not used in player builds.
+        /// </summary>
+        internal static Action<InputActionReference> s_CheckImmutableReference;
+#endif
+
         /// <summary>
         /// Clears the cached <see cref="m_Action"/> field for this <see cref="InputActionReference"/> instance.
         /// </summary>
@@ -256,65 +259,5 @@ public InputAction ToInputAction()
         {
             return action;
         }
-
-        /// <summary>
-        /// Checks if this input action reference instance can be safely mutated without side effects.
-        /// </summary>
-        /// <remarks>
-        /// This check isn't needed in player builds since ScriptableObject would never be persisted if mutated
-        /// in a player.
-        /// </remarks>
-        /// <exception cref="InvalidOperationException">Thrown if this input action reference is part of an
-        /// input actions asset and mutating it would have side-effects on the projects assets.</exception>
-        private void CheckImmutableReference()
-        {
-            #if UNITY_EDITOR
-            // Prevent accidental mutation of the source asset if this InputActionReference is a persisted object
-            // residing as a sub-asset within a .inputactions asset.
-            // This is not needed for players since scriptable objects aren't serialized back from within a player.
-            if (!CanSetReference())
-            {
-                throw new InvalidOperationException("Attempting to modify an immutable InputActionReference instance " +
-                    "that is part of an .inputactions asset. This is not allowed since it would modify the source " +
-                    "asset in which the reference is serialized and potentially corrupt it. " +
-                    "Instead use InputActionReference.Create(action) to create a new mutable " +
-                    "in-memory instance or serialize it as a separate asset if the intent is for changes to " +
-                    "survive domain reloads.");
-            }
-            #endif // UNITY_EDITOR
-        }
-
-        #if UNITY_EDITOR
-        // Note that we do a lot of checking here, but it is only for a rather slim (unintended) use case in
-        // editor and not in final builds. The alternative would be to set a non-serialized field on the reference
-        // when importing assets which would simplify this class, but it adds complexity to import stage and
-        // is more difficult to assess from a asset version portability perspective.
-        private bool CanSetReference()
-        {
-            // If callbacks aren't set, allow the operation
-            if (s_IsSubAsset == null || s_GetAssetPath == null || s_LoadMainAssetAtPath == null)
-                return true;
-
-            // "Immutable" input action references are always sub-assets of InputActionAsset.
-            var isSubAsset = s_IsSubAsset(this);
-            if (!isSubAsset)
-                return true;
-
-            // If we cannot get the path of our reference, we cannot be a persisted asset within an InputActionAsset.
-            var path = s_GetAssetPath(this);
-            if (path == null)
-                return true;
-
-            // If we cannot get the main asset we cannot be a persisted asset within an InputActionAsset.
-            // Also we check that it is the expected type.
-            var mainAsset = s_LoadMainAssetAtPath(path);
-            if (!mainAsset)
-                return true;
-
-            // We can only allow setting the reference if it is not part of an persisted InputActionAsset.
-            return (mainAsset is not InputActionAsset);
-        }
-
-        #endif // UNITY_EDITOR
     }
 }