Flattening CLUBB's grid: allocations by any name, bounds by component, generics by arity

corpus/baseline.json

@@ -1367,11 +1367,11 @@
      "stopped_by": "static.rwset",
      "verdicts": {
       "static.rwset": {
-       "detail": "7/66 blocks disagree: cspl_interp/B002, cspleps/B003, csplint/B006, csplint/B012, csplint/B016 (+2 more)",
+       "detail": "5/66 blocks disagree: csplint/B006, csplint/B012, csplint/B016, csplint_square/B011, csplint_square/B015",
        "metrics": {
         "blocks_checked": 66,
         "blocks_deferred": 14,
-        "blocks_matched": 59,
+        "blocks_matched": 61,
         "blocks_waived": 0
        },
        "passed": false
@@ -1418,11 +1418,11 @@
      "stopped_by": "static.rwset",
      "verdicts": {
       "static.rwset": {
-       "detail": "18/124 blocks disagree: splrep_msg/B002, splprep/B014, splprep/B016, splprep/B019, splprep/B020 (+13 more)",
+       "detail": "1/124 blocks disagree: splrep_msg/B002",
        "metrics": {
         "blocks_checked": 124,
         "blocks_deferred": 8,
-        "blocks_matched": 106,
+        "blocks_matched": 123,
         "blocks_waived": 0
        },
        "passed": false
@@ -1650,11 +1650,11 @@
      "stopped_by": "static.rwset",
      "verdicts": {
       "static.rwset": {
-       "detail": "7/187 blocks disagree: genrand_encode/B002, genrand_encode/B003, genrand_decode/B002, genrand_load_state/B003, genrand_load_state/B004 (+2 more)",
+       "detail": "3/187 blocks disagree: genrand_encode/B002, genrand_encode/B003, genrand_decode/B002",
        "metrics": {
         "blocks_checked": 187,
         "blocks_deferred": 3,
-        "blocks_matched": 180,
+        "blocks_matched": 184,
         "blocks_waived": 0
        },
        "passed": false
@@ -1904,23 +1904,42 @@
       "oracle/f2py-golden": "ok",
       "store/fs-evidence": "ok",
       "transform/translate.numpy": "ok",
-      "verifier/differential.bitexact": "ok",
-      "verifier/static.rwset": "ok",
-      "verifier/symbolic.notary": "ok"
+      "verifier/differential.bitexact": "failed",
+      "verifier/static.rwset": "ok"
      },
-     "stopped_by": null,
+     "stopped_by": "differential.bitexact",
      "verdicts": {
       "differential.bitexact": {
-       "detail": "80 points across 1 subprogram(s), all bit-exact",
+       "detail": "3 subprogram(s) could not be compared: searchsorted_dp: candidate raised: NameError: name 'SMALL' is not defined; searchsorted_idp: candidate raised: NameError:",
        "metrics": {
-        "bit_exact": 80,
+        "bit_exact": 90,
         "integer_mismatch": 0,
-        "integer_points": 0,
+        "integer_points": 10,
         "max_rel": 0.0,
         "max_ulp": 0,
         "nan_mismatch": 0,
-        "points": 80,
+        "points": 90,
         "subprograms": {
+         "searchsorted_dp": {
+          "error": "candidate raised: NameError: name 'SMALL' is not defined"
+         },
+         "searchsorted_dpi": {
+          "error": "candidate raised: NameError: name 'SMALL' is not defined"
+         },
+         "searchsorted_i": {
+          "bit_exact": 10,
+          "integer_mismatch": 0,
+          "integer_points": 10,
+          "max_rel": 0.0,
+          "max_ulp": 0,
+          "nan_mismatch": 0,
+          "points": 10,
+          "redrawn": 0,
+          "reshaped": 0
+         },
+         "searchsorted_idp": {
+          "error": "candidate raised: NameError: name 'SMALL' is not defined"
+         },
          "sort": {
           "bit_exact": 80,
           "integer_mismatch": 0,
@@ -1935,7 +1954,7 @@
         },
         "trials": 10
        },
-       "passed": true
+       "passed": false
       },
       "static.rwset": {
        "detail": "62 blocks match",
@@ -1946,13 +1965,6 @@
         "blocks_waived": 0
        },
        "passed": true
-      },
-      "symbolic.notary": {
-       "detail": "no rewrites to notarize; the translation is print-order faithful",
-       "metrics": {
-        "rewrites": 0
-       },
-       "passed": true
       }
      }
     },
@@ -2360,11 +2372,11 @@
      "stopped_by": "static.rwset",
      "verdicts": {
       "static.rwset": {
-       "detail": "15/106 blocks disagree: slsqp/B019, slsqpb/B002, slsqpb/B003, slsqpb/B006, reset_bfgs_matrix/B002 (+10 more)",
+       "detail": "7/106 blocks disagree: slsqpb/B002, slsqpb/B003, slsqpb/B006, reset_bfgs_matrix/B002, lsq/B026 (+2 more)",
        "metrics": {
         "blocks_checked": 106,
         "blocks_deferred": 8,
-        "blocks_matched": 91,
+        "blocks_matched": 99,
         "blocks_waived": 0
        },
        "passed": false

src/recast/fortran/expr.py

@@ -156,7 +156,9 @@ def substitute(expr: Expr, name: str, replacement: Expr) -> Expr:
     For the one legal self-reference in an initializer, a kind inquiry on the
     constant being declared (``tol = max( 1.e-10_r8, epsilon(tol) )``): the
     reference carries the constant's kind and nothing else, and the fold
-    renders reals as 64-bit, so a 64-bit literal stands in for it.
+    renders reals as 64-bit, so a 64-bit literal stands in for it. Every
+    occurrence is replaced: a parameter cannot name itself anywhere else in
+    its own initializer, so there is no other occurrence to preserve.
     """
     if expr.kind == "name" and expr.text == name:
         return replacement
@@ -205,52 +207,56 @@ def render(
 REAL_CALLS = frozenset({"real", "dble", "sqrt"} | KIND_INQUIRIES)
 
 
-def typed(expr: Expr) -> str | None:
+def typed(expr: Expr, env: dict[str, str | None] | None = None) -> str | None:
     """``"real"``, ``"int"``, or ``None`` when a bare name leaves it open.
 
     Type inference the fold needs for exactly one decision: whether a ``/``
     is Fortran's integer division. A real literal or a real-valued call
     anywhere in an operand makes the quotient real; ``int(...)`` and integer
-    literals make it integer; a name is whatever its initializer was, which
-    this tree does not carry.
+    literals make it integer; a name is what ``env`` says its declaration
+    was -- CLUBB's ``ep = Rd / Rv`` over two real parameters is a real
+    quotient, and a fold that guessed integer made it zero.
     """
     if expr.kind == "real":
         return "real"
     if expr.kind == "int":
         return "int"
     if expr.kind == "name":
-        return None
+        return (env or {}).get(expr.text)
     if expr.kind == "call":
         if expr.text == "int":
             return "int"
         if expr.text in REAL_CALLS:
             return "real"
-    kinds = {typed(a) for a in expr.args}
+    kinds = {typed(a, env) for a in expr.args}
     if "real" in kinds:
         return "real"
     if kinds == {"int"}:
         return "int"
     return None
 
 
-def with_integer_division(expr: Expr, *, default_integer: bool | None = None) -> Expr:
+def with_integer_division(
+    expr: Expr, *, default_integer: bool | None = None, env: dict[str, str | None] | None = None
+) -> Expr:
     """The tree with every integer ``/`` spelled ``//``.
 
     Fortran divides two integers to an integer: ``nrk = runge_kutta_type / 10``
     is 4, not 4.1. A quotient whose operands are both known integers is
-    marked; one with a name in it falls back to ``default_integer``, which
-    the caller sets from the whole initializer -- an expression with no real
-    literal and no real-valued call in it is integer arithmetic throughout,
-    because a name in it is an integer parameter or it would have had one.
+    marked; one with a name in it is typed by ``env`` (the declared types
+    of the constants resolved so far) and otherwise falls back to
+    ``default_integer``, which the caller sets from the whole initializer.
     """
     if default_integer is None:
-        default_integer = typed(expr) != "real"
+        default_integer = typed(expr, env) != "real"
     if not expr.args:
         return expr
-    args = tuple(with_integer_division(a, default_integer=default_integer) for a in expr.args)
+    args = tuple(
+        with_integer_division(a, default_integer=default_integer, env=env) for a in expr.args
+    )
     text = expr.text
     if expr.kind == "binary" and expr.text == "/":
-        kinds = {typed(a) for a in args}
+        kinds = {typed(a, env) for a in args}
         if kinds == {"int"} or ("real" not in kinds and default_integer):
             text = "//"
     return Expr(expr.kind, text, args)