diff --git a/dace/cli/sdfgcc.py b/dace/cli/sdfgcc.py
index 1df7604b4b..0d04950be7 100644
--- a/dace/cli/sdfgcc.py
+++ b/dace/cli/sdfgcc.py
@@ -48,7 +48,7 @@ def main():
         sdfg = SDFGOptimizer(sdfg).optimize()
 
     # Compile SDFG
-    sdfg.compile(outpath)
+    sdfg.compile(outpath, return_program_handle=False)
 
     # Copying header file to optional path
     if outpath is not None:
diff --git a/dace/cli/sdfv.py b/dace/cli/sdfv.py
index 2012debe82..d14059468f 100644
--- a/dace/cli/sdfv.py
+++ b/dace/cli/sdfv.py
@@ -43,7 +43,11 @@ def view(sdfg: dace.SDFG, filename: Optional[Union[str, int]] = None, verbose: b
         ):
             fd, filename = tempfile.mkstemp(suffix='.sdfg')
             sdfg.save(filename)
-            os.system(f'code {filename}')
+            if platform.system() == 'Darwin':
+                # Special case for MacOS
+                os.system(f'open {filename}')
+            else:
+                os.system(f'code {filename}')
             os.close(fd)
             return
 
diff --git a/dace/codegen/compiled_sdfg.py b/dace/codegen/compiled_sdfg.py
index 9bfcc439e0..332db028ae 100644
--- a/dace/codegen/compiled_sdfg.py
+++ b/dace/codegen/compiled_sdfg.py
@@ -518,6 +518,9 @@ def _construct_args(self, kwargs) -> Tuple[Tuple[Any], Tuple[Any]]:
                     # Otherwise, None values are passed as null pointers below
                 elif isinstance(arg, ctypes._Pointer):
                     pass
+                elif isinstance(arg, str):
+                    # Cast to bytes
+                    arglist[i] = ctypes.c_char_p(arg.encode('utf-8'))
                 else:
                     raise TypeError(f'Passing an object (type {type(arg).__name__}) to an array in argument "{a}"')
             elif is_array and not is_dtArray:
@@ -550,6 +553,8 @@ def _construct_args(self, kwargs) -> Tuple[Tuple[Any], Tuple[Any]]:
                     pass
                 elif isinstance(arg, float) and atype.dtype.type == np.float64:
                     pass
+                elif isinstance(arg, bool) and atype.dtype.type == np.bool_:
+                    pass
                 elif (isinstance(arg, str) or arg is None) and atype.dtype == dtypes.string:
                     if arg is None:
                         arglist[i] = ctypes.c_char_p(None)
diff --git a/dace/codegen/compiler.py b/dace/codegen/compiler.py
index 350e141606..236f832cac 100644
--- a/dace/codegen/compiler.py
+++ b/dace/codegen/compiler.py
@@ -213,7 +213,7 @@ def configure_and_compile(program_folder, program_name=None, output_stream=None)
         # Clean CMake directory and try once more
         if Config.get_bool('debugprint'):
             print('Cleaning CMake build folder and retrying...')
-        shutil.rmtree(build_folder)
+        shutil.rmtree(build_folder, ignore_errors=True)
         os.makedirs(build_folder)
         try:
             _run_liveoutput(cmake_command, shell=True, cwd=build_folder, output_stream=output_stream)
diff --git a/dace/codegen/cppunparse.py b/dace/codegen/cppunparse.py
index edeb5270ca..c375147930 100644
--- a/dace/codegen/cppunparse.py
+++ b/dace/codegen/cppunparse.py
@@ -555,7 +555,11 @@ def _write_constant(self, value):
             if result.find("b'") >= 0:
                 self.write(result)
             else:
-                self.write(result.replace('\'', '\"'))
+                towrite = result
+                if result.startswith("'"):
+                    towrite = result[1:-1].replace('"', '\\"')
+                    towrite = f'"{towrite}"'
+                self.write(towrite)
 
     def _Constant(self, t):
         value = t.value
@@ -1187,6 +1191,8 @@ def py2cpp(code, expr_semicolon=True, defined_symbols=None):
         return cppunparse(ast.parse(symbolic.symstr(code, cpp_mode=True)),
                           expr_semicolon,
                           defined_symbols=defined_symbols)
+    elif isinstance(code, int):
+        return str(code)
     elif code.__class__.__name__ == 'function':
         try:
             code_str = inspect.getsource(code)
diff --git a/dace/codegen/tools/type_inference.py b/dace/codegen/tools/type_inference.py
index 8f8dd84151..26b369fa9d 100644
--- a/dace/codegen/tools/type_inference.py
+++ b/dace/codegen/tools/type_inference.py
@@ -375,6 +375,8 @@ def _Compare(t, symbols, inferred_symbols):
     for o, e in zip(t.ops, t.comparators):
         if o.__class__.__name__ not in cppunparse.CPPUnparser.cmpops:
             continue
+        if isinstance(e, ast.Constant) and e.value is None:
+            continue
         inf_type = _dispatch(e, symbols, inferred_symbols)
         if isinstance(inf_type, dtypes.vector):
             # Make sure all occuring vectors are of same size
diff --git a/dace/dtypes.py b/dace/dtypes.py
index a016ac60e2..d0c6f23e03 100644
--- a/dace/dtypes.py
+++ b/dace/dtypes.py
@@ -404,6 +404,8 @@ def __init__(self, wrapped_type, typename=None):
             wrapped_type = numpy.bool_
         elif getattr(wrapped_type, '__name__', '') == 'bool_' and typename is None:
             typename = 'bool'
+        elif wrapped_type is type(None):
+            wrapped_type = None
 
         self.type = wrapped_type  # Type in Python
         self.ctype = _CTYPES[wrapped_type]  # Type in C
diff --git a/dace/memlet.py b/dace/memlet.py
index f78da3a6b7..85bd0a348d 100644
--- a/dace/memlet.py
+++ b/dace/memlet.py
@@ -555,9 +555,9 @@ def used_symbols(self, all_symbols: bool, edge=None) -> Set[str]:
             from dace.sdfg import nodes
             if isinstance(edge.dst, nodes.CodeNode) or isinstance(edge.src, nodes.CodeNode):
                 view_edge = True
-            elif edge.dst_conn == 'views' and isinstance(edge.dst, nodes.AccessNode):
+            elif edge.dst_conn and isinstance(edge.dst, nodes.AccessNode):
                 view_edge = True
-            elif edge.src_conn == 'views' and isinstance(edge.src, nodes.AccessNode):
+            elif edge.src_conn and isinstance(edge.src, nodes.AccessNode):
                 view_edge = True
 
         if not view_edge:
diff --git a/dace/properties.py b/dace/properties.py
index 09439ce4f8..82be72f9fd 100644
--- a/dace/properties.py
+++ b/dace/properties.py
@@ -329,7 +329,7 @@ def initialize_properties(obj, *args, **kwargs):
         for name, prop in own_properties.items():
             # Only assign our own properties, so we don't overwrite what's been
             # set by the base class
-            if hasattr(obj, name):
+            if hasattr(obj, '_' + name):
                 raise PropertyError("Property {} already assigned in {}".format(name, type(obj).__name__))
             if not prop.indirected:
                 if prop.allow_none or prop.default is not None:
