Merge pull request #192 from brunomikoski/feature/fix-missing-last-known-name

Feature/fix missing last known name

Author: brunomikoski

CHANGELOG.MD

@@ -3,7 +3,27 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-[Unreleased]
+
+## [Unreleased]
+### Added
+- `CollectionItemPicker<T>.ToString()` override returning `[item1, item2, ...]` (empty collection renders as `[]`; null entries render as `<null>`). Uses `StringBuilder` to avoid per-call allocations on long pickers.
+- `CollectionItemQuery<T>.IsEmpty()` returns `true` when every `QuerySet`'s picker contains zero items — useful for skipping the `Matches` evaluation on default-constructed queries.
+- `CollectionItemPickerPropertyDrawer` now writes `itemLastKnownName` and `collectionLastKnownName` when an entry is added to a picker, so newly added items have populated cache names immediately instead of empty strings.
+
+### Changed
+- Reverted `CollectionItemQuery.MatchType` enum values: `SomeNot` → `NotAny`, `None` → `NotAll`. The new names mirror `Any`/`All` and describe the actual semantics (target has *none* of the picker items / target is missing *at least one* of them). Integer values are preserved (2 and 3), so existing serialized `QuerySet` data deserializes unchanged.
+- Added XML documentation on `MatchType` values and the `Matches` method to surface the semantics in IntelliSense.
+- `CollectionItemPicker<T>` events renamed: `OnItemTypeAddedEvent` → `OnItemAddedEvent`, `OnItemTypeRemovedEvent` → `OnItemRemovedEvent`. **Breaking** for external subscribers — `+=`/`-=` call sites must be updated. `OnChangedEvent` is unchanged.
+- `CollectionItemIndirectReference.itemLastKnownName` and `collectionLastKnownName` are now wrapped in `#if UNITY_EDITOR` and no longer compiled into player builds. Runtime resolution relies exclusively on GUIDs.
+- `CollectionItemQuery<T>.Matches(IEnumerable<T> targetItems, out int)` now tolerates a `null` `targetItems` — treated as empty, so `Any`/`All` sets fail and `NotAny`/`NotAll` sets pass.
+
+### Fixed
+- `CollectionItemQueryPropertyDrawer.IsCombinationImpossible` no longer reports false positives for `Any` + `NotAny` and `All` + `NotAll` rule pairs. Impossibility for these now requires the stricter *subset* relationship between pickers (not just any intersection), matching the real-world satisfiability. `All` + `NotAny` continues to be flagged on any intersection, which is correct.
+- `CollectionItemPicker` and `CollectionItemIndirectReference<T>` now implement `ISerializationCallbackReceiver` to invalidate their runtime caches on deserialization, so inspector edits to a picker during Play Mode take effect immediately instead of returning the stale cached `Items`/`Ref`.
+- `CollectionItemIndirectReferencePropertyDrawer` now re-syncs stale `itemLastKnownName`/`collectionLastKnownName` from the live asset and collection names on every draw (via `ApplyModifiedPropertiesWithoutUndo`), preventing the cached names from drifting when an asset is renamed outside the inspector.
+
+### Removed
+- Removed the runtime fallback in `CollectionItemIndirectReference.TryGetCollectionItem` that, when the stored GUIDs failed to resolve, attempted to look the collection and item back up by `collectionLastKnownName`/`itemLastKnownName`. With the names now editor-only, GUID is the single runtime lookup path; rename recovery is handled at edit time by the drawer instead.
 
 ## [2.5.1] - 06/04/2026
 ### Added

Scripts/Editor/PropertyDrawers/CollectionItemIndirectReferencePropertyDrawer.cs

@@ -50,7 +50,8 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             collectionLastKnownNameSerializedProperty = property.FindPropertyRelative(COLLECTION_LAST_KNOW_NAME_PROPERTY_PATH);
 
             TryGetCollectionItem(out ScriptableObject collectionItem);
