feat[next][dace]: GTIR-to-SDFG lowering of cast_ builtin

src/gt4py/next/program_processors/runners/dace_fieldview/gtir_python_codegen.py

@@ -73,12 +73,18 @@
 }
 
 
+def builtin_cast(*args: Any) -> str:
+    val, target_type = args
+    return MATH_BUILTINS_MAPPING[target_type].format(val)
+
+
 def builtin_if(*args: Any) -> str:
     cond, true_val, false_val = args
     return f"{true_val} if {cond} else {false_val}"
 
 
 GENERAL_BUILTIN_MAPPING: dict[str, Callable[[Any], str]] = {
+    "cast_": builtin_cast,
     "if_": builtin_if,
 }
 

src/gt4py/next/program_processors/runners/dace_fieldview/gtir_to_tasklet.py

@@ -795,5 +795,8 @@ def visit_Literal(self, node: gtir.Literal) -> SymbolExpr:
 
     def visit_SymRef(self, node: gtir.SymRef) -> IteratorExpr | MemletExpr | SymbolExpr:
         param = str(node.id)
-        assert param in self.symbol_map
-        return self.symbol_map[param]
+        if param in self.symbol_map:
+            return self.symbol_map[param]
+        # if not in the lambda symbol map, this must be a symref to a builtin function
+        assert param in gtir_python_codegen.MATH_BUILTINS_MAPPING
+        return SymbolExpr(param, dace.string)

tests/next_tests/unit_tests/program_processor_tests/runners_tests/test_dace_fieldview.py

@@ -97,35 +97,41 @@ def make_mesh_symbols(mesh: MeshDescriptor):
     )
 
 
-def test_gtir_copy():
+def test_gtir_cast():
     domain = im.call("cartesian_domain")(
         im.call("named_range")(gtir.AxisLiteral(value=IDim.value), 0, "size")
     )
+    IFTYPE_INT64 = ts.FieldType(IFTYPE.dims, dtype=ts.ScalarType(kind=ts.ScalarKind.INT64))
     testee = gtir.Program(
-        id="gtir_copy",
+        id="test_gtir_cast",
         function_definitions=[],
         params=[
-            gtir.Sym(id="x", type=IFTYPE),
+            gtir.Sym(id="x", type=IFTYPE_INT64),
             gtir.Sym(id="y", type=IFTYPE),
             gtir.Sym(id="size", type=SIZE_TYPE),
         ],
         declarations=[],
         body=[
             gtir.SetAt(
-                expr=im.as_fieldop(im.lambda_("a")(im.deref("a")), domain)("x"),
+                expr=im.op_as_fieldop("divides", domain)(
+                    im.as_fieldop(
+                        im.lambda_("a")(im.call("cast_")(im.deref("a"), "float64")), domain
+                    )("x"),
+                    2.0,
+                ),
                 domain=domain,
                 target=gtir.SymRef(id="y"),
             )
         ],
     )
 
-    a = np.random.rand(N)
-    b = np.empty_like(a)
+    a = np.ones(N, dtype=np.int64)
+    b = np.empty_like(a, dtype=np.float64)
 
     sdfg = dace_backend.build_sdfg_from_gtir(testee, CARTESIAN_OFFSETS)
 
     sdfg(x=a, y=b, **FSYMBOLS)
-    assert np.allclose(a, b)
+    assert np.allclose(b, 0.5)
 
 
 def test_gtir_update():