fix[next][dace]: Remove isolated access nodes for unused args in let-lambda (#2422)

This PR handles `SymRefs` to symbols which are not used, and which are
passed as arguments to let-lambdas. The cleanup stage was removed in
#2418, resulting in isolated access nodes. Test coverage added.

Author: edopao

src/gt4py/next/program_processors/runners/dace/lowering/gtir_to_sdfg.py

@@ -1235,6 +1235,20 @@ def visit_Lambda(
 
             ctx.state.add_edge(src_node, None, nsdfg_node, input_connector, memlet)
 
+        # We can now safely remove all remaining arguments, because unused.
+        # It can happen that a let-lambda argument is not used, in which case it
+        # should be `None` at this stage, but the symbol passed as argument is captured
+        # by the let-lambda expression and thus can be accessed directly inside the
+        # inner scope. The domain in the annex of this symbol is not `NEVER`, and
+        # an access node is created, so we find an isolated access node here.
+        if unused_access_nodes := [
+            arg_node.dc_node
+            for arg_node in lambda_arg_nodes.values()
+            if not (arg_node is None or arg_node.dc_node.desc(ctx.sdfg).transient)
+        ]:
+            assert all(ctx.state.degree(access_node) == 0 for access_node in unused_access_nodes)
+            ctx.state.remove_nodes_from(unused_access_nodes)
+
         def construct_output_for_nested_sdfg(
             inner_data: gtir_to_sdfg_types.FieldopData,
         ) -> gtir_to_sdfg_types.FieldopData:

src/gt4py/next/program_processors/runners/dace/lowering/gtir_to_sdfg_primitives.py

@@ -618,8 +618,8 @@ def translate_tuple_get(
     index = int(node.args[0].value)
 
     data_nodes = sdfg_builder.visit(node.args[1], ctx=ctx)
-    if isinstance(data_nodes, gtir_to_sdfg_types.FieldopData):
-        raise ValueError(f"Invalid tuple expression {node}")
+    if not isinstance(data_nodes, tuple):
+        raise ValueError(f"Invalid tuple expression {node}.")
     # Now we remove the tuple fields that are not used, to avoid an SDFG validation
     # error because of isolated access nodes.
     unused_data_nodes = gtx_utils.flatten_nested_tuple(
@@ -724,6 +724,11 @@ def translate_symbol_ref(
     """Generates the dataflow subgraph for a `ir.SymRef` node."""
     assert isinstance(node, gtir.SymRef)
 
+    # If the symbol is not used, the domain is set to 'NEVER' in node annex.
+    node_domain = getattr(node.annex, "domain", infer_domain.DomainAccessDescriptor.UNKNOWN)
+    if node_domain == infer_domain.DomainAccessDescriptor.NEVER:
+        return None
+
     symbol_name = str(node.id)
     # we retrieve the type of the symbol in the GT4Py prgram
     gt_symbol_type = sdfg_builder.get_symbol_type(symbol_name)

tests/next_tests/unit_tests/program_processor_tests/runners_tests/dace_tests/test_gtir_to_sdfg.py

@@ -1647,6 +1647,38 @@ def test_gtir_let_lambda():
     assert np.allclose(b, ref)
 
 
+def test_gtir_let_lambda_unused_arg():
+    testee = gtir.Program(
+        id="let_lambda_unused_arg",
+        function_definitions=[],
+        params=[
+            gtir.Sym(id="x", type=IFTYPE),
+            gtir.Sym(id="y", type=IFTYPE),
+            gtir.Sym(id="z", type=IFTYPE),
+        ],
+        declarations=[],
+        body=[
+            gtir.SetAt(
+                # Arg 'xᐞ1' is used inside the let-lambda, 'yᐞ1' is not.
+                expr=im.let(("xᐞ1", im.op_as_fieldop("multiplies")("x", 3.0)), ("yᐞ1", "y"))(
+                    im.op_as_fieldop("multiplies")("xᐞ1", 2.0)
+                ),
+                domain=im.get_field_domain(gtx_common.GridType.CARTESIAN, "z", [IDim]),
+                target=gtir.SymRef(id="z"),
+            )
+        ],
+    )
+
+    a = np.random.rand(N)
+    b = np.random.rand(N)
+    c = np.random.rand(N)
+
+    sdfg = build_dace_sdfg(testee, {})
+
+    sdfg(a, b, c, **FSYMBOLS)
+    assert np.allclose(c, a * 6.0)
+
+
 def test_gtir_let_lambda_scalar_expression():
     domain_inner = im.domain(gtx_common.GridType.CARTESIAN, ranges={IDim: (1, "size_inner")})
     domain_outer = im.get_field_domain(