Squashed commit of the following:

commit 02327a9
Author: Philip Mueller <philip.mueller@cscs.ch>
Date:   Thu Jul 3 09:46:03 2025 +0200

    Optimized `gpu_map_has_explicit_threadblocks()` the function will only once fully scann the tree.

commit 6d13e68
Author: Philip Mueller <philip.mueller@cscs.ch>
Date:   Thu Jul 3 09:36:16 2025 +0200

    Small modification that will improve debug experience.

commit 8f4cbc5
Author: Philip Mueller <philip.mueller@cscs.ch>
Date:   Thu Jul 3 08:51:57 2025 +0200

    Added a documentation.

commit edeca0e
Author: Philip Mueller <philip.mueller@cscs.ch>
Date:   Thu Jul 3 08:17:48 2025 +0200

    This kind of works.

commit a621c44
Author: Philip Mueller <philip.mueller@cscs.ch>
Date:   Wed Jul 2 12:53:15 2025 +0200

    This shjould Fix Edoardo's case, but a test is missing.

Author: philip-paul-mueller

dace/transformation/helpers.py

@@ -1375,40 +1375,62 @@ def scope_tree_recursive(state: SDFGState, entry: Optional[nodes.EntryNode] = No
     :param state: The state that contains the root of the scope tree.
     :param entry: A scope entry node to set as root, otherwise the state is
                   the root if None is given.
+
+    :note: This function adds a `state` attribute to the `ScopeTree` objects, it refers to
+        the state to which the scope was found.
     """
+    # The first clear is to make sure that the data structure we get is not referred to by any
+    #  other reference. The second clear is needed to ensure that nobody gets the object we
+    #  operate on. This is because we actually modifying them and they are cached by the state.
+    #  The real error happens if this function is called multiple times, without a refresh.
+    # NOTE: `scope_tree()` only performs a shallow copy, but only of the `dict` that we do not use.
+    state._clear_scopedict_cache()
     stree = state.scope_tree()[entry]
+    state._clear_scopedict_cache()
+
     stree.state = state  # Annotate state in tree
 
     # Add nested SDFGs as children
     def traverse(state: SDFGState, treenode: ScopeTree):
+        # See above why.
+        state._clear_scopedict_cache()
         snodes = state.scope_children()[treenode.entry]
+        state._clear_scopedict_cache()
+
         for node in snodes:
             if isinstance(node, nodes.NestedSDFG):
                 for nstate in node.sdfg.states():
                     ntree = nstate.scope_tree()[None]
+                    assert ntree not in treenode.children
+                    assert not hasattr(ntree, "state")  # Non standard field.
                     ntree.state = nstate
                     treenode.children.append(ntree)
+
         for child in treenode.children:
             if hasattr(child, 'state') and child.state != state:
-                traverse(getattr(child, 'state', state), child)
+                traverse(child.state, child)
 
     traverse(state, stree)
     return stree
 
 
 def get_internal_scopes(state: SDFGState,
                         entry: nodes.EntryNode,
-                        immediate: bool = False) -> List[Tuple[SDFGState, nodes.EntryNode]]:
+                        immediate: bool = False,
+                        recursive_scope_tree: Optional[ScopeTree] = None) -> List[Tuple[SDFGState, nodes.EntryNode]]:
     """
     Returns all internal scopes within a given scope, including if they
     reside in nested SDFGs.
 
     :param state: State in which entry node resides.
     :param entry: The entry node to start from.
-    :param immediate: If True, only returns the scopes that are immediately
-                      nested in the map.
+    :param immediate: If True, only returns the scopes that are immediately nested in the map.
+    :param recursive_scope_tree: The recursive scope tree, see `scope_tree_recursive()` for more.
     """
-    stree = scope_tree_recursive(state, entry)
+
+    if recursive_scope_tree is None:
+        recursive_scope_tree = scope_tree_recursive(state, entry)
+
     result = []
 
     def traverse(state: SDFGState, treenode: ScopeTree):
@@ -1420,19 +1442,21 @@ def traverse(state: SDFGState, treenode: ScopeTree):
             else:  # Nested SDFG
                 traverse(child.state, child)
 
-    traverse(state, stree)
+    traverse(state, recursive_scope_tree)
     return result
 
 
 def gpu_map_has_explicit_threadblocks(state: SDFGState, entry: nodes.EntryNode) -> bool:
     """
     Returns True if GPU_Device map has explicit thread-block maps nested within.
     """
-    internal_maps = get_internal_scopes(state, entry)
+    rstree = scope_tree_recursive(state, entry)
+    internal_maps = get_internal_scopes(state, entry, recursive_scope_tree=rstree)
     if any(m.schedule in (dtypes.ScheduleType.GPU_ThreadBlock, dtypes.ScheduleType.GPU_ThreadBlock_Dynamic)
            for _, m in internal_maps):
         return True
-    imm_maps = get_internal_scopes(state, entry, immediate=True)
+
+    imm_maps = get_internal_scopes(state, entry, immediate=True, recursive_scope_tree=rstree)
     if any(m.schedule == dtypes.ScheduleType.Default for _, m in imm_maps):
         return True