Merge pull request #22170 from jmchilton/fix_paired_unpaired_map_over

More paired_or_unpaired fixes.

Author: mvdbeek

doc/source/dev/collection_semantics.md

@@ -71,6 +71,34 @@ def effective_collection_type(self, subcollection_type):
         if subcollection_type == "single_datasets":
             return self.collection_type
 
+        normalized = _normalize_collection_type(self.collection_type)
+        normalized_sub = _normalize_collection_type(subcollection_type)
+
+        if subcollection_type == "paired_or_unpaired":
+            if self.collection_type.endswith(":paired"):
+                # paired_or_unpaired consumes the :paired suffix
+                return self.collection_type[: -len(":paired")]
+            elif normalized.endswith("list"):
+                # paired_or_unpaired acts like single_datasets for collections
+                # whose innermost type is list (each element wrapped as unpaired)
+                return self.collection_type
+            else:
+                # strip last rank (paired_or_unpaired consumes it)
+                return self.collection_type[: self.collection_type.rfind(":")]
+
+        if normalized_sub.endswith(":paired_or_unpaired"):
+            # Compound :paired_or_unpaired suffix — iterative peel-off matching
+            # TS effectiveMapOver logic. Strip ranks from both sides, then
+            # optionally strip one more if :paired was consumed.
+            current = self.collection_type
+            current_other = subcollection_type
+            while ":" in current_other:
+                current_other = current_other[: current_other.rfind(":")]
+                current = current[: current.rfind(":")]
+            if normalized.endswith(":paired"):
+                current = current[: current.rfind(":")]
+            return current
+
         return self.collection_type[: -(len(subcollection_type) + 1)]
 
     def has_subcollections_of_type(self, other_collection_type) -> bool:
@@ -88,12 +116,23 @@ def has_subcollections_of_type(self, other_collection_type) -> bool:
         other_collection_type = _normalize_collection_type(other_collection_type)
         if collection_type == other_collection_type:
             return False
-        if collection_type.endswith(other_collection_type):
+        if collection_type.endswith(f":{other_collection_type}"):
             return True
         if other_collection_type == "paired_or_unpaired":
             # this can be thought of as a subcollection of anything except a pair
             # since it would match a pair exactly
             return collection_type != "paired"
+        if other_collection_type.endswith(":paired_or_unpaired"):
+            # Compound :paired_or_unpaired suffix — e.g. list:list can map over
+            # list:paired_or_unpaired. Strip the :paired_or_unpaired to get the
+            # required higher ranks, optionally strip :paired from self (since
+            # paired_or_unpaired consumes paired), then check alignment.
+            higher_ranks_required = other_collection_type[: other_collection_type.rfind(":")]
+            if collection_type.endswith(":paired"):
+                higher_ranks = collection_type[: collection_type.rfind(":")]
+            else:
+                higher_ranks = collection_type
+            return higher_ranks.endswith(higher_ranks_required) and higher_ranks != higher_ranks_required
         if other_collection_type == "single_datasets":
             # effectively any collection has unpaired subcollections
             return True