Address some review comments

src/gt4py/next/common.py

@@ -1169,7 +1169,6 @@ def promote_dims(*dims_list: Sequence[Dimension]) -> list[Dimension]:
         check_dims(list(dims))
     unique_dims = {dim for dims in dims_list for dim in dims}
 
-
     promoted_dims = sorted(unique_dims, key=lambda dim: (dims_kind_order[dim.kind], dim.value))
     check_dims(promoted_dims)
     return promoted_dims if unique_dims else []

src/gt4py/next/iterator/type_system/type_synthesizer.py

@@ -330,7 +330,7 @@ def applied_as_fieldop(*fields) -> ts.FieldType | ts.DeferredType:
 
                 def resolve_shift(
                     input_dim: common.Dimension, shift_tuple: tuple[itir.OffsetLiteral, ...]
-                ) -> common.Dimension | None:
+                ) -> common.Dimension:
                     """
                     Resolves the final dimension by applying shifts from the given shift tuple.
 
@@ -341,12 +341,10 @@ def resolve_shift(
                     - shift_tuple (tuple[itir.OffsetLiteral, ...]): A tuple of offset literals defining the shift.
 
                     Returns:
-                    - common.Dimension | None: The resolved dimension or `None` if no shift is applied.
+                    - common.Dimension: The resolved dimension or `input_dim` if no shift is applied.
                     """
-                    if not shift_tuple or not offset_provider_type:
-                        return None
 
-                    final_target: common.Dimension | None = None
+                    final_target: common.Dimension = input_dim
 
                     for off_literal in shift_tuple[::2]:
                         offset_type = offset_provider_type[off_literal.value]  # type: ignore [index] # ensured by accessing only every second element
@@ -377,19 +375,14 @@ def resolve_shift(
                                         input_dim = target  # Update input_dim for next iteration
                     return final_target
 
-                if any(shifts_results[i]):
+                for shift_tuple in shifts_results[
+                    i
+                ]:  # Use shift tuple corresponding to the input field
                     for input_dim in input_dims:
-                        for shift_tuple in shifts_results[
-                            i
-                        ]:  # Use shift tuple corresponding to the input field
-                            final_dim = (
-                                resolve_shift(input_dim, shift_tuple) or input_dim
-                            )  # If ther are no shifts, take input_dim
-                            if final_dim not in seen:
-                                seen.add(final_dim)
-                                output_dims.append(final_dim)
-                else:
-                    output_dims.extend(input_dims)
+                        final_dim = resolve_shift(input_dim, shift_tuple)
+                        if final_dim not in seen:
+                            seen.add(final_dim)
+                            output_dims.append(final_dim)
             else:
                 output_dims = domain.dims
 
@@ -401,7 +394,12 @@ def resolve_shift(
         assert isinstance(stencil_return, ts.DataType)
         return type_info.apply_to_primitive_constituents(
             lambda el_type: ts.FieldType(
-                dims=sorted({dim for dim in output_dims}, key=lambda dim: (common.dims_kind_order[dim.kind], dim.value)) if output_dims != "unknown" else [],
+                dims=sorted(
+                    {dim for dim in output_dims},
+                    key=lambda dim: (common.dims_kind_order[dim.kind], dim.value),
+                )
+                if output_dims != "unknown"
+                else [],
                 dtype=el_type,
             ),
             stencil_return,

tests/next_tests/unit_tests/iterator_tests/test_type_inference.py

@@ -589,6 +589,25 @@ def test_as_fieldop_without_domain_V2E():
     )
 
 
+def test_as_fieldop_without_domain_V2E_new():
+    stencil = im.lambda_("it")(
+        im.deref(im.shift("C2E", 0)(im.shift("E2V", 0)(im.shift("V2E", 0)("it"))))
+    )
+
+    testee = im.as_fieldop(stencil)(im.ref("inp", float_edge_field))
+    result = itir_type_inference.infer(
+        testee,
+        offset_provider_type={"C2E": C2E, "E2V": E2V, "V2E": V2E},
+        allow_undeclared_symbols=True,
+    )
+    assert result.type == ts.FieldType(dims=[Cell], dtype=float64_type)
+    assert result.fun.args[0].type.pos_only_args[0] == it_ts.IteratorType(
+        position_dims="unknown",
+        defined_dims=float_edge_field.dims,
+        element_type=float_edge_field.dtype,
+    )
+
+
 def test_as_fieldop_without_domain_only_one_shift():
     stencil = im.lambda_("it1", "it2")(
         im.plus(im.deref(im.shift("V2E", 1)("it1")), im.deref("it2"))