-            
+            ValidateLastKnownNames(collectionItem);
+
             int indexOfArrayPart = property.propertyPath.IndexOf('[');
             if (indexOfArrayPart > -1)
             {
@@ -132,6 +133,31 @@ private bool TryGetCollectionItem(out ScriptableObject item)
             return true;
         }
 
+        private void ValidateLastKnownNames(ScriptableObject collectionItem)
+        {
+            if (collectionItem == null || collectionItem is not ISOCItem socItem)
+                return;
+
+            bool changed = false;
+
+            if (!string.Equals(itemLastKnowNameSerializedProperty.stringValue, socItem.name, StringComparison.Ordinal))
+            {
+                itemLastKnowNameSerializedProperty.stringValue = socItem.name;
+                changed = true;
+            }
+
+            if (!string.Equals(collectionLastKnownNameSerializedProperty.stringValue, socItem.Collection.name, StringComparison.Ordinal))
+            {
+                collectionLastKnownNameSerializedProperty.stringValue = socItem.Collection.name;
+                changed = true;
+            }
+
+            if (changed)
+            {
+                itemLastKnowNameSerializedProperty.serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            }
+        }
+
         private void CreateCollectionItemPropertyDrawer(SerializedProperty serializedProperty)
         {
             collectionItemPropertyDrawer = new CollectionItemPropertyDrawer();

Scripts/Editor/PropertyDrawers/CollectionItemPickerPropertyDrawer.cs

@@ -204,6 +204,9 @@ private void AssignItemGUIDToProperty(ScriptableObject scriptableObject, Seriali
 
             newProperty.FindPropertyRelative(COLLECTION_GUID_VALUE_A).longValue = collectionValues.Item1;
             newProperty.FindPropertyRelative(COLLECTION_GUID_VALUE_B).longValue = collectionValues.Item2;
+
+            newProperty.FindPropertyRelative("itemLastKnownName").stringValue = item.name;
+            newProperty.FindPropertyRelative("collectionLastKnownName").stringValue = item.Collection.name;
         }
 
         private void SetSelectedValuesOnPopup(PopupList<PopupItem> popupList, SerializedProperty property)

Scripts/Editor/PropertyDrawers/CollectionItemQueryPropertyDrawer.cs

@@ -257,7 +257,7 @@ private bool IsMatchTypeValid(SerializedProperty queryProp, int elementIndex, in
 
                 int otherEnumIndex = otherMatchTypeProp.enumValueIndex;
 
-                if (IsCombinationImpossible(candidateEnumIndex, otherEnumIndex))
+                if (IsCombinationImpossible(candidateEnumIndex, candidateItems, otherEnumIndex, otherItems))
                     return false;
             }
 
@@ -292,7 +292,7 @@ private bool HasImpossibleRules(SerializedProperty queryProp)
                         continue;
                     int matchB = matchTypeBProp.enumValueIndex;
 
-                    if (IsCombinationImpossible(matchA, matchB))
+                    if (IsCombinationImpossible(matchA, itemsA, matchB, itemsB))
                         return true;
                 }
             }
