fix: picker names confusion

Author: brunomikoski

CHANGELOG.MD

@@ -3,7 +3,14 @@ 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]
+### 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.
+
+### 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.
 
 ## [2.5.1] - 06/04/2026
 ### Added

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/CollectionItemQuery.cs

@@ -11,10 +11,14 @@ public class CollectionItemQuery<T> where T : ScriptableObject, ISOCItem
     {
         public enum MatchType
         {
+            /// <summary>Target has at least one of the picker items.</summary>
             Any = 0,
+            /// <summary>Target has every one of the picker items.</summary>
             All = 1,
-            SomeNot = 2,
-            None = 3,
+            /// <summary>Target has none of the picker items (all picker items are absent).</summary>
+            NotAny = 2,
+            /// <summary>Target is missing at least one of the picker items (not all are present).</summary>
+            NotAll = 3,
         }
 
         [Serializable]
@@ -63,6 +67,13 @@ public override string ToString()
             return stringBuilder.ToString();
         }
 
+        /// <summary>
+        /// Evaluates every <see cref="QuerySet"/> in the query against <paramref name="targetItems"/>.
+        /// Returns <c>true</c> only if every set passes its <see cref="MatchType"/> check;
+        /// an empty query returns <c>true</c>.
+        /// </summary>
+        /// <param name="targetItems">The items to test against (e.g., the tags on a rigidbody).</param>
+        /// <param name="resultMatchCount">Total number of individual picker items found across all query sets. Informational only; does not affect the return value.</param>
         public bool Matches(IEnumerable<T> targetItems, out int resultMatchCount)
         {
             targetGuids.Clear();
@@ -96,16 +107,16 @@ public bool Matches(IEnumerable<T> targetItems, out int resultMatchCount)
 
                 switch (qs.MatchType)
                 {
-                    case MatchType.SomeNot:
+                    case MatchType.NotAny:
                     {
-                        if (matchCount > 0) 
+                        if (matchCount > 0)
                             return false;
                         break;
                     }
-                    case MatchType.None:
+                    case MatchType.NotAll:
                     {
-                        if (matchCount == pickerCount) 
-                            return false; 
+                        if (matchCount == pickerCount)
+                            return false;
                         break;
                     }
                     case MatchType.Any: