Consolidate elementwise operators into a descriptor table

Every elementwise binary operator (+ - * / ^ %% %/%, comparisons,
& && | ||) becomes a row in binop_table, compiled by one compile_binop
that applies a closed set of mode rules (promote / double / compare /
logical) and resolves shapes through resolve_elementwise(), the renamed
maybe_reshape_vector_matrix() with the conformability policy applied via
guard_conformable_dims() -- now the single guard emitter shared with the
BLAS lowerings and ifelse() (whose private axis verdict and inline .or.
guard are deleted). check_conformable() was dims_match() in list form;
both call sites now say so. The real-domain floor spelling shared by
floor() and double %/% is factored into real_floor_expr().

Behavior-neutral: zero snapshot churn, full QUICKR_FULL_GRID=1 pass,
and byte-identical generated Fortran over a 20-program differential
battery against the previous commit.

Author: mns-nordicals

R/r2f-arithmetic.R

@@ -8,31 +8,11 @@ ifelse_branch_shape_msg <- paste0(
   "R-style recycling is not supported"
 )
 
-# Three-valued conformability verdict for one axis of an ifelse() branch
-# against `test`: ok+known (no guard), not-ok+known (compile error), or
-# unknown (runtime guard). NA dims are always unknown: two unknown lengths
-# are not the same quantity.
-ifelse_axis_verdict <- function(test_dim, branch_dim) {
-  if (is_wholenumber(test_dim) && is_wholenumber(branch_dim)) {
-    return(list(
-      ok = identical(as.integer(test_dim), as.integer(branch_dim)),
-      unknown = FALSE
-    ))
-  }
-  if (!is_scalar_na(test_dim) && !is_scalar_na(branch_dim)) {
-    test_norm <- fortranize_expr_symbols(test_dim)
-    branch_norm <- fortranize_expr_symbols(branch_dim)
-    if (identical(test_norm, branch_norm)) {
-      return(list(ok = TRUE, unknown = FALSE))
-    }
-  }
-  list(ok = TRUE, unknown = TRUE)
-}
-
 # Enforce the shape contract for one ifelse() branch: scalars broadcast
 # natively; a non-scalar branch must match `test`'s shape, because
 # merge() requires conformable arguments and a runtime mismatch would
-# read past the shorter branch. Statically unequal dims are a compile
+# read past the shorter branch. Per axis, guard_conformable_dims()
+# applies the framework policy: statically unequal dims are a compile
 # error; symbolic dims get a statement-level runtime size guard.
 check_ifelse_branch_shape <- function(branch, mask, hoist, scope) {
   if (passes_as_scalar(branch@value)) {
@@ -41,39 +21,19 @@ check_ifelse_branch_shape <- function(branch, mask, hoist, scope) {
   if (branch@value@rank != mask@value@rank) {
     stop(ifelse_branch_shape_msg, call. = FALSE)
   }
-  unknown_axes <- integer()
   for (axis in seq_len(mask@value@rank)) {
-    verdict <- ifelse_axis_verdict(
+    guard_conformable_dims(
+      dim_or_one(branch, axis),
       dim_or_one(mask, axis),
-      dim_or_one(branch, axis)
+      ifelse_branch_shape_msg,
+      hoist,
+      scope,
+      left = branch,
+      right = mask,
+      left_axis = axis,
+      right_axis = axis
     )
-    if (!verdict$ok) {
-      stop(ifelse_branch_shape_msg, call. = FALSE)
-    }
-    if (verdict$unknown) {
-      unknown_axes <- c(unknown_axes, axis)
-    }
-  }
-  if (!length(unknown_axes)) {
-    return(invisible())
   }
-  if (is.null(hoist)) {
-    stop(
-      "cannot emit a runtime length guard here; ",
-      "ifelse() branch lengths must match `test` statically",
-      call. = FALSE
-    )
-  }
-  # size() is an inquiry, so applying it to operand expression text does
-  # not evaluate the operands.
-  condition <- str_flatten(
-    map_chr(
-      unknown_axes,
-      function(axis) glue("size({branch}, {axis}) /= size({mask}, {axis})")
-    ),
-    " .or. "
-  )
-  emit_quickr_error_if(condition, ifelse_branch_shape_msg, hoist, scope)
   invisible()
 }