@@ -451,31 +451,43 @@ private static bool HasItemIntersection(HashSet<(long, long)> a, HashSet<(long,
             return false;
         }
 
-        private static bool IsCombinationImpossible(int matchA, int matchB)
+        private static bool IsCombinationImpossible(
+            int matchA, HashSet<(long, long)> itemsA,
+            int matchB, HashSet<(long, long)> itemsB)
         {
-            // 0 = Any, 1 = All, 2 = SomeNot (forbids any), 3 = None (forbids all)
-            // Only truly impossible when overlapping items can never satisfy both rules:
-            // - All + SomeNot: must have all AND must have none → impossible
-            // - Any + SomeNot: must have at least one AND must have none → impossible
-            // - All + None: must have all AND must not have all → impossible
-            // - Any + None: must have at least one AND must not have all → satisfiable (partial overlap ok)
-            int lo = Mathf.Min(matchA, matchB);
-            int hi = Mathf.Max(matchA, matchB);
-
-            // All(1) + SomeNot(2)
-            if (lo == 1 && hi == 2)
+            // Caller guarantees itemsA ∩ itemsB is non-empty.
+            // 0 = Any, 1 = All, 2 = NotAny, 3 = NotAll.
+            //
+            // All + NotAny: the overlap is forced-in by All and forced-out by NotAny → always impossible.
+            // Any(X) + NotAny(Y): impossible iff every X item is also forbidden by Y (X ⊆ Y); otherwise an X-only item satisfies both.
+            // All(X) + NotAll(Y): impossible iff every Y item is already required by X (Y ⊆ X); otherwise target = X misses a Y-only item.
+            // Any + NotAll and all other pairings remain satisfiable in the general (non-degenerate-picker) case.
+
+            if ((matchA == 1 && matchB == 2) || (matchA == 2 && matchB == 1))
                 return true;
 
-            // Any(0) + SomeNot(2)
-            if (lo == 0 && hi == 2)
-                return true;
+            if (matchA == 0 && matchB == 2) return IsSubsetOf(itemsA, itemsB);
+            if (matchA == 2 && matchB == 0) return IsSubsetOf(itemsB, itemsA);
 
-            // All(1) + None(3)
-            if (lo == 1 && hi == 3)
-                return true;
+            if (matchA == 1 && matchB == 3) return IsSubsetOf(itemsB, itemsA);
+            if (matchA == 3 && matchB == 1) return IsSubsetOf(itemsA, itemsB);
 
             return false;
         }
+
+        private static bool IsSubsetOf(HashSet<(long, long)> candidate, HashSet<(long, long)> container)
+        {
+            if (candidate == null || container == null || candidate.Count == 0)
+                return false;
+
+            foreach ((long, long) item in candidate)
+            {
+                if (!container.Contains(item))
+                    return false;
+            }
+
+            return true;
+        }
     }
 }
 

Scripts/Runtime/Core/CollectionItemIndirectReference.cs

@@ -20,10 +20,12 @@ public abstract class CollectionItemIndirectReference: IEquatable<CollectionItem
         protected long collectionGUIDValueB;
         protected LongGuid CollectionGUID => new LongGuid(collectionGUIDValueA, collectionGUIDValueB);
 
+#if UNITY_EDITOR
         [SerializeField]
         protected string itemLastKnownName;
         [SerializeField, FormerlySerializedAs("collectionLastKnowName")]
         protected string collectionLastKnownName;
+#endif
 
         public bool Equals(CollectionItemIndirectReference other)
         {
@@ -65,7 +67,7 @@ public bool IsValid()
     }
 
     [Serializable]
-    public class CollectionItemIndirectReference<TObject> : CollectionItemIndirectReference
+    public class CollectionItemIndirectReference<TObject> : CollectionItemIndirectReference, ISerializationCallbackReceiver
         where TObject : ScriptableObject, ISOCItem
     {
         [NonSerialized]
@@ -111,30 +113,6 @@ private bool TryResolveReference(out TObject result)
                     return true;
                 }
             }
-            else
-            {
-                if (!string.IsNullOrEmpty(collectionLastKnownName))
-                {
-                    if (CollectionsRegistry.Instance.TryGetCollectionByName(collectionLastKnownName, out collection))
-                    {
-                        SetCollection(collection);
-
-                        if (!string.IsNullOrEmpty(itemLastKnownName))
-                        {
-                            if(collection.TryGetItemByName(itemLastKnownName, out ScriptableObject possibleResult))
-                            {
-                                result = possibleResult as TObject;
-                                if (result == null)
-                                {
-                                    return false;
-                                }
-                                SetCollectionItem(result);
-                                return true;
-                            }
-                        }
-                    }
-                }
-            }
 
             result = null;
             return false;
