Repository: GridTools/gt4py
Pull request #1244 (2023-04-26 12:34:05)

fix[next]: Yet another test parametrization cleanup
- Change `pytest.skip` to `pytest.xfail` when the skip reason is a bug or missing feature.
- Enable a few tests which are supported now.


Patch:
diff --git a/src/gt4py/next/ffront/foast_to_itir.py b/src/gt4py/next/ffront/foast_to_itir.py
index b030eaff..2811be1e 100644
--- a/src/gt4py/next/ffront/foast_to_itir.py
+++ b/src/gt4py/next/ffront/foast_to_itir.py
@@ -19,11 +19,10 @@ from gt4py.next.ffront import (
     dialect_ast_enums,
     fbuiltins,
     field_operator_ast as foast,
-    itir_makers as im,
     type_specifications as ts_ffront,
 )
 from gt4py.next.ffront.fbuiltins import FUN_BUILTIN_NAMES, MATH_BUILTIN_NAMES, TYPE_BUILTIN_NAMES
-from gt4py.next.iterator import ir as itir
+from gt4py.next.iterator import ir as itir, ir_makers as im
 from gt4py.next.type_system import type_info, type_specifications as ts
 
 
@@ -78,7 +77,7 @@ class FieldOperatorLowering(NodeTranslator):
 
     def visit_FieldOperator(self, node: foast.FieldOperator, **kwargs) -> itir.FunctionDefinition:
         func_definition: itir.FunctionDefinition = self.visit(node.definition, **kwargs)
-        new_body = im.deref_(func_definition.expr)
+        new_body = im.deref(func_definition.expr)
 
         return itir.FunctionDefinition(
             id=func_definition.id,
@@ -93,8 +92,8 @@ class FieldOperatorLowering(NodeTranslator):
         # We are lowering node.forward and node.init to iterators, but here we expect values -> `deref`.
         # In iterator IR we didn't properly specify if this is legal,
         # however after lift-inlining the expressions are transformed back to literals.
-        forward = im.deref_(self.visit(node.forward, **kwargs))
-        init = im.deref_(self.visit(node.init, **kwargs))
+        forward = im.deref(self.visit(node.forward, **kwargs))
+        init = im.deref(self.visit(node.init, **kwargs))
 
         # lower definition function
         func_definition: itir.FunctionDefinition = self.visit(node.definition, **kwargs)
@@ -105,9 +104,9 @@ class FieldOperatorLowering(NodeTranslator):
         new_body = im.let(
             func_definition.params[0].id,
             im.promote_to_const_iterator(func_definition.params[0].id),
-        )(im.deref_(new_body))
+        )(im.deref(new_body))
         definition = itir.Lambda(params=func_definition.params, expr=new_body)
