fix(codegen): widen mixed-numeric list elements + narrow unknown-func defer to __tfm_ (TASK-29B-2 review)

- infer_type's ListExpr arm now unifies element types via _common_base
  (same helper COALESCE uses), so make_array(int, float) types as
  list[float] and pydantic widens the int element at model_validate
  (measured: no emission-side change needed).
- _emit_expr's Func branch narrows the UnsupportedInCodegen defer to
  __tfm_ transformer placeholders only; every other unknown function
  name (e.g. foobar(x), invalid SQL) keeps the original hard ValueError
  instead of being silently skipped by the differential harness.

Author: ahrzb

sql_transform/_codegen/engine.py

@@ -94,10 +94,13 @@ def _emit_expr(e: Any, env: dict) -> str:
     if isinstance(e, cp.Func):
         fn = _BUILTINS.get(e.name)
         if fn is None:
-            # Anything without a codegen builtin -- notably a transformer call
-            # (`__tfm_N__(...)`), which codegen has no support for at all -- is a
-            # deferred surface, not a hard error.
-            raise UnsupportedInCodegen(f"{e.name}() is not supported in codegen yet")
+            if e.name.startswith("__tfm_"):
+                # A transformer placeholder call: codegen has no transformer
+                # support (native-only, TASK-34) -- deferred surface, not an error.
+                raise UnsupportedInCodegen(
+                    f"{e.name}() is not supported in codegen yet"
+                )
+            raise ValueError(f"Unknown function: {e.name}")
         return f"{fn}({', '.join(_emit_expr(a, env) for a in e.args)})"
     if isinstance(e, cp.Case):
         out = _emit_expr(e.default, env)

sql_transform/_codegen/plan.py

@@ -820,13 +820,16 @@ def infer_type(e: Any, schemas: dict) -> FieldType:
         return FieldType(StructBase(fields), False)
     if isinstance(e, ListExpr):
         elem_types = [infer_type(x, schemas) for x in e.items]
-        # Native unifies: identical element types collapse to that type; an empty
-        # or mixed list is unresolvable.
-        elem = (
-            elem_types[0]
-            if elem_types and all(t == elem_types[0] for t in elem_types)
-            else FieldType(OTHER, True)
-        )
+        if not elem_types:
+            elem = FieldType(OTHER, True)
+        else:
+            # Unify element bases the same way COALESCE does (numeric int/float
+            # -> float), so e.g. make_array(int_col, float_col) types as
+            # list<float> -- matching DataFusion, which widens the int element
+            # at runtime (measured: make_array(1, 2.5) -> [1.0, 2.5]).
+            elem = FieldType(
+                _common_base(elem_types), any(t.nullable for t in elem_types)
+            )
         return FieldType(ListBase(elem), False)
     if isinstance(e, Func):
         return _function_type(e.name, [infer_type(a, schemas) for a in e.args])

tests/test_diff_errors.py

@@ -29,3 +29,13 @@ def test_int_mod_by_zero_rejected_by_both():
         "SELECT a % b AS r FROM t",
         {"t": rows({"a": "int", "b": "int"}, [{"a": 5, "b": 0}])},
     )
+
+
+def test_unknown_function_rejected_by_both():
+    # foobar() is invalid SQL -- DataFusion errors -- and is NOT a `__tfm_`
+    # transformer placeholder, so codegen must raise a hard error too (not
+    # UnsupportedInCodegen, which the harness would skip as a deferred surface).
+    check_both_raise(
+        "SELECT foobar(x) AS y FROM t",
+        {"t": rows({"x": "int"}, [{"x": 1}])},
+    )

tests/test_diff_types.py

@@ -21,6 +21,36 @@ def test_list_construct():
     )
 
 
+def test_list_construct_mixed_numeric_widens(xfail_on_native):
+    # DataFusion widens the int element to match the float element (list<double>).
+    # Locks in infer_type's ListExpr arm unifying element bases via _common_base
+    # (like COALESCE), so the output model types the list as list[float] and
+    # pydantic coerces the runtime int element to float.
+    #
+    # Bracket literal `[x, y]` (not make_array(...)): native's function dispatch
+    # doesn't recognize "make_array"/"array" as a builtin at all (a separate,
+    # pre-existing gap -- expr_build.rs's convert_function has no such case,
+    # unlike Python's ANONYMOUS-function branch), so it isn't a usable surface
+    # to compare both engines against the oracle. The bracket form reaches the
+    # same Expr::List / ListExpr construction path in both engines.
+    #
+    # xfail_on_native: measured -- native's unify_list_element_types
+    # (src/types.rs) is exact-equality-only, the same bug class just fixed here
+    # in codegen's infer_type. Native still emits [1, 2.5] (un-widened) instead
+    # of DataFusion's [1.0, 2.5]. A native-side fix is out of scope here; flag
+    # as a parity bug for its own ticket rather than fixing inline.
+    xfail_on_native(
+        "native does not widen mixed int/float list elements "
+        "(types.rs unify_list_element_types is exact-equality-only) -- "
+        "separate parity bug, own ticket"
+    )
+    check(
+        "SELECT [x, y] AS l FROM t",
+        {"t": rows({"x": "int", "y": "float"}, [{"x": 1, "y": 2.5}])},
+        expect=[{"l": [1.0, 2.5]}],
+    )
+
+
 def test_struct_input_roundtrip():
     check(
         "SELECT s FROM t",