diff --git a/dace/runtime/include/dace/stream.h b/dace/runtime/include/dace/stream.h
index 255e16ec2b..1f8134fae6 100644
--- a/dace/runtime/include/dace/stream.h
+++ b/dace/runtime/include/dace/stream.h
@@ -338,7 +338,7 @@ namespace dace {
 
     template <int CHUNKSIZE>
     struct Consume {
-        template <template <typename, bool> typename StreamT, typename T, bool ALIGNED,
+        template <template <typename, bool> class StreamT, typename T, bool ALIGNED,
                   typename Functor>
         static void consume(StreamT<T, ALIGNED>& stream, unsigned num_threads,
                             Functor&& contents) {
@@ -359,7 +359,7 @@ namespace dace {
             for (auto& t : threads) t.join();
         }
 
-        template <template <typename, bool> typename StreamT, typename T, bool ALIGNED,
+        template <template <typename, bool> class StreamT, typename T, bool ALIGNED,
                   typename CondFunctor, typename Functor>
         static void consume_cond(StreamT<T, ALIGNED>& stream, unsigned num_threads,
                                  CondFunctor&& quiescence, Functor&& contents) {
@@ -384,7 +384,7 @@ namespace dace {
     // Specialization for consumption of 1 element
     template<>
     struct Consume<1> {
-        template <template <typename, bool> typename StreamT, typename T, bool ALIGNED,
+        template <template <typename, bool> class StreamT, typename T, bool ALIGNED,
                   typename Functor>
         static void consume(StreamT<T, ALIGNED>& stream, unsigned num_threads,
                             Functor&& contents) {
@@ -404,7 +404,7 @@ namespace dace {
             for (auto& t : threads) t.join();
         }
 
-        template <template <typename, bool> typename StreamT, typename T, bool ALIGNED,
+        template <template <typename, bool> class StreamT, typename T, bool ALIGNED,
                   typename CondFunctor, typename Functor>
         static void consume_cond(StreamT<T, ALIGNED>& stream, unsigned num_threads,
                                  CondFunctor&& quiescence, Functor&& contents) {
diff --git a/dace/sdfg/graph.py b/dace/sdfg/graph.py
index 5ec4bbb029..b8dcfd4e8f 100644
--- a/dace/sdfg/graph.py
+++ b/dace/sdfg/graph.py
@@ -409,7 +409,7 @@ def all_simple_paths(self,
             for path in map(nx.utils.pairwise, nx.all_simple_paths(self._nx, source_node, dest_node)):
                 yield [Edge(e[0], e[1], self._nx.edges[e]['data']) for e in path]
         else:
-            return nx.all_simple_paths(self._nx, source_node, dest_node)
+            yield from nx.all_simple_paths(self._nx, source_node, dest_node)
 
     def all_nodes_between(self, begin: NodeT, end: NodeT) -> Sequence[NodeT]:
         """Finds all nodes between begin and end. Returns None if there is any
diff --git a/dace/sdfg/propagation.py b/dace/sdfg/propagation.py
index a24db0c72b..f048389421 100644
--- a/dace/sdfg/propagation.py
+++ b/dace/sdfg/propagation.py
@@ -377,7 +377,7 @@ def can_be_applied(self, dim_exprs, variable_context, node_range, orig_edges, di
                 matches = rngelem.match(cst)
                 if matches is None or len(matches) != 1:
                     return False
-                if not matches[cst].is_constant():
+                if matches[cst].free_symbols:
                     return False
 
         else:  # Single element case
@@ -386,7 +386,7 @@ def can_be_applied(self, dim_exprs, variable_context, node_range, orig_edges, di
                 matches = dexpr.match(cst)
                 if matches is None or len(matches) != 1:
                     return False
-                if not matches[cst].is_constant():
+                if matches[cst].free_symbols:
                     return False
 
         return True
@@ -1296,6 +1296,8 @@ def align_memlet(state, e: gr.MultiConnectorEdge[Memlet], dst: bool) -> Memlet:
     # Fix memlet fields
     result.data = node.data
     result.subset = e.data.other_subset
+    if result.subset is None:
+        result.subset = subsets.Range.from_array(state.sdfg.arrays[result.data])
     result.other_subset = e.data.subset
     result._is_data_src = not is_src
     return result
diff --git a/dace/sdfg/sdfg.py b/dace/sdfg/sdfg.py
index 19d2a47295..3be268e44d 100644
--- a/dace/sdfg/sdfg.py
+++ b/dace/sdfg/sdfg.py
@@ -2266,14 +2266,16 @@ def is_loaded(self) -> bool:
         dll = cs.ReloadableDLL(binary_filename, self.name)
         return dll.is_loaded()
 
-    def compile(self, output_file=None, validate=True) -> 'CompiledSDFG':
+    def compile(self, output_file=None, validate=True,
+                return_program_handle=True) -> 'CompiledSDFG':
         """ Compiles a runnable binary from this SDFG.
 
             :param output_file: If not None, copies the output library file to
                                 the specified path.
             :param validate: If True, validates the SDFG prior to generating
                              code.
-            :return: A callable CompiledSDFG object.
+            :param return_program_handle: If False, does not load the generated library.
+            :return: A callable CompiledSDFG object, or None if ``return_program_handle=False``.
         """
 
         # Importing these outside creates an import loop
@@ -2336,7 +2338,8 @@ def compile(self, output_file=None, validate=True) -> 'CompiledSDFG':
             shutil.copyfile(shared_library, output_file)
 
         # Get the function handle
-        return compiler.get_program_handle(shared_library, sdfg)
+        if return_program_handle:
+            return compiler.get_program_handle(shared_library, sdfg)
 
     def argument_typecheck(self, args, kwargs, types_only=False):
         """ Checks if arguments and keyword arguments match the SDFG
diff --git a/dace/sdfg/utils.py b/dace/sdfg/utils.py
index 5b9ce1a431..623a82c5bf 100644
--- a/dace/sdfg/utils.py
+++ b/dace/sdfg/utils.py
@@ -629,9 +629,13 @@ def remove_edge_and_dangling_path(state: SDFGState, edge: MultiConnectorEdge):
         e = curedge.edge
         state.remove_edge(e)
         if inwards:
-            neighbors = [] if not e.src_conn else [neighbor for neighbor in state.out_edges_by_connector(e.src, e.src_conn)]
+            neighbors = [] if not e.src_conn else [
+                neighbor for neighbor in state.out_edges_by_connector(e.src, e.src_conn)
+            ]
         else:
-            neighbors = [] if not e.dst_conn else [neighbor for neighbor in state.in_edges_by_connector(e.dst, e.dst_conn)]
+            neighbors = [] if not e.dst_conn else [
+                neighbor for neighbor in state.in_edges_by_connector(e.dst, e.dst_conn)
+            ]
         if len(neighbors) > 0:  # There are still edges connected, leave as-is
             break
 
@@ -796,6 +800,33 @@ def get_all_view_nodes(state: SDFGState, view: nd.AccessNode) -> List[nd.AccessN
     return result
 
 
+def get_all_view_edges(state: SDFGState, view: nd.AccessNode) -> List[gr.MultiConnectorEdge[mm.Memlet]]:
+    """
+    Given a view access node, returns a list of viewed access nodes as edges
+    if existent, else None
+    """
+    sdfg = state.parent
+    node = view
+    desc = sdfg.arrays[node.data]
+    result = []
+    while isinstance(desc, dt.View):
+        edge = get_view_edge(state, node)
+        if edge is None:
+            break
+        old_node = node
+        if edge.dst is view:
+            node = edge.src
+        else:
+            node = edge.dst
+        if node is old_node:
+            break
+        if not isinstance(node, nd.AccessNode):
+            break
+        desc = sdfg.arrays[node.data]
+        result.append(edge)
+    return result
+
+
 def get_view_edge(state: SDFGState, view: nd.AccessNode) -> gr.MultiConnectorEdge[mm.Memlet]:
     """
     Given a view access node, returns the
@@ -818,8 +849,18 @@ def get_view_edge(state: SDFGState, view: nd.AccessNode) -> gr.MultiConnectorEdg
     # If there is one edge (in/out) that leads (via memlet path) to an access
     # node, and the other side (out/in) has a different number of edges.
     if len(in_edges) == 1 and len(out_edges) != 1:
+        # If the edge is not leading to an access node, fail
+        mpath = state.memlet_path(in_edges[0])
+        if not isinstance(mpath[0].src, nd.AccessNode):
+            return None
+
         return in_edges[0]
     if len(out_edges) == 1 and len(in_edges) != 1:
+        # If the edge is not leading to an access node, fail
+        mpath = state.memlet_path(out_edges[0])
+        if not isinstance(mpath[-1].dst, nd.AccessNode):
+            return None
+
         return out_edges[0]
     if len(out_edges) == len(in_edges) and len(out_edges) != 1:
         return None
@@ -843,7 +884,7 @@ def get_view_edge(state: SDFGState, view: nd.AccessNode) -> gr.MultiConnectorEdg
         return out_edge
     if not src_is_data and not dst_is_data:
         return None
-    
+
     # Check if there is a 'views' connector
     if in_edge.dst_conn and in_edge.dst_conn == 'views':
         return in_edge
@@ -1227,8 +1268,8 @@ def fuse_states(sdfg: SDFG, permissive: bool = False, progress: bool = None) ->
                         progress = True
                         pbar = tqdm(total=fusible_states, desc='Fusing states', initial=counter)
 
-                    if (u in skip_nodes or v in skip_nodes or not isinstance(v, SDFGState) or
-                        not isinstance(u, SDFGState)):
+                    if (u in skip_nodes or v in skip_nodes or not isinstance(v, SDFGState)
+                            or not isinstance(u, SDFGState)):
                         continue
                     candidate = {StateFusion.first_state: u, StateFusion.second_state: v}
                     sf = StateFusion()
@@ -1252,8 +1293,7 @@ def inline_loop_blocks(sdfg: SDFG, permissive: bool = False, progress: bool = No
     blocks = [n for n, _ in sdfg.all_nodes_recursive() if isinstance(n, LoopRegion)]
     count = 0
 
-    for _block in optional_progressbar(reversed(blocks), title='Inlining Loops',
-                                       n=len(blocks), progress=progress):
+    for _block in optional_progressbar(reversed(blocks), title='Inlining Loops', n=len(blocks), progress=progress):
         block: LoopRegion = _block
         if block.inline()[0]:
             count += 1
@@ -1265,20 +1305,25 @@ def inline_control_flow_regions(sdfg: SDFG, permissive: bool = False, progress:
     blocks = [n for n, _ in sdfg.all_nodes_recursive() if isinstance(n, ControlFlowRegion)]
     count = 0
 
-    for _block in optional_progressbar(reversed(blocks), title='Inlining control flow regions',
-                                       n=len(blocks), progress=progress):
+    for _block in optional_progressbar(reversed(blocks),
+                                       title='Inlining control flow regions',
+                                       n=len(blocks),
+                                       progress=progress):
         block: ControlFlowRegion = _block
         if block.inline()[0]:
             count += 1
 
     return count
 
+
 def inline_conditional_blocks(sdfg: SDFG, permissive: bool = False, progress: bool = None) -> int:
     blocks = [n for n, _ in sdfg.all_nodes_recursive() if isinstance(n, ConditionalBlock)]
     count = 0
 
-    for _block in optional_progressbar(reversed(blocks), title='Inlining conditional blocks',
-                                       n=len(blocks), progress=progress):
+    for _block in optional_progressbar(reversed(blocks),
+                                       title='Inlining conditional blocks',
+                                       n=len(blocks),
+                                       progress=progress):
         block: ConditionalBlock = _block
         if block.inline()[0]:
             count += 1
diff --git a/dace/sdfg/validation.py b/dace/sdfg/validation.py
index 2df9e17445..0b1d946798 100644
--- a/dace/sdfg/validation.py
+++ b/dace/sdfg/validation.py
@@ -836,7 +836,7 @@ def validate_state(state: 'dace.sdfg.SDFGState',
             dst_expr = (e.data.dst_subset.num_elements() * sdfg.arrays[dst_node.data].veclen)
             if symbolic.inequal_symbols(src_expr, dst_expr):
                 error = InvalidSDFGEdgeError('Dimensionality mismatch between src/dst subsets', sdfg, state_id, eid)
-                # NOTE: Make an exception for Views
+                # NOTE: Make an exception for Views and reference sets
                 from dace.sdfg import utils
                 if (isinstance(sdfg.arrays[src_node.data], dt.View) and utils.get_view_edge(state, src_node) is e):
                     warnings.warn(error.message)
@@ -844,6 +844,8 @@ def validate_state(state: 'dace.sdfg.SDFGState',
                 if (isinstance(sdfg.arrays[dst_node.data], dt.View) and utils.get_view_edge(state, dst_node) is e):
                     warnings.warn(error.message)
                     continue
+                if e.dst_conn == 'set':
+                    continue
                 raise error
 
     if Config.get_bool('experimental.check_race_conditions'):
diff --git a/dace/subsets.py b/dace/subsets.py
index e7b6869678..0fa6fb536c 100644
--- a/dace/subsets.py
+++ b/dace/subsets.py
@@ -162,10 +162,10 @@ def covers_precise(self, other):
     def __repr__(self):
         return '%s (%s)' % (type(self).__name__, self.__str__())
 
-    def offset(self, other, negative, indices=None):
+    def offset(self, other, negative, indices=None, offset_end=True):
         raise NotImplementedError
 
-    def offset_new(self, other, negative, indices=None):
+    def offset_new(self, other, negative, indices=None, offset_end=True):
         raise NotImplementedError
 
     def at(self, i, strides):
@@ -229,6 +229,7 @@ def _tuple_to_symexpr(val):
 @dace.serialize.serializable
 class Range(Subset):
     """ Subset defined in terms of a fixed range. """
+
     def __init__(self, ranges):
         parsed_ranges = []
         parsed_tiles = []
@@ -402,7 +403,7 @@ def data_dims(self):
         return (sum(1 if (re - rb + 1) != 1 else 0 for rb, re, _ in self.ranges) + sum(1 if ts != 1 else 0
                                                                                        for ts in self.tile_sizes))
 
-    def offset(self, other, negative, indices=None):
+    def offset(self, other, negative, indices=None, offset_end=True):
         if not isinstance(other, Subset):
             if isinstance(other, (list, tuple)):
                 other = Indices(other)
@@ -414,9 +415,11 @@ def offset(self, other, negative, indices=None):
         off = other.min_element()
         for i in indices:
             rb, re, rs = self.ranges[i]
-            self.ranges[i] = (rb + mult * off[i], re + mult * off[i], rs)
+            if offset_end:
+                re = re + mult * off[i]
+            self.ranges[i] = (rb + mult * off[i], re, rs)
 
-    def offset_new(self, other, negative, indices=None):
+    def offset_new(self, other, negative, indices=None, offset_end=True):
         if not isinstance(other, Subset):
             if isinstance(other, (list, tuple)):
                 other = Indices(other)
@@ -426,8 +429,8 @@ def offset_new(self, other, negative, indices=None):
         if indices is None:
             indices = set(range(len(self.ranges)))
         off = other.min_element()
-        return Range([(self.ranges[i][0] + mult * off[i], self.ranges[i][1] + mult * off[i], self.ranges[i][2])
-                      for i in indices])
+        return Range([(self.ranges[i][0] + mult * off[i], self.ranges[i][1] if not offset_end else
+                       (self.ranges[i][1] + mult * off[i]), self.ranges[i][2]) for i in indices])
 
     def dims(self):
         return len(self.ranges)
@@ -848,9 +851,11 @@ def intersects(self, other: 'Range'):
 class Indices(Subset):
     """ A subset of one element representing a single index in an
         N-dimensional data descriptor. """
+
     def __init__(self, indices):
         if indices is None or len(indices) == 0:
-            raise TypeError('Expected an array of index expressions: got empty' ' array or None')
+            raise TypeError('Expected an array of index expressions: got empty'
+                            ' array or None')
         if isinstance(indices, str):
             raise TypeError("Expected collection of index expression: got str")
         elif isinstance(indices, symbolic.SymExpr):
@@ -860,6 +865,7 @@ def __init__(self, indices):
         self.tile_sizes = [1]
 
     def to_json(self):
+
         def a2s(obj):
             if isinstance(obj, symbolic.SymExpr):
                 return str(obj.expr)
@@ -919,7 +925,7 @@ def strides(self):
     def absolute_strides(self, global_shape):
         return [1] * len(self.indices)
 
-    def offset(self, other, negative, indices=None):
+    def offset(self, other, negative, indices=None, offset_end=True):
         if not isinstance(other, Subset):
             if isinstance(other, (list, tuple)):
                 other = Indices(other)
@@ -929,7 +935,7 @@ def offset(self, other, negative, indices=None):
         for i, off in enumerate(other.min_element()):
             self.indices[i] += mult * off
 
-    def offset_new(self, other, negative, indices=None):
+    def offset_new(self, other, negative, indices=None, offset_end=True):
         if not isinstance(other, Subset):
             if isinstance(other, (list, tuple)):
                 other = Indices(other)
diff --git a/dace/symbolic.py b/dace/symbolic.py
index 6218bbe715..9737080c52 100644
--- a/dace/symbolic.py
+++ b/dace/symbolic.py
@@ -23,7 +23,6 @@
 # below, we recreate it to be as in versions < 1.9.
 _sympy_clash = {k: v if v else getattr(sympy.abc, k) for k, v in sympy.abc._clash.items()}
 
-
 # SymPy 1.13 changes the behavior of `==` such that floats with different precisions
 # are always different.
 # For DaCe, mostly the comparison of value (ignoring precision) is relevant which
@@ -31,6 +30,7 @@
 # SymPy 1.12, so we fall back to `==` in that case (which ignores precision in those versions).
 # For convenience, we provide this functionality in our own SymPy layer.
 if packaging_version.Version(sympy.__version__) < packaging_version.Version("1.12"):
+
     def equal_valued(x, y):
         return x == y
 else:
@@ -584,6 +584,8 @@ def eval(cls, x, y):
         """
         if x.is_Number and y.is_Number:
             return x // y
+        if y.is_Number and y == 1:
+            return x
 
     def _eval_is_integer(self):
         return True
@@ -658,31 +660,79 @@ def eval(cls, x, y, z):
         if x.is_Boolean:
             return (y if x else z)
 
+    def _eval_is_real(self):
+        if self.args[1].is_real is True and self.args[2].is_real is True:
+            return True
+        if self.args[1].is_real is False and self.args[2].is_real is False:
+            return False
 
-class BitwiseAnd(sympy.Function):
-    pass
+    def _eval_is_nonnegative(self):
+        if self.args[1].is_nonnegative is True and self.args[2].is_nonnegative is True:
+            return True
+        if self.args[1].is_nonnegative is False and self.args[2].is_nonnegative is False:
+            return False
 
+    def _eval_is_positive(self):
+        if self.args[1].is_positive is True and self.args[2].is_positive is True:
+            return True
+        if self.args[1].is_positive is False and self.args[2].is_positive is False:
+            return False
 
-class BitwiseOr(sympy.Function):
-    pass
+    def _eval_is_integer(self):
+        if self.args[1].is_integer is True and self.args[2].is_integer is True:
+            return True
+        if self.args[1].is_integer is False and self.args[2].is_integer is False:
+            return False
 
 
-class BitwiseXor(sympy.Function):
+class bitwise_and(sympy.Function):
     pass
 
 
-class BitwiseNot(sympy.Function):
+class bitwise_or(sympy.Function):
     pass
 
 
-class LeftShift(sympy.Function):
+class bitwise_xor(sympy.Function):
     pass
 
 
-class RightShift(sympy.Function):
+class bitwise_invert(sympy.Function):
     pass
 
 
+class left_shift(sympy.Function):
+
+    @classmethod
+    def eval(cls, x, y):
+        """
+        Evaluates a left shift.
+
+        :param x: Value to shift.
+        :param y: Value to shift by.
+        :return: Return value (literal or symbolic).
+        """
+        if x.is_Number and y.is_Number:
+            return x << y
+        return x * (2**y)
+
+
+class right_shift(sympy.Function):
+
+    @classmethod
+    def eval(cls, x, y):
+        """
+        Evaluates a right shift.
+
+        :param x: Value to shift.
+        :param y: Value to shift by.
+        :return: Return value (literal or symbolic).
+        """
+        if x.is_Number and y.is_Number:
+            return x >> y
+        return int_floor(x, (2**y))
+
+
 class ROUND(sympy.Function):
 
     @classmethod
@@ -724,7 +774,7 @@ def free_symbols(self):
 
     def __str__(self):
         return f'{self.args[0]}.{self.args[1]}'
-    
+
     def _subs(self, *args, **kwargs):
         return Attr(self.args[0].subs(*args, **kwargs), self.args[1].subs(*args, **kwargs))
 
@@ -951,12 +1001,12 @@ class PythonOpToSympyConverter(ast.NodeTransformer):
     }
 
     _ast_to_sympy_functions = {
-        ast.BitAnd: 'BitwiseAnd',
-        ast.BitOr: 'BitwiseOr',
-        ast.BitXor: 'BitwiseXor',
-        ast.Invert: 'BitwiseNot',
-        ast.LShift: 'LeftShift',
-        ast.RShift: 'RightShift',
+        ast.BitAnd: 'bitwise_and',
+        ast.BitOr: 'bitwise_or',
+        ast.BitXor: 'bitwise_xor',
+        ast.Invert: 'bitwise_invert',
+        ast.LShift: 'left_shift',
+        ast.RShift: 'right_shift',
         ast.FloorDiv: 'int_floor',
     }
 
@@ -970,18 +1020,35 @@ def visit_UnaryOp(self, node):
                                           node)
             new_node = ast.Call(func=func_node, args=[self.visit(node.operand)], keywords=[])
             return ast.copy_location(new_node, node)
+
+        # Convert arithmetic expressions of the form "-(a == b)" to ternary operators
+        node.operand = self._convert_boolop_to_ifexpr(node.operand)
+
         return self.generic_visit(node)
 
     def visit_BinOp(self, node):
+        # Convert arithmetic expressions of the form "a + (b == c)" to ternary operators
+        node.left = self._convert_boolop_to_ifexpr(node.left)
+        node.right = self._convert_boolop_to_ifexpr(node.right)
+
         if type(node.op) in self._ast_to_sympy_functions:
             func_node = ast.copy_location(ast.Name(id=self._ast_to_sympy_functions[type(node.op)], ctx=ast.Load()),
                                           node)
+
             new_node = ast.Call(func=func_node,
                                 args=[self.visit(value) for value in (node.left, node.right)],
                                 keywords=[])
             return ast.copy_location(new_node, node)
         return self.generic_visit(node)
 
+    def _convert_boolop_to_ifexpr(self, node: ast.AST):
+        if isinstance(node, ast.Compare):
+            return ast.copy_location(
+                ast.Call(func=ast.Name(id='IfExpr', ctx=ast.Load),
+                         args=[node, ast.Constant(value=1), ast.Constant(value=0)],
+                         keywords=[]), node)
+        return node
+
     def visit_BoolOp(self, node):
         func_node = ast.copy_location(ast.Name(id=type(node.op).__name__, ctx=ast.Load()), node)
 
@@ -1076,12 +1143,18 @@ def pystr_to_symbolic(expr, symbol_map=None, simplify=None) -> sympy.Basic:
         'arg': sympy.Symbol('arg'),
         'Is': Is,
         'IsNot': IsNot,
-        'BitwiseAnd': BitwiseAnd,
-        'BitwiseOr': BitwiseOr,
-        'BitwiseXor': BitwiseXor,
-        'BitwiseNot': BitwiseNot,
-        'LeftShift': LeftShift,
-        'RightShift': RightShift,
+        'BitwiseAnd': bitwise_and,
+        'BitwiseOr': bitwise_or,
+        'BitwiseXor': bitwise_xor,
+        'BitwiseNot': bitwise_invert,
+        'bitwise_and': bitwise_and,
+        'bitwise_or': bitwise_or,
+        'bitwise_xor': bitwise_xor,
+        'bitwise_invert': bitwise_invert,
+        'LeftShift': left_shift,
+        'left_shift': left_shift,
+        'RightShift': right_shift,
+        'right_shift': right_shift,
         'int_floor': int_floor,
         'int_ceil': int_ceil,
         'IfExpr': IfExpr,
diff --git a/dace/transformation/dataflow/redundant_array.py b/dace/transformation/dataflow/redundant_array.py
index 7b241ff9cd..5e5072ff32 100644
--- a/dace/transformation/dataflow/redundant_array.py
+++ b/dace/transformation/dataflow/redundant_array.py
@@ -196,6 +196,10 @@ def can_be_applied(self, graph: SDFGState, expr_index, sdfg, permissive=False):
         if not in_desc.transient:
             return False
 
+        # Skip structure views
+        if isinstance(in_desc, data.StructureView) or isinstance(out_desc, data.StructureView):
+            return False
+
         # 1. Get edge e1 and extract subsets for arrays A and B
         e1 = graph.edges_between(in_array, out_array)[0]
         try:
@@ -705,6 +709,10 @@ def can_be_applied(self, graph, expr_index, sdfg, permissive=False):
         if not out_desc.transient:
             return False
 
+        # Skip structure views
+        if isinstance(in_desc, data.StructureView) or isinstance(out_desc, data.StructureView):
+            return False
+
         # 1. Get edge e1 and extract/validate subsets for arrays A and B
         e1 = graph.edges_between(in_array, out_array)[0]
         try:
@@ -1528,6 +1536,8 @@ def can_be_applied(self, state: SDFGState, _: int, sdfg: SDFG, permissive=False)
         # Ensure view
         if not isinstance(desc, data.View):
             return False
+        if isinstance(desc, data.StructureView):
+            return False
 
         # Get viewed node and non-viewed edges
         view_edge = sdutil.get_view_edge(state, self.view)
diff --git a/dace/transformation/dataflow/tasklet_fusion.py b/dace/transformation/dataflow/tasklet_fusion.py
index 29bb014263..183b98c402 100644
--- a/dace/transformation/dataflow/tasklet_fusion.py
+++ b/dace/transformation/dataflow/tasklet_fusion.py
@@ -3,20 +3,21 @@
 
 import ast
 import re
-from typing import Any, Dict
+from typing import Any, Dict, Optional, Set
 
 import astunparse
 import dace
 from dace.dtypes import Language
+from dace.properties import make_properties, Property
 from dace.sdfg import nodes
 from dace.sdfg import utils as sdutil
 from dace.transformation import transformation as pm
-from dace.transformation import helpers as thelpers
 
 
 class PythonConnectorRenamer(ast.NodeTransformer):
     """ Renames connector names in Tasklet code.
     """
+
     def __init__(self, repl_dict: Dict[str, str]) -> None:
         """ Initializes AST transformer.
         
@@ -32,6 +33,7 @@ def visit_Name(self, node: ast.Name) -> Any:
 
 
 class CPPConnectorRenamer():
+
     def __init__(self, repl_dict: Dict[str, str]) -> None:
         self.repl_dict = repl_dict
 
@@ -43,6 +45,7 @@ def rename(self, code: str) -> str:
 
 
 class PythonInliner(ast.NodeTransformer):
+
     def __init__(self, target_id, target_ast):
         self.target_id = target_id
         self.target_ast = target_ast
@@ -55,6 +58,7 @@ def visit_Name(self, node: ast.AST):
 
 
 class CPPInliner():
+
     def __init__(self, inline_target, inline_val):
         self.inline_target = inline_target
         self.inline_val = inline_val
@@ -63,6 +67,7 @@ def inline(self, code: str):
         return re.sub(r'\b%s\b' % re.escape(self.inline_target), '(' + self.inline_val + ')', code)
 
 
+@make_properties
 class TaskletFusion(pm.SingleStateTransformation):
     """
     Fuses two connected Tasklets.
@@ -139,6 +144,11 @@ class TaskletFusion(pm.SingleStateTransformation):
     data = pm.PatternNode(nodes.AccessNode)
     t2 = pm.PatternNode(nodes.Tasklet)
 
+    new_name = Property(dtype=str,
+                        default=None,
+                        allow_none=True,
+                        desc='New name to give tasklet. If None, fuses tasklet names')
+
     @classmethod
     def expressions(cls):
         return [sdutil.node_path_graph(cls.t1, cls.data, cls.t2), sdutil.node_path_graph(cls.t1, cls.t2)]
@@ -157,9 +167,14 @@ def can_be_applied(self, graph: dace.SDFGState, expr_index: int, sdfg: dace.SDFG
             return False
 
         # The first Tasklet must not be used anywhere else. If the Tasklet leads into an AccessNode, that AccessNode in
-        # turn can not be used anywhere else.
+        # turn cannot be used anywhere else.
         if graph.out_degree(t1) != 1 or (data is not None and graph.out_degree(data) != 1):
             return False
+        if data is not None:
+            access_node_count = sum(1 for s in sdfg.nodes() for n in s.data_nodes() if n.data == data.data)
+            access_node_count += sum(1 for e in sdfg.edges() if data.data in e.data.free_symbols)
+            if access_node_count > 1:
+                return False
 
         # Try to parse the code to check that there is not more than one assignment.
         try:
@@ -186,6 +201,8 @@ def apply(self, graph: dace.SDFGState, sdfg: dace.SDFG):
 
         # Remove the connector from the second Tasklet.
         inputs = {k: v for k, v in t2.in_connectors.items() if k != t2_in_edge.dst_conn}
+        all_conns = set(inputs.keys()) | set(t2.out_connectors)
+        all_conns_with_inputs = all_conns | set(t1.in_connectors)
 
         # Copy the first Tasklet's in connectors.
         repldict = {}
@@ -195,7 +212,15 @@ def apply(self, graph: dace.SDFGState, sdfg: dace.SDFG):
                 continue
 
             # Check if there is a conflict.
-            if in_edge.dst_conn in inputs:
+            if in_edge.dst_conn in all_conns:
+
+                # Check for conflicts with the second tasklet's output connectors
+                if in_edge.dst_conn in t2.out_connectors:
+                    in_edge.dst_conn = dace.data.find_new_name(in_edge.dst_conn, all_conns_with_inputs)
+                    repldict[old_value] = in_edge.dst_conn
+                    inputs[in_edge.dst_conn] = t1.in_connectors[old_value]
+                    continue
+
                 # Conflicts are ok if the Memlets are the same.
                 conflict_edges = list(graph.in_edges_by_connector(t2, in_edge.dst_conn))
                 t2edge = None
@@ -208,7 +233,7 @@ def apply(self, graph: dace.SDFGState, sdfg: dace.SDFG):
                     t2edge = conflict_edges[0]
                 if t2edge is not None and (in_edge.data != t2edge.data or in_edge.data.data != t2edge.data.data
                                            or in_edge.data is None or in_edge.data.data is None):
-                    in_edge.dst_conn = dace.data.find_new_name(in_edge.dst_conn, set(inputs))
+                    in_edge.dst_conn = dace.data.find_new_name(in_edge.dst_conn, all_conns_with_inputs)
                     repldict[old_value] = in_edge.dst_conn
                 else:
                     # If the Memlets are the same, rename the connector on the first Tasklet, such that we only have
@@ -243,10 +268,25 @@ def apply(self, graph: dace.SDFGState, sdfg: dace.SDFG):
             if rhs:
                 new_code_str = CPPInliner(t2_in_edge.dst_conn, rhs).inline(t2.code.as_string)
         else:
-            return
+            raise ValueError(f'Cannot inline tasklet with language {t1.language}')
 
-        new_tasklet = graph.add_tasklet(t1.label + '_fused_' + t2.label, inputs, t2.out_connectors, new_code_str,
-                                        t1.language)
+        if self.new_name:
+            new_name = self.new_name
+        else:
+            new_name = t1.label + '_fused_' + t2.label
+
+        new_tasklet = graph.add_tasklet(new_name,
+                                        inputs,
+                                        t2.out_connectors,
+                                        new_code_str,
+                                        t1.language,
+                                        state_fields=t1.state_fields + t2.state_fields,
+                                        code_global=t1.code_global.code + t2.code_global.code,
+                                        code_init=t1.code_init.code + t2.code_init.code,
+                                        code_exit=t1.code_exit.code + t2.code_exit.code,
+                                        location=_merge_dicts(t1.location, t2.location),
+                                        side_effects=t1.side_effects or t2.side_effects,
+                                        debuginfo=_merge_debuginfo(t1.debuginfo, t2.debuginfo))
 
         for in_edge in graph.in_edges(t1):
             if in_edge.src_conn is None and isinstance(in_edge.src, dace.nodes.EntryNode):
@@ -269,3 +309,49 @@ def apply(self, graph: dace.SDFGState, sdfg: dace.SDFG):
             graph.remove_node(data)
 
         graph.remove_node(t2)
+
+
+def _merge_dicts(a: Optional[Dict[Any, Any]], b: Optional[Dict[Any, Any]]):
+    if a is None and b is not None:
+        return b
+    if b is None and a is not None:
+        return a
+    result = dict()
+    result.update(a)
+    result.update(b)
+    return result
+
+
+def _merge_sets(a: Optional[Set[Any]], b: Optional[Set[Any]]):
+    if a is None and b is not None:
+        return b
+    if b is None and a is not None:
+        return a
+    result = set()
+    result.update(a)
+    result.update(b)
+    return result
+
+
+def _merge_debuginfo(a: Optional[dace.DebugInfo], b: Optional[dace.DebugInfo]):
+    if a is None and b is not None:
+        return b
+    if b is None and a is not None:
+        return a
+
+    if a.filename != b.filename:
+        # TODO: Support multiple files in debuginfo
+        return b
+
+    a_end_line = a.end_line if a.end_line >= 0 else a.start_line
+    b_end_line = b.end_line if b.end_line >= 0 else b.start_line
+    a_end_col = a.end_column if a.end_column >= 0 else a.start_column
+    b_end_col = b.end_column if b.end_column >= 0 else b.start_column
+
+    return dace.DebugInfo(
+        start_line=min(a.start_line, b.start_line),
+        start_column=min(a.start_column, b.start_column),
+        end_line=max(a_end_line, b_end_line),
+        end_column=max(a_end_col, b_end_col),
+        filename=a.filename,
+    )
diff --git a/dace/transformation/helpers.py b/dace/transformation/helpers.py
index b7bf49e62b..7824030e5c 100644
--- a/dace/transformation/helpers.py
+++ b/dace/transformation/helpers.py
@@ -688,6 +688,9 @@ def state_fission(subgraph: graph.SubgraphView, label: Optional[str] = None) ->
     for e in orig_edges:
         newstate.add_edge(new_nodes[e.src], e.src_conn, new_nodes[e.dst], e.dst_conn, e.data)
 
+    for bn in boundary_nodes:
+        bn._in_connectors.clear()
+
     return newstate
 
 
diff --git a/dace/transformation/interstate/loop_to_map.py b/dace/transformation/interstate/loop_to_map.py
index 39410f2547..58b9d51c59 100644
--- a/dace/transformation/interstate/loop_to_map.py
+++ b/dace/transformation/interstate/loop_to_map.py
@@ -450,7 +450,7 @@ def apply(self, _, sdfg: sd.SDFG):
                     increment_edge = sdfg.add_edge(new_body, e.dst, e.data)
 
 
-            elif 1 < self.expr_index <= 3:  # Rotated loop
+            elif 1 < self.expr_index <= 3 or 5 <= self.expr_index <= 7:  # Rotated loop
                 entrystate = self.entry_state
                 latch = self.loop_latch
 
@@ -668,7 +668,8 @@ def apply(self, _, sdfg: sd.SDFG):
             body.add_nedge(entry, exit, memlet.Memlet())
 
         # Get rid of the loop exit condition edge (it will be readded below)
-        sdfg.remove_edge(after_edge)
+        if self.expr_index not in (5, 6, 7):
+            sdfg.remove_edge(after_edge)
 
         # Remove the assignment on the edge to the guard
         for e in [init_edge, increment_edge]:
diff --git a/dace/transformation/interstate/multistate_inline.py b/dace/transformation/interstate/multistate_inline.py
index f637f479dc..84b8a82c75 100644
--- a/dace/transformation/interstate/multistate_inline.py
+++ b/dace/transformation/interstate/multistate_inline.py
@@ -149,6 +149,9 @@ def apply(self, outer_state: SDFGState, sdfg: SDFG):
         for loc, code in nsdfg.exit_code.items():
             sdfg.append_exit_code(code.code, loc)
 
+        # Callbacks and other types
+        sdfg._callback_mapping.update(nsdfg.callback_mapping)
+
         # Environments
         for nstate in nsdfg.nodes():
             for node in nstate.nodes():
diff --git a/dace/transformation/interstate/sdfg_nesting.py b/dace/transformation/interstate/sdfg_nesting.py
index 622dfe5595..7b64e49869 100644
--- a/dace/transformation/interstate/sdfg_nesting.py
+++ b/dace/transformation/interstate/sdfg_nesting.py
@@ -263,6 +263,9 @@ def apply(self, state: SDFGState, sdfg: SDFG):
         for loc, code in nsdfg.exit_code.items():
             sdfg.append_exit_code(code.code, loc)
 
+        # Callbacks and other types
+        sdfg._callback_mapping.update(nsdfg.callback_mapping)
+
         # Environments
         for node in nstate.nodes():
             if isinstance(node, nodes.CodeNode):
diff --git a/dace/transformation/interstate/state_fusion.py b/dace/transformation/interstate/state_fusion.py
index 3abbe085f5..dbdf7642bd 100644
--- a/dace/transformation/interstate/state_fusion.py
+++ b/dace/transformation/interstate/state_fusion.py
@@ -306,6 +306,15 @@ def can_be_applied(self, graph, expr_index, sdfg, permissive=False):
             resulting_ccs: List[CCDesc] = StateFusion.find_fused_components(first_cc_input, first_cc_output,
                                                                             second_cc_input, second_cc_output)
 
+            if len(resulting_ccs) > 1:
+                # Side-effect tasklets cannot be fused if could lead to data races
+                for node in first_state.nodes():
+                    if isinstance(node, nodes.CodeNode) and getattr(node, 'side_effects', False):
+                        return False
+                for node in second_state.nodes():
+                    if isinstance(node, nodes.CodeNode) and getattr(node, 'side_effects', False):
+                        return False
+
             # Check for data races
             for fused_cc in resulting_ccs:
                 # Write-Write hazard - data is output of both first and second
diff --git a/dace/transformation/passes/analysis/analysis.py b/dace/transformation/passes/analysis/analysis.py
index 095319f807..cc0d95c1d8 100644
--- a/dace/transformation/passes/analysis/analysis.py
+++ b/dace/transformation/passes/analysis/analysis.py
@@ -1,12 +1,14 @@
 # Copyright 2019-2024 ETH Zurich and the DaCe authors. All rights reserved.
 
-from collections import defaultdict
+from collections import defaultdict, deque
+from dataclasses import dataclass
 from dace.sdfg.state import ControlFlowBlock, ControlFlowRegion, LoopRegion
 from dace.transformation import pass_pipeline as ppl, transformation
 from dace import SDFG, SDFGState, properties, InterstateEdge, Memlet, data as dt, symbolic
 from dace.sdfg.graph import Edge
-from dace.sdfg import nodes as nd
+from dace.sdfg import nodes as nd, utils as sdutil
 from dace.sdfg.analysis import cfg
+from dace.sdfg.propagation import align_memlet
 from typing import Dict, Set, Tuple, Any, Optional, Union
 import networkx as nx
 from networkx.algorithms import shortest_paths as nxsp
@@ -632,6 +634,7 @@ def apply_pass(self, top_sdfg: SDFG, _) -> Dict[int, Dict[str, Set[Memlet]]]:
         return top_result
 
 
+@dataclass(unsafe_hash=True)
 @properties.make_properties
 @transformation.experimental_cfg_block_compatible
 class FindReferenceSources(ppl.Pass):
@@ -642,6 +645,9 @@ class FindReferenceSources(ppl.Pass):
 
     CATEGORY: str = 'Analysis'
 
+    trace_through_code = properties.Property(dtype=bool, default=False, desc='Trace inputs through tasklets.')
+    recursive = properties.Property(dtype=bool, default=False, desc='Add reference of reference dependencies.')
+
     def modifies(self) -> ppl.Modifies:
         return ppl.Modifies.Nothing
 
@@ -658,6 +664,7 @@ def apply_pass(self, top_sdfg: SDFG, _) -> Dict[int, Dict[str, Set[Union[Memlet,
             result: Dict[str, Set[Memlet]] = defaultdict(set)
             reference_descs = set(k for k, v in sdfg.arrays.items() if isinstance(v, dt.Reference))
             for state in sdfg.states():
+                code_sources: Dict[str, Set[nd.CodeNode]] = defaultdict(set)
                 for anode in state.data_nodes():
                     if anode.data not in reference_descs:
                         continue
@@ -668,9 +675,51 @@ def apply_pass(self, top_sdfg: SDFG, _) -> Dict[int, Dict[str, Set[Union[Memlet,
                         if isinstance(true_src, nd.CodeNode):
                             # Code  -> Reference
                             result[anode.data].add(true_src)
+                            code_sources[anode.data].add(true_src)
                         else:
                             # Array -> Reference
-                            result[anode.data].add(e.data)
+                            result[anode.data].add(align_memlet(state, e, dst=False))
+
+                            # If array is view, add view targets
+                            view_targets = sdutil.get_all_view_edges(state, true_src)
+                            for te in view_targets:
+                                result[anode.data].add(align_memlet(state, te, dst=False))
+
+                        if 'views' in anode.out_connectors:  # Reference and view
+                            out_edge, = state.out_edges_by_connector(anode, 'views')
+                            if isinstance(out_edge.dst, nd.AccessNode):
+                                view_targets = sdutil.get_all_view_nodes(state, out_edge.dst)
+                            for target in view_targets:
+                                if isinstance(true_src, nd.CodeNode):
+                                    # Code  -> Reference
+                                    result[target.data].add(true_src)
+                                    code_sources[target.data].add(true_src)
+                                else:
+                                    # Array -> Reference
+                                    result[target.data].add(align_memlet(state, e, dst=False))
+
+                # Trace back through code nodes
+                if self.trace_through_code:
+                    for name, codes in code_sources.items():
+                        sources = deque(codes)
+                        while sources:
+                            src = sources.pop()
+                            if isinstance(src, nd.CodeNode):
+                                for e in state.in_edges(src):
+                                    true_src = state.memlet_path(e)[0].src
+                                    if isinstance(true_src, nd.CodeNode):
+                                        # Keep traversing backwards
+                                        sources.append(true_src)
+                                    else:
+                                        result[name].add(e.data)
+
+            # Recursively add dependencies of reference dependencies
+            if self.recursive:
+                for k, v in result.items():
+                    for src in list(v):
+                        if not isinstance(v, nd.CodeNode) and src.data in result:
+                            v.update(result[src.data])
+
             top_result[sdfg.cfg_id] = result
         return top_result
 
diff --git a/dace/transformation/passes/pattern_matching.py b/dace/transformation/passes/pattern_matching.py
index a046a557ce..faa011f7d9 100644
--- a/dace/transformation/passes/pattern_matching.py
+++ b/dace/transformation/passes/pattern_matching.py
@@ -124,6 +124,7 @@ def apply_pass(self, sdfg: SDFG, pipeline_results: Dict[str, Any]) -> Dict[str,
 
             # Set previous pipeline results
             match._pipeline_results = pipeline_results
+            match.permissive = self.permissive
 
             result = match.apply(graph, tcfg.sdfg)
             applied_transformations[type(match).__name__].append(result)
@@ -177,6 +178,7 @@ def _apply_and_validate(self, match: xf.PatternTransformation, sdfg: SDFG, start
 
         # Set previous pipeline results
         match._pipeline_results = pipeline_results
+        match.permissive = self.permissive
 
         if self.validate_all:
             match_name = match.print_match(tcfg)
diff --git a/dace/transformation/passes/scalar_to_symbol.py b/dace/transformation/passes/scalar_to_symbol.py
index a0cb08ea0c..33712c8a1c 100644
--- a/dace/transformation/passes/scalar_to_symbol.py
+++ b/dace/transformation/passes/scalar_to_symbol.py
@@ -86,6 +86,8 @@ def find_promotable_scalars(sdfg: sd.SDFG, transients_only: bool = True, integer
 
     # General array checks
     for aname, desc in sdfg.arrays.items():
+        if isinstance(desc, (dt.View, dt.StructureView)):
+            continue
         if (transients_only and not desc.transient) or isinstance(desc, dt.Stream):
             continue
         if desc.total_size != 1:
@@ -185,6 +187,9 @@ def find_promotable_scalars(sdfg: sd.SDFG, transients_only: bool = True, integer
                 else:
                     # Check that tasklets have only one statement
                     cb: props.CodeBlock = edge.src.code
+                    if edge.src.has_side_effects(sdfg):
+                        candidates.remove(candidate)
+                        continue
                     if cb.language is dtypes.Language.Python:
                         if (len(cb.code) > 1 or not isinstance(cb.code[0], ast.Assign)):
                             candidates.remove(candidate)
@@ -314,22 +319,25 @@ def __init__(self, in_edges: Dict[str, mm.Memlet], out_edges: Dict[str, mm.Memle
         """
         self.in_edges = in_edges
         self.out_edges = out_edges
+        self.arrays = {k: sdfg.arrays[v.data] for k, v in in_edges.items() if k is not None}
+        self.arrays.update({k: sdfg.arrays[v.data] for k, v in out_edges.items() if k is not None})
         self.sdfg = sdfg
         self.defined = defined_syms
+        self.connector_names = set(in_edges.keys()) | set(out_edges.keys())
         self.in_mapping: Dict[str, Tuple[str, subsets.Range]] = {}
         self.out_mapping: Dict[str, Tuple[str, subsets.Range]] = {}
         self.do_not_remove: Set[str] = set()
-        self.latest: DefaultDict[str, int] = collections.defaultdict(int)
 
     def visit_Subscript(self, node: ast.Subscript) -> Any:
         # Convert subscript to symbol name
         node = self.generic_visit(node)
         node_name = astutils.rname(node)
         if node_name in self.in_edges:
-            self.latest[node_name] += 1
-            new_name = f'{node_name}_{self.latest[node_name]}'
+            new_name = dt.find_new_name(node_name, self.connector_names)
+            self.connector_names.add(new_name)
+
             orig_subset = self.in_edges[node_name].subset
-            subset = orig_subset.compose(subsets.Range(astutils.subscript_to_slice(node, self.sdfg.arrays)[1]))
+            subset = orig_subset.compose(subsets.Range(astutils.subscript_to_slice(node, self.arrays)[1]))
             # Check if range can be collapsed
             if _range_is_promotable(subset, self.defined):
                 self.in_mapping[new_name] = (node_name, subset)
@@ -337,10 +345,11 @@ def visit_Subscript(self, node: ast.Subscript) -> Any:
             else:
                 self.do_not_remove.add(node_name)
         elif node_name in self.out_edges:
-            self.latest[node_name] += 1
-            new_name = f'{node_name}_{self.latest[node_name]}'
+            new_name = dt.find_new_name(node_name, self.connector_names)
+            self.connector_names.add(new_name)
+
             orig_subset = self.out_edges[node_name].subset
-            subset = orig_subset.compose(subsets.Range(astutils.subscript_to_slice(node, self.sdfg.arrays)[1]))
+            subset = orig_subset.compose(subsets.Range(astutils.subscript_to_slice(node, self.arrays)[1]))
             # Check if range can be collapsed
             if _range_is_promotable(subset, self.defined):
                 self.out_mapping[new_name] = (node_name, subset)
@@ -649,6 +658,8 @@ def apply_pass(self, sdfg: SDFG, _: Dict[Any, Any]) -> Set[str]:
                 tasklet_inputs = [e.src for e in state.in_edges(input)]
                 # Step 2.1
                 new_state = xfh.state_fission(gr.SubgraphView(state, set([input, node] + tasklet_inputs)))
+                if state.edges_between(input, node):  # Edge still there after fission, remove manually
+                    state.remove_edge_and_connectors(state.edges_between(input, node)[0])
                 new_isedge: sd.InterstateEdge = new_state.parent_graph.out_edges(new_state)[0]
                 # Step 2.2
                 node: nodes.AccessNode = new_state.sink_nodes()[0]
diff --git a/tests/transformations/tasklet_fusion_test.py b/tests/transformations/tasklet_fusion_test.py
index c621ee38d4..7227056f4c 100644
--- a/tests/transformations/tasklet_fusion_test.py
+++ b/tests/transformations/tasklet_fusion_test.py
@@ -287,9 +287,37 @@ def sdfg_intermediate_transients(A: dace.float32[10], B: dace.float32[10]):
             applied = True
             break
 
-    assert applied
-    assert len([node for node in sdfg.start_state.data_nodes() if node.data == "tmp"]) == 1
-    assert "tmp" in sdfg.arrays
+    # tmp is used twice, so tasklet fusion should not apply
+    assert not applied
+
+
+def test_transient_in_different_state():
+
+    @dace.program
+    def sdfg_intermediate_transients(A: dace.float32[10], B: dace.float32[10]):
+        tmp = dace.define_local_scalar(dace.float32)
+
+        # Use tmp in different states to test removal of data
+        if B[0] < 0:
+            tmp = A[0] - 1
+            B[0] = tmp
+        else:
+            tmp = A[0] + 1
+            B[0] = tmp
+
+    sdfg = sdfg_intermediate_transients.to_sdfg(simplify=True)
+    assert len([node for state in sdfg.states() for node in state.data_nodes() if node.data == "tmp"]) == 2
+
+    xforms = Optimizer(sdfg=sdfg).get_pattern_matches(patterns=(TaskletFusion, ))
+    applied = False
+    for xform in xforms:
+        if xform.data.data == "tmp":
+            xform.apply(sdfg.start_state, sdfg)
+            applied = True
+            break
+
+    # tmp is used twice, so tasklet fusion should not apply
+    assert not applied
 
 
 if __name__ == '__main__':
@@ -304,3 +332,4 @@ def sdfg_intermediate_transients(A: dace.float32[10], B: dace.float32[10]):
     test_map_with_tasklets(language='CPP', with_data=True)
     test_none_connector()
     test_intermediate_transients()
+    test_transient_in_different_state()