-        body = im.call_(im.call_("scan")(definition, forward, init))(
+        body = im.call(im.call("scan")(definition, forward, init))(
             *(param.id for param in definition.params[1:])
         )
 
@@ -153,12 +152,12 @@ class FieldOperatorLowering(NodeTranslator):
         return im.ref(node.id)
 
     def visit_Subscript(self, node: foast.Subscript, **kwargs) -> itir.Expr:
-        return im.promote_to_lifted_stencil(lambda tuple_: im.tuple_get_(node.index, tuple_))(
+        return im.promote_to_lifted_stencil(lambda tuple_: im.tuple_get(node.index, tuple_))(
             self.visit(node.value, **kwargs)
         )
 
     def visit_TupleExpr(self, node: foast.TupleExpr, **kwargs) -> itir.Expr:
-        return im.promote_to_lifted_stencil(lambda *elts: im.make_tuple_(*elts))(
+        return im.promote_to_lifted_stencil(lambda *elts: im.make_tuple(*elts))(
             *[self.visit(el, **kwargs) for el in node.elts],
         )
 
@@ -188,19 +187,19 @@ class FieldOperatorLowering(NodeTranslator):
     def _visit_shift(self, node: foast.Call, **kwargs) -> itir.Expr:
         match node.args[0]:
             case foast.Subscript(value=foast.Name(id=offset_name), index=int(offset_index)):
-                shift_offset = im.shift_(offset_name, offset_index)
+                shift_offset = im.shift(offset_name, offset_index)
             case foast.Name(id=offset_name):
                 return im.lifted_neighbors(str(offset_name), self.visit(node.func, **kwargs))
             case foast.Call(func=foast.Name(id="as_offset")):
                 func_args = node.args[0]
                 offset_dim = func_args.args[0]
                 assert isinstance(offset_dim, foast.Name)
-                shift_offset = im.shift_(
-                    offset_dim.id, im.deref_(self.visit(func_args.args[1], **kwargs))
+                shift_offset = im.shift(
+                    offset_dim.id, im.deref(self.visit(func_args.args[1], **kwargs))
                 )
             case _:
                 raise FieldOperatorLoweringError("Unexpected shift arguments!")
-        return im.lift_(im.lambda__("it")(im.deref_(shift_offset("it"))))(
+        return im.lift(im.lambda_("it")(im.deref(shift_offset("it"))))(
             self.visit(node.func, **kwargs)
         )
 
@@ -225,9 +224,9 @@ class FieldOperatorLowering(NodeTranslator):
             lowered_func = self.visit(node.func, **kwargs)
             lowered_args = [self.visit(arg, **kwargs) for arg in node.args]
             args = [f"__arg{i}" for i in range(len(lowered_args))]
-            return im.lift_(im.lambda__(*args)(im.call_(lowered_func)(*args)))(*lowered_args)
+            return im.lift(im.lambda_(*args)(im.call(lowered_func)(*args)))(*lowered_args)
         elif isinstance(node.func.type, ts.FunctionType):
-            return im.call_(self.visit(node.func, **kwargs))(*self.visit(node.args, **kwargs))
+            return im.call(self.visit(node.func, **kwargs))(*self.visit(node.args, **kwargs))
 
         raise AssertionError(
             f"Call to object of type {type(node.func.type).__name__} not understood."
@@ -239,7 +238,7 @@ class FieldOperatorLowering(NodeTranslator):
 
         # TODO check that we test astype that results in a itir.map_ operation
         return self._map(
-            im.lambda__("it")(im.call_("cast_")("it", str(dtype))),
+            im.lambda_("it")(im.call("cast_")("it", str(dtype))),
             obj,
         )
 
@@ -262,7 +261,7 @@ class FieldOperatorLowering(NodeTranslator):
         # TODO(havogt): deal with nested reductions of the form neighbor_sum(neighbor_sum(field(off1)(off2)))
         it = self.visit(node.args[0], **kwargs)
         assert isinstance(node.kwargs["axis"].type, ts.DimensionType)
-        val = im.call_(im.call_("reduce")(op, im.deref_(init_expr)))
+        val = im.call(im.call("reduce")(op, im.deref(init_expr)))
         return im.promote_to_lifted_stencil(val)(it)
 
     def _visit_neighbor_sum(self, node: foast.Call, **kwargs) -> itir.FunCall:
@@ -288,9 +287,9 @@ class FieldOperatorLowering(NodeTranslator):
             source_type = {**fbuiltins.BUILTINS, "string": str}[node.args[0].type.__str__().lower()]
             if target_type is bool and source_type is not bool:
                 return im.promote_to_const_iterator(
-                    im.literal_(str(bool(source_type(node.args[0].value))), "bool")
+                    im.literal(str(bool(source_type(node.args[0].value))), "bool")
                 )
-            return im.promote_to_const_iterator(im.literal_(str(node.args[0].value), node_kind))
+            return im.promote_to_const_iterator(im.literal(str(node.args[0].value), node_kind))
         raise FieldOperatorLoweringError(f"Encountered a type cast, which is not supported: {node}")
 
     def _make_literal(self, val: Any, type_: ts.TypeSpec) -> itir.Expr:
@@ -298,16 +297,16 @@ class FieldOperatorLowering(NodeTranslator):
         # the following constructs work if they are removed by inlining.
         if isinstance(type_, ts.TupleType):
             return im.promote_to_const_iterator(
-                im.make_tuple_(
+                im.make_tuple(
                     *(
-                        im.deref_(self._make_literal(val, type_))
+                        im.deref(self._make_literal(val, type_))
                         for val, type_ in zip(val, type_.types)
                     )
                 )
             )
         elif isinstance(type_, ts.ScalarType):
             typename = type_.kind.name.lower()
-            return im.promote_to_const_iterator(im.literal_(str(val), typename))
+            return im.promote_to_const_iterator(im.literal(str(val), typename))
         raise ValueError(f"Unsupported literal type {type_}.")
 
     def visit_Constant(self, node: foast.Constant, **kwargs) -> itir.Expr:
@@ -317,9 +316,9 @@ class FieldOperatorLowering(NodeTranslator):
         lowered_args = [self.visit(arg, **kwargs) for arg in args]
         if any(type_info.contains_local_field(arg.type) for arg in args):
             lowered_args = [promote_to_list(arg)(larg) for arg, larg in zip(args, lowered_args)]
-            op = im.call_("map_")(op)
+            op = im.call("map_")(op)
 
-        return im.promote_to_lifted_stencil(im.call_(op))(*lowered_args)
+        return im.promote_to_lifted_stencil(im.call(op))(*lowered_args)
 
 
 class FieldOperatorLoweringError(Exception):
diff --git a/src/gt4py/next/ffront/itir_makers.py b/src/gt4py/next/iterator/ir_makers.py
similarity index 77%
rename from src/gt4py/next/ffront/itir_makers.py
rename to src/gt4py/next/iterator/ir_makers.py
index f9f8cbd2..c7dfe9d0 100644
--- a/src/gt4py/next/ffront/itir_makers.py
+++ b/src/gt4py/next/iterator/ir_makers.py
@@ -92,13 +92,13 @@ def ensure_offset(str_or_offset: Union[str, int, itir.OffsetLiteral]) -> itir.Of
     return str_or_offset
 
 
-class lambda__:
+class lambda_:
     """
     Create a lambda from params and an expression.
 
     Examples
     --------
-    >>> lambda__("a")(deref_("a"))  # doctest: +ELLIPSIS
+    >>> lambda_("a")(deref("a"))  # doctest: +ELLIPSIS
     Lambda(params=[Sym(id=SymbolName('a'), kind=None, dtype=None)], expr=FunCall(fun=SymRef(id=SymbolRef('deref')), args=[SymRef(id=SymbolRef('a'))]))
     """
 
@@ -109,13 +109,13 @@ class lambda__:
         return itir.Lambda(params=[sym(arg) for arg in self.args], expr=ensure_expr(expr))
 
 
-class call_:
+class call:
     """
     Create a FunCall from an expression and arguments.
 
     Examples
     --------
-    >>> call_("plus")(1, 1)
+    >>> call("plus")(1, 1)
     FunCall(fun=SymRef(id=SymbolRef('plus')), args=[Literal(value='1', type='int'), Literal(value='1', type='int')])
     """
 
@@ -126,111 +126,111 @@ class call_:
         return itir.FunCall(fun=self.fun, args=[ensure_expr(expr) for expr in exprs])
 
 
-def deref_(expr):
+def deref(expr):
     """Create a deref FunCall, shorthand for ``call("deref")(expr)``."""
-    return call_("deref")(expr)
+    return call("deref")(expr)
 
 
-def plus_(left, right):
+def plus(left, right):
     """Create a plus FunCall, shorthand for ``call("plus")(left, right)``."""
-    return call_("plus")(left, right)
+    return call("plus")(left, right)
 
 
-def minus_(left, right):
+def minus(left, right):
     """Create a minus FunCall, shorthand for ``call("minus")(left, right)``."""
-    return call_("minus")(left, right)
+    return call("minus")(left, right)
 
 
 def multiplies_(left, right):
     """Create a multiplies FunCall, shorthand for ``call("multiplies")(left, right)``."""
-    return call_("multiplies")(left, right)
+    return call("multiplies")(left, right)
 
 
 def divides_(left, right):
     """Create a divides FunCall, shorthand for ``call("divides")(left, right)``."""
-    return call_("divides")(left, right)
+    return call("divides")(left, right)
 
 
 def floordiv_(left, right):
     """Create a floor division FunCall, shorthand for ``call("floordiv")(left, right)``."""
     # TODO(tehrengruber): Use int(floor(left/right)) as soon as we support integer casting
     #  and remove the `floordiv` builtin again.
-    return call_("floordiv")(left, right)
+    return call("floordiv")(left, right)
 
 
-def mod_(left, right):
+def mod(left, right):
     """Create a modulo FunCall, shorthand for ``call("mod")(left, right)``."""
-    return call_("mod")(left, right)
+    return call("mod")(left, right)
 
 
-def and__(left, right):
+def and_(left, right):
     """Create an and_ FunCall, shorthand for ``call("and_")(left, right)``."""
-    return call_("and_")(left, right)
+    return call("and_")(left, right)
 
 
-def or__(left, right):
+def or_(left, right):
     """Create an or_ FunCall, shorthand for ``call("or_")(left, right)``."""
-    return call_("or_")(left, right)
+    return call("or_")(left, right)
 
 
-def xor__(left, right):
+def xor_(left, right):
     """Create an xor_ FunCall, shorthand for ``call("xor_")(left, right)``."""
-    return call_("xor_")(left, right)
+    return call("xor_")(left, right)
 
 
-def greater_(left, right):
+def greater(left, right):
     """Create a greater FunCall, shorthand for ``call("greater")(left, right)``."""
-    return call_("greater")(left, right)
+    return call("greater")(left, right)
 
 
-def less_(left, right):
+def less(left, right):
     """Create a less FunCall, shorthand for ``call("less")(left, right)``."""
-    return call_("less")(left, right)
+    return call("less")(left, right)
 
 
-def less_equal_(left, right):
+def less_equal(left, right):
     """Create a less_equal FunCall, shorthand for ``call("less_equal")(left, right)``."""
-    return call_("less_equal")(left, right)
+    return call("less_equal")(left, right)
 
 
-def greater_equal_(left, right):
-    """Create a greater_equal_ FunCall, shorthand for ``call("greater_equal")(left, right)``."""
-    return call_("greater_equal")(left, right)
+def greater_equal(left, right):
+    """Create a greater_equal FunCall, shorthand for ``call("greater_equal")(left, right)``."""
+    return call("greater_equal")(left, right)
 
 
-def not_eq_(left, right):
-    """Create a not_eq_ FunCall, shorthand for ``call("not_eq_")(left, right)``."""
-    return call_("not_eq_")(left, right)
+def not_eq(left, right):
+    """Create a not_eq FunCall, shorthand for ``call("not_eq")(left, right)``."""
+    return call("not_eq")(left, right)
 
 
-def eq_(left, right):
+def eq(left, right):
     """Create a eq FunCall, shorthand for ``call("eq")(left, right)``."""
-    return call_("eq")(left, right)
+    return call("eq")(left, right)
 
 
-def not__(expr):
+def not_(expr):
     """Create a not_ FunCall, shorthand for ``call("not_")(expr)``."""
-    return call_("not_")(expr)
+    return call("not_")(expr)
 
 
-def make_tuple_(*args):
+def make_tuple(*args):
     """Create a make_tuple FunCall, shorthand for ``call("make_tuple")(*args)``."""
-    return call_("make_tuple")(*args)
+    return call("make_tuple")(*args)
 
 
-def tuple_get_(tuple_expr, index):
+def tuple_get(tuple_expr, index):
     """Create a tuple_get FunCall, shorthand for ``call("tuple_get")(tuple_expr, index)``."""
-    return call_("tuple_get")(tuple_expr, index)
+    return call("tuple_get")(tuple_expr, index)
 
 
 def if_(cond, true_val, false_val):
     """Create a not_ FunCall, shorthand for ``call("if_")(expr)``."""
-    return call_("if_")(cond, true_val, false_val)
+    return call("if_")(cond, true_val, false_val)
 
 
-def lift_(expr):
+def lift(expr):
     """Create a lift FunCall, shorthand for ``call(call("lift")(expr))``."""
-    return call_(call_("lift")(expr))
+    return call(call("lift")(expr))
 
 
 class let:
@@ -248,19 +248,19 @@ class let:
         self.init_form = init_form
 
     def __call__(self, form):
-        return call_(lambda__(self.var)(form))(self.init_form)
+        return call(lambda_(self.var)(form))(self.init_form)
 
 
-def shift_(offset, value=None):
+def shift(offset, value=None):
     """
     Create a shift call.
 
     Examples
     --------
-    >>> shift_("i", 0)("a")
+    >>> shift("i", 0)("a")
     FunCall(fun=FunCall(fun=SymRef(id=SymbolRef('shift')), args=[OffsetLiteral(value='i'), OffsetLiteral(value=0)]), args=[SymRef(id=SymbolRef('a'))])
 
-    >>> shift_("V2E")("b")
+    >>> shift("V2E")("b")
     FunCall(fun=FunCall(fun=SymRef(id=SymbolRef('shift')), args=[OffsetLiteral(value='V2E')]), args=[SymRef(id=SymbolRef('b'))])
     """
     offset = ensure_offset(offset)
@@ -268,16 +268,16 @@ def shift_(offset, value=None):
     if value is not None:
         value = ensure_offset(value)
         args.append(value)
-    return call_(call_("shift")(*args))
+    return call(call("shift")(*args))
 
 
-def literal_(value: str, typename: str):
+def literal(value: str, typename: str):
     return itir.Literal(value=value, type=typename)
 
 
-def neighbors_(offset, it):
+def neighbors(offset, it):
     offset = ensure_offset(offset)
-    return call_("neighbors")(offset, it)
+    return call("neighbors")(offset, it)
 
 
 def lifted_neighbors(offset, it) -> itir.Expr:
@@ -289,7 +289,7 @@ def lifted_neighbors(offset, it) -> itir.Expr:
     >>> str(lifted_neighbors("off", "a"))
     '(↑(λ(it) → neighbors(offₒ, it)))(a)'
     """
-    return lift_(lambda__("it")(neighbors_(offset, "it")))(it)
+    return lift(lambda_("it")(neighbors(offset, "it")))(it)
 
 
 def promote_to_const_iterator(expr: str | itir.Expr) -> itir.Expr:
@@ -301,7 +301,7 @@ def promote_to_const_iterator(expr: str | itir.Expr) -> itir.Expr:
     >>> str(promote_to_const_iterator("foo"))
     '(↑(λ() → foo))()'
     """
-    return lift_(lambda__()(expr))()
+    return lift(lambda_()(expr))()
 
 
 def promote_to_lifted_stencil(op: str | itir.SymRef | Callable) -> Callable[..., itir.Expr]:
@@ -319,17 +319,17 @@ def promote_to_lifted_stencil(op: str | itir.SymRef | Callable) -> Callable[...,
     '(↑(λ(__arg0, __arg1) → op(·__arg0, ·__arg1)))(a, b)'
     """
     if isinstance(op, (str, itir.SymRef)):
-        op = call_(op)
+        op = call(op)
 
     def _impl(*its: itir.Expr) -> itir.Expr:
         args = [
             f"__arg{i}" for i in range(len(its))
         ]  # TODO: `op` must not contain `SymRef(id="__argX")`
-        return lift_(lambda__(*args)(op(*[deref_(arg) for arg in args])))(*its)  # type: ignore[operator] # `op` is not `str`
+        return lift(lambda_(*args)(op(*[deref(arg) for arg in args])))(*its)  # type: ignore[operator] # `op` is not `str`
 
     return _impl
 
 
-def map__(op):
+def map_(op):
     """Create a `map_` call."""
-    return call_(call_("map_")(op))
+    return call(call("map_")(op))
diff --git a/src/gt4py/next/iterator/transforms/cse.py b/src/gt4py/next/iterator/transforms/cse.py
index ad3fa219..fde6f902 100644
--- a/src/gt4py/next/iterator/transforms/cse.py
+++ b/src/gt4py/next/iterator/transforms/cse.py
@@ -126,8 +126,8 @@ class CommonSubexpressionElimination(NodeTranslator):
 
     Examples:
         >>> x = ir.SymRef(id="x")
-        >>> plus_ = lambda a, b: ir.FunCall(fun=ir.SymRef(id=("plus")), args=[a, b])
-        >>> expr = plus_(plus_(x, x), plus_(x, x))
+        >>> plus = lambda a, b: ir.FunCall(fun=ir.SymRef(id=("plus")), args=[a, b])
+        >>> expr = plus(plus(x, x), plus(x, x))
         >>> print(CommonSubexpressionElimination().visit(expr))
         (λ(_cs_1) → _cs_1 + _cs_1)(x + x)
     """
diff --git a/src/gt4py/next/iterator/transforms/inline_lifts.py b/src/gt4py/next/iterator/transforms/inline_lifts.py
index 5b17ca3f..aafb5ab2 100644
--- a/src/gt4py/next/iterator/transforms/inline_lifts.py
+++ b/src/gt4py/next/iterator/transforms/inline_lifts.py
@@ -18,8 +18,7 @@ from typing import Optional
 
 import gt4py.eve as eve
 from gt4py.eve import NodeTranslator, traits
-from gt4py.next.ffront import itir_makers as im
-from gt4py.next.iterator import ir
+from gt4py.next.iterator import ir, ir_makers as im
 from gt4py.next.iterator.transforms.inline_lambdas import inline_lambda
 
 
@@ -102,7 +101,7 @@ def _transform_and_extract_lift_args(
             extracted_args[new_symbol] = arg
             new_args.append(ir.SymRef(id=new_symbol.id))
 
-    return (im.lift_(inner_stencil)(*new_args), extracted_args)
+    return (im.lift(inner_stencil)(*new_args), extracted_args)
 
 
 @dataclasses.dataclass
@@ -228,7 +227,7 @@ class InlineLifts(traits.VisitorWithSymbolTableTrait, NodeTranslator):
                     **kwargs,
                 )
 
-                new_stencil = im.lambda__(*new_arg_exprs.keys())(inlined_call)
-                return im.lift_(new_stencil)(*new_arg_exprs.values())
+                new_stencil = im.lambda_(*new_arg_exprs.keys())(inlined_call)
+                return im.lift(new_stencil)(*new_arg_exprs.values())
 
         return node


Test patch:
diff --git a/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_execution.py b/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_execution.py
index 75a784b7..d4a297f5 100644
--- a/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_execution.py
+++ b/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_execution.py
@@ -232,7 +232,7 @@ def test_nested_scalar_arg(fieldview_backend):
 
 def test_scalar_arg_with_field(fieldview_backend):
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip("IndexFields and ConstantFields are not supported yet.")
+        pytest.xfail("IndexFields and ConstantFields are not supported yet.")
 
     inp = index_field(Edge, dtype=float64)
     factor = 3.0
@@ -257,7 +257,7 @@ def test_scalar_arg_with_field(fieldview_backend):
 
 def test_scalar_in_domain_spec_and_fo_call(fieldview_backend):
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip(
+        pytest.xfail(
             "Scalar arguments not supported to be used in both domain specification "
             "and as an argument to a field operator."
         )
@@ -300,7 +300,7 @@ def test_scalar_scan(fieldview_backend):
 
 def test_tuple_scalar_scan(fieldview_backend):
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip("Scalar tuple arguments are not supported in gtfn yet.")
+        pytest.xfail("Scalar tuple arguments are not supported in gtfn yet.")
 
     size = 10
     KDim = Dimension("K", kind=DimensionKind.VERTICAL)
@@ -453,7 +453,7 @@ def test_nested_reduction(reduction_setup, fieldview_backend):
     assert np.allclose(out, expected)
 
 
-@pytest.mark.skip("Not yet supported in lowering, requires `map_`ing of inner reduce op.")
+@pytest.mark.xfail(reason="Not yet supported in lowering, requires `map_`ing of inner reduce op.")
 def test_nested_reduction_shift_first(reduction_setup, fieldview_backend):
     rs = reduction_setup
     V2EDim = rs.V2EDim
@@ -575,7 +575,7 @@ def test_fieldop_from_scan(fieldview_backend, forward):
 
 def test_solve_triag(fieldview_backend):
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip("Has a bug.")
+        pytest.xfail("Transformation passes fail in putting `scan` to the top.")
     shape = (3, 7, 5)
     rng = np.random.default_rng()
     a_np, b_np, c_np, d_np = (rng.normal(size=shape) for _ in range(4))
@@ -796,7 +796,7 @@ def test_domain(fieldview_backend):
 
 def test_domain_input_bounds(fieldview_backend):
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip("FloorDiv not fully supported in gtfn.")
+        pytest.xfail("FloorDiv not fully supported in gtfn.")
     inp = np_as_located_field(IDim, JDim)(np.ones((size, size), dtype=float64))
     out = np_as_located_field(IDim, JDim)(2 * np.ones((size, size), dtype=float64))
 
@@ -900,7 +900,7 @@ def test_domain_tuple(fieldview_backend):
 
 def test_where_k_offset(fieldview_backend):
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip("IndexFields are not supported yet.")
+        pytest.xfail("IndexFields are not supported yet.")
     a = np_as_located_field(IDim, KDim)(np.ones((size, size)))
     out = np_as_located_field(IDim, KDim)(np.zeros((size, size)))
     k_index = index_field(KDim)
diff --git a/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_gt4py_builtins.py b/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_gt4py_builtins.py
index e3cc8dfe..5dd72a73 100644
--- a/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_gt4py_builtins.py
+++ b/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_gt4py_builtins.py
@@ -154,8 +154,6 @@ def test_reduction_expression(reduction_setup, fieldview_backend):
 
 
 def test_conditional_nested_tuple(fieldview_backend):
-    if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip("Tuple outputs not supported in gtfn backends")
     a_I_float = np_as_located_field(IDim)(np.random.randn(size).astype("float64"))
     b_I_float = np_as_located_field(IDim)(np.random.randn(size).astype("float64"))
     out_I_float = np_as_located_field(IDim)(np.random.randn(size).astype("float64"))
diff --git a/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_math_unary_builtins.py b/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_math_unary_builtins.py
index 42fecc0a..c82c3f4f 100644
--- a/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_math_unary_builtins.py
+++ b/tests/next_tests/integration_tests/feature_tests/ffront_tests/test_math_unary_builtins.py
@@ -76,7 +76,7 @@ def test_floordiv(fieldview_backend):
     out_I_int = np_as_located_field(IDim)(np.zeros((size,), dtype=int64))
 
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip(
+        pytest.xfail(
             "FloorDiv not yet supported."
         )  # see https://github.com/GridTools/gt4py/issues/1136
 
@@ -93,7 +93,7 @@ def test_mod(fieldview_backend):
     out_I_int = np_as_located_field(IDim)(np.zeros((size,), dtype=int64))
 
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip(
+        pytest.xfail(
             "Modulo not properly supported for negative numbers."
         )  # see https://github.com/GridTools/gt4py/issues/1219
 
diff --git a/tests/next_tests/integration_tests/feature_tests/iterator_tests/test_strided_offset_provider.py b/tests/next_tests/integration_tests/feature_tests/iterator_tests/test_strided_offset_provider.py
index 98d042a1..1248b552 100644
--- a/tests/next_tests/integration_tests/feature_tests/iterator_tests/test_strided_offset_provider.py
+++ b/tests/next_tests/integration_tests/feature_tests/iterator_tests/test_strided_offset_provider.py
@@ -19,12 +19,9 @@ from gt4py.next.common import Dimension
 from gt4py.next.iterator.builtins import deref, lift, named_range, shift, unstructured_domain
 from gt4py.next.iterator.embedded import StridedNeighborOffsetProvider, np_as_located_field
 from gt4py.next.iterator.runtime import closure, fendef, fundef, offset
+from gt4py.next.program_processors.runners.gtfn_cpu import run_gtfn, run_gtfn_imperative
 
-from next_tests.unit_tests.conftest import (
-    program_processor,
-    program_processor_no_gtfn_exec,
-    run_processor,
-)
+from next_tests.unit_tests.conftest import program_processor, run_processor
 
 
 LocA = Dimension("LocA")
@@ -52,8 +49,10 @@ def fencil(size, out, inp):
     )
 
 
-def test_strided_offset_provider(program_processor_no_gtfn_exec):
-    program_processor, validate = program_processor_no_gtfn_exec
+def test_strided_offset_provider(program_processor):
+    program_processor, validate = program_processor
+    if program_processor in [run_gtfn, run_gtfn_imperative]:
+        pytest.xfail("StridedNeighborOffsetProvider not implemented in bindings.")
 
     LocA_size = 2
     max_neighbors = LocA2LocAB_offset_provider.max_neighbors
diff --git a/tests/next_tests/integration_tests/feature_tests/iterator_tests/test_trivial.py b/tests/next_tests/integration_tests/feature_tests/iterator_tests/test_trivial.py
index 68918e28..b1968111 100644
--- a/tests/next_tests/integration_tests/feature_tests/iterator_tests/test_trivial.py
+++ b/tests/next_tests/integration_tests/feature_tests/iterator_tests/test_trivial.py
@@ -129,8 +129,6 @@ def fen_direct_deref(i_size, j_size, out, inp):
 
 def test_direct_deref(program_processor, lift_mode):
     program_processor, validate = program_processor
-    if program_processor == run_gtfn:
-        pytest.xfail("extract_fundefs_from_closures() doesn't work for builtins in gtfn")
 
     rng = np.random.default_rng()
     inp = rng.uniform(size=(5, 7))
diff --git a/tests/next_tests/integration_tests/multi_feature_tests/iterator_tests/test_with_toy_connectivity.py b/tests/next_tests/integration_tests/multi_feature_tests/iterator_tests/test_with_toy_connectivity.py
index d240d83f..b895da21 100644
--- a/tests/next_tests/integration_tests/multi_feature_tests/iterator_tests/test_with_toy_connectivity.py
+++ b/tests/next_tests/integration_tests/multi_feature_tests/iterator_tests/test_with_toy_connectivity.py
@@ -188,8 +188,7 @@ def sparse_stencil(non_sparse, inp):
 
 def test_sparse_input_field(program_processor, lift_mode):
     program_processor, validate = program_processor
-    if program_processor == type_check.check:
-        pytest.xfail("Partial shifts not properly supported by type inference.")
+
     non_sparse = np_as_located_field(Edge)(np.zeros(18))
     inp = np_as_located_field(Vertex, V2E)(np.asarray([[1, 2, 3, 4]] * 9))
     out = np_as_located_field(Vertex)(np.zeros([9]))
@@ -212,8 +211,6 @@ def test_sparse_input_field(program_processor, lift_mode):
 
 def test_sparse_input_field_v2v(program_processor, lift_mode):
     program_processor, validate = program_processor
-    if program_processor == type_check.check:
-        pytest.xfail("Partial shifts not properly supported by type inference.")
 
     non_sparse = np_as_located_field(Edge)(np.zeros(18))
     inp = np_as_located_field(Vertex, V2V)(v2v_arr)
diff --git a/tests/next_tests/unit_tests/ffront_tests/test_foast_to_itir.py b/tests/next_tests/unit_tests/ffront_tests/test_foast_to_itir.py
index bbb9daaa..f0b437ab 100644
--- a/tests/next_tests/unit_tests/ffront_tests/test_foast_to_itir.py
+++ b/tests/next_tests/unit_tests/ffront_tests/test_foast_to_itir.py
@@ -24,7 +24,7 @@ from types import SimpleNamespace
 import pytest
 
 from gt4py.next.common import DimensionKind, Field
-from gt4py.next.ffront import itir_makers as im, type_specifications as ts_ffront
+from gt4py.next.ffront import type_specifications as ts_ffront
 from gt4py.next.ffront.fbuiltins import (
     Dimension,
     FieldOffset,
@@ -36,7 +36,7 @@ from gt4py.next.ffront.fbuiltins import (
 )
 from gt4py.next.ffront.foast_to_itir import FieldOperatorLowering
 from gt4py.next.ffront.func_to_foast import FieldOperatorParser
-from gt4py.next.iterator import ir as itir
+from gt4py.next.iterator import ir as itir, ir_makers as im
 from gt4py.next.type_system import type_specifications as ts, type_translation
 
 
@@ -117,7 +117,7 @@ def test_shift():
     parsed = FieldOperatorParser.apply_to_function(shift_by_one)
     lowered = FieldOperatorLowering.apply(parsed)
 
-    reference = im.lift_(im.lambda__("it")(im.deref_(im.shift_("Ioff", 1)("it"))))("inp")
+    reference = im.lift(im.lambda_("it")(im.deref(im.shift("Ioff", 1)("it"))))("inp")
 
     assert lowered.expr == reference
 
@@ -131,7 +131,7 @@ def test_negative_shift():
     parsed = FieldOperatorParser.apply_to_function(shift_by_one)
     lowered = FieldOperatorLowering.apply(parsed)
 
-    reference = im.lift_(im.lambda__("it")(im.deref_(im.shift_("Ioff", -1)("it"))))("inp")
+    reference = im.lift(im.lambda_("it")(im.deref(im.shift("Ioff", -1)("it"))))("inp")
 
     assert lowered.expr == reference
 
@@ -169,13 +169,13 @@ def test_unary_ops():
     reference = im.let(
         itir.Sym(id="tmp__0", dtype=("float64", False), kind="Iterator"),
         im.promote_to_lifted_stencil("plus")(
-            im.promote_to_const_iterator(im.literal_("0", "float64")), "inp"
+            im.promote_to_const_iterator(im.literal("0", "float64")), "inp"
         ),
     )(
         im.let(
             itir.Sym(id="tmp__1", dtype=("float64", False), kind="Iterator"),
             im.promote_to_lifted_stencil("minus")(
-                im.promote_to_const_iterator(im.literal_("0", "float64")), "tmp__0"
+                im.promote_to_const_iterator(im.literal("0", "float64")), "tmp__0"
             ),
         )("tmp__1")
     )
@@ -196,8 +196,8 @@ def test_unpacking():
     lowered = FieldOperatorLowering.apply(parsed)
 
     tuple_expr = im.promote_to_lifted_stencil("make_tuple")("inp1", "inp2")
-    tuple_access_0 = im.promote_to_lifted_stencil(lambda x: im.tuple_get_(0, x))("__tuple_tmp_0")
-    tuple_access_1 = im.promote_to_lifted_stencil(lambda x: im.tuple_get_(1, x))("__tuple_tmp_0")
+    tuple_access_0 = im.promote_to_lifted_stencil(lambda x: im.tuple_get(0, x))("__tuple_tmp_0")
+    tuple_access_1 = im.promote_to_lifted_stencil(lambda x: im.tuple_get(1, x))("__tuple_tmp_0")
 
     reference = im.let("__tuple_tmp_0", tuple_expr)(
         im.let(itir.Sym(id="tmp1__0", dtype=("float64", False), kind="Iterator"), tuple_access_0)(
@@ -211,7 +211,7 @@ def test_unpacking():
 
 
 def test_annotated_assignment():
-    pytest.skip("Annotated assignments are not properly supported at the moment.")
+    pytest.xfail("Annotated assignments are not properly supported at the moment.")
 
     def copy_field(inp: Field[[TDim], float64]):
         tmp: Field[[TDim], float64] = inp
@@ -242,7 +242,7 @@ def test_call():
     parsed = FieldOperatorParser.apply_to_function(call)
     lowered = FieldOperatorLowering.apply(parsed)
 
-    reference = im.lift_(im.lambda__("__arg0")(im.call_("identity")("__arg0")))("inp")
+    reference = im.lift(im.lambda_("__arg0")(im.call("identity")("__arg0")))("inp")
 
     assert lowered.expr == reference
 
@@ -295,7 +295,7 @@ def test_add_scalar_literal_to_field():
     lowered = FieldOperatorLowering.apply(parsed)
 
     reference = im.promote_to_lifted_stencil("plus")(
-        im.promote_to_const_iterator(im.literal_("2.0", "float64")), "a"
+        im.promote_to_const_iterator(im.literal("2.0", "float64")), "a"
     )
 
     assert lowered.expr == reference
@@ -312,8 +312,8 @@ def test_add_scalar_literals():
     reference = im.let(
         "tmp__0",
         im.promote_to_lifted_stencil("plus")(
-            im.promote_to_const_iterator(im.literal_("1", "int32")),
-            im.promote_to_const_iterator(im.literal_("1", "int32")),
+            im.promote_to_const_iterator(im.literal("1", "int32")),
+            im.promote_to_const_iterator(im.literal("1", "int32")),
         ),
     )(im.promote_to_lifted_stencil("plus")("a", "tmp__0"))
 
@@ -376,7 +376,7 @@ def test_scalar_and():
     lowered = FieldOperatorLowering.apply(parsed)
 
     reference = im.promote_to_lifted_stencil("and_")(
-        "a", im.promote_to_const_iterator(im.literal_("False", "bool"))
+        "a", im.promote_to_const_iterator(im.literal("False", "bool"))
     )
 
     assert lowered.expr == reference
@@ -402,8 +402,8 @@ def test_compare_scalars():
     lowered = FieldOperatorLowering.apply(parsed)
 
     reference = im.promote_to_lifted_stencil("greater")(
-        im.promote_to_const_iterator(im.literal_("3", "int64")),
-        im.promote_to_const_iterator(im.literal_("4", "int64")),
+        im.promote_to_const_iterator(im.literal("3", "int64")),
+        im.promote_to_const_iterator(im.literal("4", "int64")),
     )
 
     assert lowered.expr == reference
@@ -470,10 +470,10 @@ def test_reduction_lowering_simple():
     lowered = FieldOperatorLowering.apply(parsed)
 
     reference = im.promote_to_lifted_stencil(
-        im.call_(
-            im.call_("reduce")(
+        im.call(
+            im.call("reduce")(
                 "plus",
-                im.deref_(im.promote_to_const_iterator(im.literal_(value="0", typename="float64"))),
+                im.deref(im.promote_to_const_iterator(im.literal(value="0", typename="float64"))),
             ),
         )
     )(
@@ -491,11 +491,11 @@ def test_reduction_lowering_expr():
     parsed = FieldOperatorParser.apply_to_function(reduction)
     lowered = FieldOperatorLowering.apply(parsed)
 
-    mapped = im.promote_to_lifted_stencil(im.map__("multiplies"))(
+    mapped = im.promote_to_lifted_stencil(im.map_("multiplies"))(
         im.promote_to_lifted_stencil("make_const_list")(
-            im.promote_to_const_iterator(im.literal_("1.1", "float64"))
+            im.promote_to_const_iterator(im.literal("1.1", "float64"))
         ),
-        im.promote_to_lifted_stencil(im.map__("plus"))("e1_nbh__0", "e2"),
+        im.promote_to_lifted_stencil(im.map_("plus"))("e1_nbh__0", "e2"),
     )
 
     reference = im.let(
@@ -503,11 +503,11 @@ def test_reduction_lowering_expr():
         im.lifted_neighbors("V2E", "e1"),
     )(
         im.promote_to_lifted_stencil(
-            im.call_(
-                im.call_("reduce")(
+            im.call(
+                im.call("reduce")(
                     "plus",
-                    im.deref_(
-                        im.promote_to_const_iterator(im.literal_(value="0", typename="float64"))
+                    im.deref(
+                        im.promote_to_const_iterator(im.literal(value="0", typename="float64"))
                     ),
                 ),
             )
@@ -537,13 +537,13 @@ def test_builtin_int_constructors():
     lowered = FieldOperatorLowering.apply(parsed)
 
     reference = im.promote_to_lifted_stencil("make_tuple")(
-        im.promote_to_const_iterator(im.literal_("1", "int64")),
-        im.promote_to_const_iterator(im.literal_("1", "int64")),
-        im.promote_to_const_iterator(im.literal_("1", "int32")),
-        im.promote_to_const_iterator(im.literal_("1", "int64")),
-        im.promote_to_const_iterator(im.literal_("1", "int64")),
-        im.promote_to_const_iterator(im.literal_("1", "int32")),
-        im.promote_to_const_iterator(im.literal_("1", "int64")),
+        im.promote_to_const_iterator(im.literal("1", "int64")),
+        im.promote_to_const_iterator(im.literal("1", "int64")),
+        im.promote_to_const_iterator(im.literal("1", "int32")),
+        im.promote_to_const_iterator(im.literal("1", "int64")),
+        im.promote_to_const_iterator(im.literal("1", "int64")),
+        im.promote_to_const_iterator(im.literal("1", "int32")),
+        im.promote_to_const_iterator(im.literal("1", "int64")),
     )
 
     assert lowered.expr == reference
@@ -575,13 +575,13 @@ def test_builtin_float_constructors():
     lowered = FieldOperatorLowering.apply(parsed)
 
     reference = im.promote_to_lifted_stencil("make_tuple")(
-        im.promote_to_const_iterator(im.literal_("0.1", "float64")),
-        im.promote_to_const_iterator(im.literal_("0.1", "float64")),
-        im.promote_to_const_iterator(im.literal_("0.1", "float32")),
-        im.promote_to_const_iterator(im.literal_("0.1", "float64")),
-        im.promote_to_const_iterator(im.literal_(".1", "float64")),
-        im.promote_to_const_iterator(im.literal_(".1", "float32")),
-        im.promote_to_const_iterator(im.literal_(".1", "float64")),
+        im.promote_to_const_iterator(im.literal("0.1", "float64")),
+        im.promote_to_const_iterator(im.literal("0.1", "float64")),
+        im.promote_to_const_iterator(im.literal("0.1", "float32")),
+        im.promote_to_const_iterator(im.literal("0.1", "float64")),
+        im.promote_to_const_iterator(im.literal(".1", "float64")),
+        im.promote_to_const_iterator(im.literal(".1", "float32")),
+        im.promote_to_const_iterator(im.literal(".1", "float64")),
     )
 
     assert lowered.expr == reference
@@ -595,14 +595,14 @@ def test_builtin_bool_constructors():
     lowered = FieldOperatorLowering.apply(parsed)
 
     reference = im.promote_to_lifted_stencil("make_tuple")(
-        im.promote_to_const_iterator(im.literal_(str(True), "bool")),
-        im.promote_to_const_iterator(im.literal_(str(False), "bool")),
-        im.promote_to_const_iterator(im.literal_(str(True), "bool")),
-        im.promote_to_const_iterator(im.literal_(str(False), "bool")),
-        im.promote_to_const_iterator(im.literal_(str(bool(0)), "bool")),
-        im.promote_to_const_iterator(im.literal_(str(bool(5)), "bool")),
-        im.promote_to_const_iterator(im.literal_(str(bool("True")), "bool")),
-        im.promote_to_const_iterator(im.literal_(str(bool("False")), "bool")),
+        im.promote_to_const_iterator(im.literal(str(True), "bool")),
+        im.promote_to_const_iterator(im.literal(str(False), "bool")),
+        im.promote_to_const_iterator(im.literal(str(True), "bool")),
+        im.promote_to_const_iterator(im.literal(str(False), "bool")),
+        im.promote_to_const_iterator(im.literal(str(bool(0)), "bool")),
+        im.promote_to_const_iterator(im.literal(str(bool(5)), "bool")),
+        im.promote_to_const_iterator(im.literal(str(bool("True")), "bool")),
+        im.promote_to_const_iterator(im.literal(str(bool("False")), "bool")),
     )
 
     assert lowered.expr == reference
diff --git a/tests/next_tests/unit_tests/ffront_tests/test_icon_like_scan.py b/tests/next_tests/unit_tests/ffront_tests/test_icon_like_scan.py
index 8943c7f4..1daf0083 100644
--- a/tests/next_tests/unit_tests/ffront_tests/test_icon_like_scan.py
+++ b/tests/next_tests/unit_tests/ffront_tests/test_icon_like_scan.py
@@ -214,9 +214,9 @@ def test_setup():
 
 def test_solve_nonhydro_stencil_52_like_z_q(test_setup, fieldview_backend):
     if fieldview_backend in [gtfn_cpu.run_gtfn, gtfn_cpu.run_gtfn_imperative]:
-        pytest.skip("Needs implementation of scan projector.")
+        pytest.xfail("Needs implementation of scan projector.")
     if fieldview_backend == roundtrip.executor:
-        pytest.skip("Inline into scan breaks embedded execution.")
+        pytest.xfail("Inline into scan breaks embedded execution.")
 
     solve_nonhydro_stencil_52_like_z_q.with_backend(fieldview_backend)(
         test_setup.z_alpha,
@@ -232,7 +232,7 @@ def test_solve_nonhydro_stencil_52_like_z_q(test_setup, fieldview_backend):
 
 def test_solve_nonhydro_stencil_52_like_z_q_tup(test_setup, fieldview_backend):
     if fieldview_backend == roundtrip.executor:
-        pytest.skip(
+        pytest.xfail(
             "Inline into scan breaks embedded execution and relies on CollapseTuple ignore_tuple_size==True."
         )
 
@@ -250,7 +250,7 @@ def test_solve_nonhydro_stencil_52_like_z_q_tup(test_setup, fieldview_backend):
 
 def test_solve_nonhydro_stencil_52_like(test_setup, fieldview_backend):
     if fieldview_backend == roundtrip.executor:
-        pytest.skip("Inline into scan breaks embedded execution.")
+        pytest.xfail("Inline into scan breaks embedded execution.")
 
     solve_nonhydro_stencil_52_like.with_backend(fieldview_backend)(
         test_setup.z_alpha,
@@ -267,7 +267,7 @@ def test_solve_nonhydro_stencil_52_like(test_setup, fieldview_backend):
 
 def test_solve_nonhydro_stencil_52_like_with_gtfn_tuple_merge(test_setup, fieldview_backend):
     if fieldview_backend == roundtrip.executor:
-        pytest.skip("Only working in gtfn with CollapseTuple ignore_tuple_size==True.")
+        pytest.xfail("Only working in gtfn with CollapseTuple ignore_tuple_size==True.")
 
     solve_nonhydro_stencil_52_like_with_gtfn_tuple_merge.with_backend(fieldview_backend)(
         test_setup.z_alpha,
diff --git a/tests/next_tests/unit_tests/iterator_tests/test_type_inference.py b/tests/next_tests/unit_tests/iterator_tests/test_type_inference.py
index 1ef6cde8..1dde3a68 100644
--- a/tests/next_tests/unit_tests/iterator_tests/test_type_inference.py
+++ b/tests/next_tests/unit_tests/iterator_tests/test_type_inference.py
@@ -15,8 +15,7 @@
 import numpy as np
 
 from gt4py.next.common import Dimension
-from gt4py.next.ffront import itir_makers as im
-from gt4py.next.iterator import ir, type_inference as ti
+from gt4py.next.iterator import ir, ir_makers as im, type_inference as ti
 from gt4py.next.iterator.embedded import NeighborTableOffsetProvider
 from gt4py.next.iterator.runtime import CartesianAxis
 
@@ -777,9 +776,9 @@ def test_fencil_definition():
 
 def test_fencil_definition_same_closure_input():
     f1 = ir.FunctionDefinition(
-        id="f1", params=[im.sym("vertex_it")], expr=im.deref_(im.shift_("E2V")("vertex_it"))
+        id="f1", params=[im.sym("vertex_it")], expr=im.deref(im.shift("E2V")("vertex_it"))
     )
-    f2 = ir.FunctionDefinition(id="f2", params=[im.sym("vertex_it")], expr=im.deref_("vertex_it"))
+    f2 = ir.FunctionDefinition(id="f2", params=[im.sym("vertex_it")], expr=im.deref("vertex_it"))
 
     testee = ir.FencilDefinition(
         id="fencil",
@@ -787,8 +786,8 @@ def test_fencil_definition_same_closure_input():
         params=[im.sym("vertex_it"), im.sym("output_edge_it"), im.sym("output_vertex_it")],
         closures=[
             ir.StencilClosure(
-                domain=im.call_("unstructured_domain")(
-                    im.call_("named_range")(
+                domain=im.call("unstructured_domain")(
+                    im.call("named_range")(
                         ir.AxisLiteral(value="Edge"),
                         ir.Literal(value="0", type="int"),
                         ir.Literal(value="10", type="int"),
@@ -799,8 +798,8 @@ def test_fencil_definition_same_closure_input():
                 inputs=[im.ref("vertex_it")],
             ),
             ir.StencilClosure(
-                domain=im.call_("unstructured_domain")(
-                    im.call_("named_range")(
+                domain=im.call("unstructured_domain")(
+                    im.call("named_range")(
                         ir.AxisLiteral(value="Vertex"),
                         ir.Literal(value="0", type="int"),
                         ir.Literal(value="10", type="int"),
diff --git a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_cse.py b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_cse.py
index 89f21fee..afbd0c15 100644
--- a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_cse.py
+++ b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_cse.py
@@ -12,15 +12,8 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import pytest
-
-from gt4py.eve.utils import UIDs
-from gt4py.next.ffront import itir_makers as im
-from gt4py.next.iterator import ir
-from gt4py.next.iterator.transforms.cse import (
-    CollectSubexpressions,
-    CommonSubexpressionElimination as CSE,
-)
+from gt4py.next.iterator import ir, ir_makers as im
+from gt4py.next.iterator.transforms.cse import CommonSubexpressionElimination as CSE
 
 
 def test_trivial():
@@ -48,8 +41,8 @@ def test_lambda_capture():
 
 
 def test_lambda_no_capture():
-    common = im.plus_("x", "y")
-    testee = im.call_(im.lambda__("z")(im.plus_("x", "y")))(im.plus_("x", "y"))
+    common = im.plus("x", "y")
+    testee = im.call(im.lambda_("z")(im.plus("x", "y")))(im.plus("x", "y"))
     expected = im.let("_cs_1", common)("_cs_1")
     actual = CSE().visit(testee)
     assert actual == expected
@@ -57,29 +50,29 @@ def test_lambda_no_capture():
 
 def test_lambda_nested_capture():
     def common_expr():
-        return im.plus_("x", "y")
+        return im.plus("x", "y")
 
     # (λ(x, y) → x + y)(x + y, x + y)
-    testee = im.call_(im.lambda__("x", "y")(common_expr()))(common_expr(), common_expr())
+    testee = im.call(im.lambda_("x", "y")(common_expr()))(common_expr(), common_expr())
     # (λ(_cs_1) → _cs_1 + _cs_1)(x + y)
-    expected = im.let("_cs_1", common_expr())(im.plus_("_cs_1", "_cs_1"))
+    expected = im.let("_cs_1", common_expr())(im.plus("_cs_1", "_cs_1"))
     actual = CSE().visit(testee)
     assert actual == expected
 
 
 def test_lambda_nested_capture_scoped():
     def common_expr():
-        return im.plus_("x", "x")
+        return im.plus("x", "x")
 
     # λ(x) → (λ(y) → y + (x + x + (x + x)))(z)
-    testee = im.lambda__("x")(
-        im.call_(im.lambda__("y")(im.plus_("y", im.plus_(common_expr(), common_expr()))))("z")
+    testee = im.lambda_("x")(
+        im.call(im.lambda_("y")(im.plus("y", im.plus(common_expr(), common_expr()))))("z")
     )
     # λ(x) → (λ(_cs_1) → (λ(y) → y + (_cs_1 + _cs_1))(z))(x + x)
-    expected = im.lambda__("x")(
-        im.call_(
-            im.lambda__("_cs_1")(
-                im.call_(im.lambda__("y")(im.plus_("y", im.plus_("_cs_1", "_cs_1"))))("z")
+    expected = im.lambda_("x")(
+        im.call(
+            im.lambda_("_cs_1")(
+                im.call(im.lambda_("y")(im.plus("y", im.plus("_cs_1", "_cs_1"))))("z")
             )
         )(common_expr())
     )
@@ -89,29 +82,29 @@ def test_lambda_nested_capture_scoped():
 
 def test_lambda_redef():
     def common_expr():
-        return im.lambda__("a")(im.plus_("a", 1))
+        return im.lambda_("a")(im.plus("a", 1))
 
     # (λ(f1) → (λ(f2) → f1(2) + f2(3))(λ(a) → a + 1))(λ(a) → a + 1)
     testee = im.let("f1", common_expr())(
-        im.let("f2", common_expr())(im.plus_(im.call_("f1")(2), im.call_("f2")(3)))
+        im.let("f2", common_expr())(im.plus(im.call("f1")(2), im.call("f2")(3)))
     )
     # (λ(_cs_1) → _cs_1(2) + _cs_1(3))(λ(a) → a + 1)
-    expected = im.let("_cs_1", common_expr())(im.plus_(im.call_("_cs_1")(2), im.call_("_cs_1")(3)))
+    expected = im.let("_cs_1", common_expr())(im.plus(im.call("_cs_1")(2), im.call("_cs_1")(3)))
     actual = CSE().visit(testee)
     assert actual == expected
 
 
 def test_lambda_redef_same_arg():
     def common_expr():
-        return im.lambda__("a")(im.plus_("a", 1))
+        return im.lambda_("a")(im.plus("a", 1))
 
     # (λ(f1) → (λ(f2) → f1(2) + f2(2))(λ(a) → a + 1))(λ(a) → a + 1)
     testee = im.let("f1", common_expr())(
-        im.let("f2", common_expr())(im.plus_(im.call_("f1")(2), im.call_("f2")(2)))
+        im.let("f2", common_expr())(im.plus(im.call("f1")(2), im.call("f2")(2)))
     )
     # (λ(_cs_1) → (λ(_cs_2) → _cs_2 + _cs_2)(_cs_1(2)))(λ(a) → a + 1)
     expected = im.let("_cs_1", common_expr())(
-        im.let("_cs_2", im.call_("_cs_1")(2))(im.plus_("_cs_2", "_cs_2"))
+        im.let("_cs_2", im.call("_cs_1")(2))(im.plus("_cs_2", "_cs_2"))
     )
     actual = CSE().visit(testee)
     assert actual == expected
@@ -119,20 +112,20 @@ def test_lambda_redef_same_arg():
 
 def test_lambda_redef_same_arg_scope():
     def common_expr():
-        return im.lambda__("a")(im.plus_("a", im.plus_(1, 1)))
+        return im.lambda_("a")(im.plus("a", im.plus(1, 1)))
 
     # (λ(f1) → (λ(f2) → f1(2) + f2(2))(λ(a) → a + 1))(λ(a) → a + 1)
-    testee = im.plus_(
+    testee = im.plus(
         im.let("f1", common_expr())(
-            im.let("f2", common_expr())(im.plus_(im.call_("f1")(2), im.call_("f2")(2)))
+            im.let("f2", common_expr())(im.plus(im.call("f1")(2), im.call("f2")(2)))
         ),
-        im.plus_(im.plus_(1, 1), im.plus_(1, 1)),
+        im.plus(im.plus(1, 1), im.plus(1, 1)),
     )
     # (λ(_cs_1) → (λ(_cs_2) → _cs_2 + _cs_2)(_cs_1(2)))(λ(a) → a + 1)
-    expected = im.let("_cs_3", im.plus_(1, 1))(
-        im.let("_cs_1", im.lambda__("a")(im.plus_("a", "_cs_3")))(
-            im.let("_cs_4", im.call_("_cs_1")(2))(
-                im.plus_(im.plus_("_cs_4", "_cs_4"), im.plus_("_cs_3", "_cs_3"))
+    expected = im.let("_cs_3", im.plus(1, 1))(
+        im.let("_cs_1", im.lambda_("a")(im.plus("a", "_cs_3")))(
+            im.let("_cs_4", im.call("_cs_1")(2))(
+                im.plus(im.plus("_cs_4", "_cs_4"), im.plus("_cs_3", "_cs_3"))
             )
         )
     )
diff --git a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_inline_lambdas.py b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_inline_lambdas.py
index bc49a6f5..b9f2ca16 100644
--- a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_inline_lambdas.py
+++ b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_inline_lambdas.py
@@ -14,36 +14,36 @@
 
 import pytest
 
-from gt4py.next.ffront import itir_makers as im
+from gt4py.next.iterator import ir_makers as im
 from gt4py.next.iterator.transforms.inline_lambdas import InlineLambdas
 
 
 test_data = [
-    ("identity1", im.call_(im.lambda__("x")("x"))("y"), im.ref("y")),
-    ("identity2", im.call_(im.lambda__("x")("x"))(im.plus_("y", "y")), im.plus_("y", "y")),
-    ("unused_param", im.call_(im.lambda__("x", "y")("x"))("x", "y"), im.ref("x")),
+    ("identity1", im.call(im.lambda_("x")("x"))("y"), im.ref("y")),
+    ("identity2", im.call(im.lambda_("x")("x"))(im.plus("y", "y")), im.plus("y", "y")),
+    ("unused_param", im.call(im.lambda_("x", "y")("x"))("x", "y"), im.ref("x")),
     (
         "composed_addition",
-        im.call_(im.lambda__("x")(im.plus_("x", "x")))(im.plus_("y", "y")),
+        im.call(im.lambda_("x")(im.plus("x", "x")))(im.plus("y", "y")),
         {
-            True: im.call_(im.lambda__("x")(im.plus_("x", "x")))(im.plus_("y", "y")),  # stays as is
-            False: im.plus_(im.plus_("y", "y"), im.plus_("y", "y")),
+            True: im.call(im.lambda_("x")(im.plus("x", "x")))(im.plus("y", "y")),  # stays as is
+            False: im.plus(im.plus("y", "y"), im.plus("y", "y")),
         },
     ),
     (
         "name_collision",
-        im.call_(im.lambda__("x")(im.plus_("x", "x")))(im.plus_("x", "y")),
+        im.call(im.lambda_("x")(im.plus("x", "x")))(im.plus("x", "y")),
         {
-            True: im.call_(im.lambda__("x")(im.plus_("x", "x")))(im.plus_("x", "y")),  # stays as is
-            False: im.plus_(im.plus_("x", "y"), im.plus_("x", "y")),
+            True: im.call(im.lambda_("x")(im.plus("x", "x")))(im.plus("x", "y")),  # stays as is
+            False: im.plus(im.plus("x", "y"), im.plus("x", "y")),
         },
     ),
     (
         "name_shadowing",
-        im.call_(
-            im.lambda__("x")(im.multiplies_(im.call_(im.lambda__("x")(im.plus_("x", 1)))(2), "x"))
-        )(im.plus_("x", "x")),
-        im.multiplies_(im.plus_(2, 1), im.plus_("x", "x")),
+        im.call(im.lambda_("x")(im.multiplies_(im.call(im.lambda_("x")(im.plus("x", 1)))(2), "x")))(
+            im.plus("x", "x")
+        ),
+        im.multiplies_(im.plus(2, 1), im.plus("x", "x")),
     ),
 ]
 
diff --git a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_inline_lifts.py b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_inline_lifts.py
index 3eb4d183..1da2b8a0 100644
--- a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_inline_lifts.py
+++ b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_inline_lifts.py
@@ -14,8 +14,7 @@
 
 import pytest
 
-from gt4py.next.ffront import itir_makers as im
-from gt4py.next.iterator import ir
+from gt4py.next.iterator import ir_makers as im
 from gt4py.next.iterator.transforms.inline_lifts import InlineLifts
 
 
@@ -24,53 +23,53 @@ def inline_lift_test_data():
         # (testee, expected)
         (
             # deref(lift(f)(args...)) -> f(args...)
-            im.deref_(im.lift_("f")("arg")),
-            im.call_("f")("arg"),
+            im.deref(im.lift("f")("arg")),
+            im.call("f")("arg"),
         ),
         (
             # deref(shift(...)(lift(f)(args...))) -> f(shift(...)(args)...)
-            im.deref_(im.shift_("I", 1)(im.lift_("f")("arg"))),
-            im.call_("f")(im.shift_("I", 1)("arg")),
+            im.deref(im.shift("I", 1)(im.lift("f")("arg"))),
+            im.call("f")(im.shift("I", 1)("arg")),
         ),
         (
             # can_deref(lift(f)(args...)) -> and(can_deref(arg[0]), and(can_deref(arg[1]), ...))
-            im.call_("can_deref")(im.lift_("f")("arg1", "arg2")),
-            im.and__(im.call_("can_deref")("arg1"), im.call_("can_deref")("arg2")),
+            im.call("can_deref")(im.lift("f")("arg1", "arg2")),
+            im.and_(im.call("can_deref")("arg1"), im.call("can_deref")("arg2")),
         ),
         (
             # can_deref(shift(...)(lift(f)(args...)) -> and(can_deref(shift(...)(arg[0])), and(can_deref(shift(...)(arg[1])), ...))
-            im.call_("can_deref")(im.shift_("I", 1)(im.lift_("f")("arg1", "arg2"))),
-            im.and__(
-                im.call_("can_deref")(im.shift_("I", 1)("arg1")),
-                im.call_("can_deref")(im.shift_("I", 1)("arg2")),
+            im.call("can_deref")(im.shift("I", 1)(im.lift("f")("arg1", "arg2"))),
+            im.and_(
+                im.call("can_deref")(im.shift("I", 1)("arg1")),
+                im.call("can_deref")(im.shift("I", 1)("arg2")),
             ),
         ),
         (
             # (↑(λ(arg1, arg2) → ·arg1 + ·arg2))((↑(λ(arg1, arg2) → ·arg1 × ·arg2))(a, b), c)
-            im.lift_(
-                im.lambda__(im.sym("arg1"), im.sym("arg2"))(
-                    im.plus_(im.deref_("arg1"), im.deref_("arg2"))
+            im.lift(
+                im.lambda_(im.sym("arg1"), im.sym("arg2"))(
+                    im.plus(im.deref("arg1"), im.deref("arg2"))
                 )
             )(
-                im.lift_(
-                    im.lambda__(im.sym("arg1"), im.sym("arg2"))(
-                        im.multiplies_(im.deref_("arg1"), im.deref_("arg2"))
+                im.lift(
+                    im.lambda_(im.sym("arg1"), im.sym("arg2"))(
+                        im.multiplies_(im.deref("arg1"), im.deref("arg2"))
                     )
                 )(im.ref("a"), im.ref("b")),
                 im.ref("c"),
             ),
             # (↑(λ(a, b, c) → ·a × ·b + ·c))(a, b, c)
-            im.lift_(
-                im.lambda__("a", "b", "c")(
-                    im.plus_(im.multiplies_(im.deref_("a"), im.deref_("b")), im.deref_("c"))
+            im.lift(
+                im.lambda_("a", "b", "c")(
+                    im.plus(im.multiplies_(im.deref("a"), im.deref("b")), im.deref("c"))
                 )
             )(im.ref("a"), im.ref("b"), im.ref("c")),
         ),
         (
             # (↑(λ(arg1, arg2) → ·arg1 + ·arg2))(arg1, (↑(λ(arg1) → ·arg1))(f()))
-            im.lift_(
-                im.lambda__(im.sym("arg1"), im.sym("arg2"))(
-                    im.plus_(im.deref_("arg1"), im.deref_("arg2"))
+            im.lift(
+                im.lambda_(im.sym("arg1"), im.sym("arg2"))(
+                    im.plus(im.deref("arg1"), im.deref("arg2"))
                 )
             )(
                 im.ref("arg1"),
@@ -80,27 +79,27 @@ def inline_lift_test_data():
                 # below. Here we test that if this symbol collides with a symbol of the outer
                 # lifted stencil, i.e. the lambda function above, the collision is properly
                 # resolved.
-                im.lift_(im.lambda__(im.sym("arg1"))(im.deref_("arg1")))(im.call_("f")()),
+                im.lift(im.lambda_(im.sym("arg1"))(im.deref("arg1")))(im.call("f")()),
             ),
             # (↑(λ(arg1, arg1_) → ·arg1 + ·arg1_))(arg1, f())
-            im.lift_(im.lambda__("arg1", "arg1_")(im.plus_(im.deref_("arg1"), im.deref_("arg1_"))))(
-                im.ref("arg1"), im.call_("f")()
+            im.lift(im.lambda_("arg1", "arg1_")(im.plus(im.deref("arg1"), im.deref("arg1_"))))(
+                im.ref("arg1"), im.call("f")()
             ),
         ),
         (
             # similar to the test case above, but the collision is with a symbol from
             # the outer scope
             # λ(arg1) → (↑(λ(arg2) → ·arg2 + arg1))((↑(λ(arg1) → ·arg1))(f()))
-            im.lambda__("arg1")(
-                im.lift_(im.lambda__(im.sym("arg2"))(im.plus_(im.deref_("arg2"), im.ref("arg1"))))(
-                    im.lift_(im.lambda__(im.sym("arg1"))(im.deref_("arg1")))(im.call_("f")())
+            im.lambda_("arg1")(
+                im.lift(im.lambda_(im.sym("arg2"))(im.plus(im.deref("arg2"), im.ref("arg1"))))(
+                    im.lift(im.lambda_(im.sym("arg1"))(im.deref("arg1")))(im.call("f")())
                 )
             ),
             # λ(arg1) → (↑(λ(arg1_) → ·arg1_ + arg1))(f())
-            im.lambda__("arg1")(
-                im.lift_(
-                    im.lambda__(im.sym("arg1_"))(im.plus_(im.deref_("arg1_"), im.ref("arg1")))
-                )(im.call_("f")())
+            im.lambda_("arg1")(
+                im.lift(im.lambda_(im.sym("arg1_"))(im.plus(im.deref("arg1_"), im.ref("arg1"))))(
+                    im.call("f")()
+                )
             ),
         ),
     ]
diff --git a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_propagate_deref.py b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_propagate_deref.py
index b8b6c6e4..ffbf2c2c 100644
--- a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_propagate_deref.py
+++ b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_propagate_deref.py
@@ -12,17 +12,13 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from gt4py.next.ffront import itir_makers as im
+from gt4py.next.iterator import ir_makers as im
 from gt4py.next.iterator.transforms.propagate_deref import PropagateDeref
 
 
 def test_deref_propagation():
-    testee = im.deref_(
-        im.call_(im.lambda__("inner_it")(im.lift_("stencil")("inner_it")))("outer_it")
-    )
-    expected = im.call_(im.lambda__("inner_it")(im.deref_(im.lift_("stencil")("inner_it"))))(
-        "outer_it"
-    )
+    testee = im.deref(im.call(im.lambda_("inner_it")(im.lift("stencil")("inner_it")))("outer_it"))
+    expected = im.call(im.lambda_("inner_it")(im.deref(im.lift("stencil")("inner_it"))))("outer_it")
 
     actual = PropagateDeref.apply(testee)
     assert actual == expected
diff --git a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_trace_shifts.py b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_trace_shifts.py
index 8a5da3df..f7e1ad2c 100644
--- a/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_trace_shifts.py
+++ b/tests/next_tests/unit_tests/iterator_tests/transforms_tests/test_trace_shifts.py
@@ -12,8 +12,7 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from gt4py.next.ffront import itir_makers as im
-from gt4py.next.iterator import ir
+from gt4py.next.iterator import ir, ir_makers as im
 from gt4py.next.iterator.transforms.trace_shifts import ALL_NEIGHBORS, TraceShifts
 
 
@@ -146,7 +145,7 @@ def test_shifted_literal():
     "Test shifting an applied lift of a stencil returning a constant / literal works."
     testee = ir.StencilClosure(
         # λ(x) → ·⟪Iₒ, 1ₒ⟫((↑(λ() → 1))())
-        stencil=im.lambda__("x")(im.deref_(im.shift_("I", 1)(im.lift_(im.lambda__()(1))()))),
+        stencil=im.lambda_("x")(im.deref(im.shift("I", 1)(im.lift(im.lambda_()(1))()))),
         inputs=[ir.SymRef(id="inp")],
         output=ir.SymRef(id="out"),
         domain=ir.FunCall(fun=ir.SymRef(id="cartesian_domain"), args=[]),
@@ -161,7 +160,7 @@ def test_shifted_literal():
 def test_tuple_get_on_closure_input():
     testee = ir.StencilClosure(
         # λ(x) → (·⟪Iₒ, 1ₒ⟫(x))[0]
-        stencil=im.lambda__("x")(im.tuple_get_(0, im.deref_(im.shift_("I", 1)("x")))),
+        stencil=im.lambda_("x")(im.tuple_get(0, im.deref(im.shift("I", 1)("x")))),
         inputs=[ir.SymRef(id="inp")],
         output=ir.SymRef(id="out"),
         domain=ir.FunCall(fun=ir.SymRef(id="cartesian_domain"), args=[]),