@@ -160,15 +138,29 @@ private void SetCollectionItem(ISOCItem item)
             (long, long) collectionItemValues = item.GUID.GetRawValues();
             collectionItemGUIDValueA = collectionItemValues.Item1;
             collectionItemGUIDValueB = collectionItemValues.Item2;
+#if UNITY_EDITOR
             itemLastKnownName = item.name;
+#endif
         }
 
         public void SetCollection(ScriptableObjectCollection targetCollection)
         {
             (long,long) collectionGUIDValues = targetCollection.GUID.GetRawValues();
             collectionGUIDValueA = collectionGUIDValues.Item1;
             collectionGUIDValueB = collectionGUIDValues.Item2;
+#if UNITY_EDITOR
             collectionLastKnownName = targetCollection.name;
+#endif
+        }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        public void OnAfterDeserialize()
+        {
+            hasCachedRef = false;
+            cachedRef = null;
         }
     }
 }

Scripts/Runtime/Core/CollectionItemPicker.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Text;
 using UnityEngine;
 using UnityEngine.Serialization;
 
@@ -11,14 +12,14 @@ namespace BrunoMikoski.ScriptableObjectCollections.Picker
     /// work if the enum had the [Flags] attribute applied to it.
     /// </summary>
     [Serializable]
-    public class CollectionItemPicker<TItemType> : IList<TItemType>, IEquatable<IList<TItemType>>, IEquatable<CollectionItemPicker<TItemType>>
+    public class CollectionItemPicker<TItemType> : IList<TItemType>, IEquatable<IList<TItemType>>, IEquatable<CollectionItemPicker<TItemType>>, ISerializationCallbackReceiver
         where TItemType : ScriptableObject, ISOCItem
     {
         [SerializeField, FormerlySerializedAs("cachedIndirectReferences")]
         private List<CollectionItemIndirectReference<TItemType>> indirectReferences = new();
 
-        public event Action<TItemType> OnItemTypeAddedEvent;
-        public event Action<TItemType> OnItemTypeRemovedEvent;
+        public event Action<TItemType> OnItemAddedEvent;
+        public event Action<TItemType> OnItemRemovedEvent;
         public event Action OnChangedEvent;
 
         private bool isDirty = true;
@@ -201,7 +202,7 @@ public void Add(TItemType item)
 
             indirectReferences.Add(new CollectionItemIndirectReference<TItemType>(item));
             isDirty = true;
-            OnItemTypeAddedEvent?.Invoke(item);
+            OnItemAddedEvent?.Invoke(item);
             OnChangedEvent?.Invoke();
         }
 
@@ -262,7 +263,7 @@ public bool Remove(TItemType item)
             {
                 isDirty = true;
                 OnChangedEvent?.Invoke();
-                OnItemTypeRemovedEvent?.Invoke(removedItem.Ref);
+                OnItemRemovedEvent?.Invoke(removedItem.Ref);
             }
 
             return removed;
@@ -295,7 +296,7 @@ public void RemoveAt(int index)
             indirectReferences.RemoveAt(index);
             isDirty = true;
             OnChangedEvent?.Invoke();
-            OnItemTypeRemovedEvent?.Invoke(removedItem.Ref);
+            OnItemRemovedEvent?.Invoke(removedItem.Ref);
         }
 
         public TItemType this[int index]
@@ -343,5 +344,33 @@ public bool Equals(CollectionItemPicker<TItemType> other)
 
             return true;
         }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        public void OnAfterDeserialize()
+        {
+            isDirty = true;
+        }
+
+        public override string ToString()
+        {
+            if (Items.Count == 0)
+                return "[]";
+
+            StringBuilder builder = new StringBuilder();
+            builder.Append('[');
+            for (int i = 0; i < Items.Count; i++)
+            {
+                if (i > 0)
+                    builder.Append(", ");
+
+                TItemType item = Items[i];
+                builder.Append(item != null ? item.name : "<null>");
+            }
+            builder.Append(']');
+            return builder.ToString();
+        }
     }
-}
+}