majit: lower discarded inline-helper results, and give the degraded-arm registry a denominator

majit/majit-macros/src/jit_interp/jitcode_lower/api.rs

@@ -531,9 +531,39 @@ pub(crate) fn generate_inline_helper_jitcode_with_calls(
     maybe_dump_liveness(&helper_name, &lowerer.op_metadata);
     let liveness_prebuild =
         liveness_prebuild_tokens(&lowerer.op_metadata, &lowerer.inline_liveness_prebuild);
+    // The body has lowered, so the consulted-key set is final. Reported per
+    // HELPER, not per machine: each `#[jit_inline]` carries its own
+    // `int_fields` / `ref_fields`, and a key one helper consults says nothing
+    // about the helper next to it.
+    //
+    // This surface is where the population lives. A `#[jit_interp]` machine
+    // declares a handful of keys; a consumer's helpers repeat theirs at every
+    // site, and a key that matches nothing at one site matches nothing at
+    // dozens.
+    let unconsulted_declarations = match inline_config.as_ref() {
+        Some(config) => {
+            let consulted = config.consulted_field_keys.borrow();
+            let mut keys: Vec<&String> = config
+                .int_fields
+                .keys()
+                .chain(config.ref_fields.keys())
+                .filter(|key| !consulted.contains(*key))
+                .collect();
+            keys.sort();
+            keys.dedup();
+            let records = keys.into_iter().map(|key| {
+                quote! {
+                    majit_metainterp::record_unconsulted_field_declaration(#helper_name, #key);
+                }
+            });
+            quote! { #(#records)* }
+        }
+        None => quote! {},
+    };
     let statements = lowerer.statements;
     Ok(Some(InlineHelperJitCode {
         body: quote! {
+            #unconsulted_declarations
             #(#statements)*
         },
         return_reg,

majit/majit-macros/src/jit_interp/jitcode_lower/dispatch.rs

@@ -2498,6 +2498,22 @@ pub(super) fn lower_dispatch_chain(
         lowerer.emit_jump(&default_label);
     }
 
+    // The denominator for `record_degraded_dispatch_arm` below, staged from the
+    // same loop's own admission test so the two cannot drift: an arm is counted
+    // here exactly when the loop emits a body for it.  Without it an empty
+    // degraded registry reads as "nothing degraded" and as "no portal was
+    // built" at once, and only the first is a pass.
+    {
+        let census_interp = config.state_type_name.clone();
+        let census_arms = classified_arms
+            .iter()
+            .filter(|arm| !matches!(arm.pat, Pat::Wild(_)) && !is_lowercase_binding_pat(&arm.pat))
+            .count();
+        lowerer.emit_aux(quote::quote! {
+            majit_metainterp::record_dispatch_arm_census(#census_interp, #census_arms);
+        });
+    }
+
     for (arm_idx, arm) in classified_arms.iter().enumerate() {
         // `_` wildcard: skip here; handled by the default GOTO below.
         // All other patterns (including Pat::Ident like `OP_NOP`) are
@@ -3007,6 +3023,33 @@ pub(super) fn lower_dispatch_chain(
         }
     }
 
+    // Every arm has lowered, so the consulted-key set is final: report the
+    // declared `int_fields` / `ref_fields` keys no access site asked about.
+    //
+    // Reported rather than rejected, and the reason is the degraded arm. An
+    // arm that refused to lower never reached its field accesses, so a key
+    // used only there is unconsulted through no fault of the declaration —
+    // failing the build on it would turn one refusal into two. The consumer's
+    // gate reads this alongside `degraded_dispatch_arms` and can tell them
+    // apart; a compile error could not.
+    {
+        let interp = config.state_type_name.clone();
+        let consulted = config.consulted_field_keys.borrow();
+        let mut unconsulted: Vec<&String> = config
+            .int_fields
+            .keys()
+            .chain(config.ref_fields.keys())
+            .filter(|key| !consulted.contains(*key))
+            .collect();
+        unconsulted.sort();
+        unconsulted.dedup();
+        for key in unconsulted {
+            lowerer.emit_aux(quote::quote! {
+                majit_metainterp::record_unconsulted_field_declaration(#interp, #key);
+            });
+        }
+    }
+
     // After all arm guards, the default/exit path: unconditional GOTO.
     // default_label is bound at the typed-return emission site in
     // lower_dispatch_body (Task 1.7).

majit/majit-macros/src/jit_interp/jitcode_lower/lower_stmt.rs

@@ -1494,6 +1494,52 @@ impl<'c> Lowerer<'c> {
                     );
                     self.emit_op(OpMeta::live_marker(), post_live);
                 }
+                // A result-returning inline helper whose result the statement
+                // discards. The sub-jitcode still ends in a typed return
+                // opcode, so it needs a destination even though nothing reads
+                // it; `alloc_reg` mints one, the same way the discarded
+                // `ResidualInt` family below does. Everything else is the
+                // value-position lowering verbatim.
+                //
+                // Without this arm the call reaches `_ => return None` and the
+                // statement is dropped: `explicit_call_emits_post_live` already
+                // answers for these kinds, so the accounting says the policy is
+                // handled while the lowering says it is not, and the effect the
+                // helper performs leaves the trace with no diagnostic. The
+                // workaround is to bind the result to `let _x = ...`, which is
+                // a source change the declaration does not ask for.
+                crate::jit_interp::CallPolicyKind::InlineInt
+                | crate::jit_interp::CallPolicyKind::InlineRef
+                | crate::jit_interp::CallPolicyKind::InlineFloat => {
+                    let result_kind = binding_kind_for_inline_policy(kind)
+                        .expect("the arm's own patterns are the inline result policies");
+                    let throwaway_reg = self.alloc_reg();
+                    let builder_path = inline_builder_path(&call.func)?;
+                    let prebuild_path = inline_prebuild_path(&call.func)?;
+                    let (inline_call, post_live) = inline_call_tokens(&arg_bindings, throwaway_reg);
+                    let __arg_regs: Vec<Register> =
+                        arg_bindings.iter().map(Register::from_binding).collect();
+                    self.inline_liveness_prebuild.push(quote! {
+                        #prebuild_path(__asm);
+                    });
+                    self.emit_op(
+                        OpMeta::linear(
+                            OpKind::InlineCall,
+                            __arg_regs,
+                            vec![Register::new(result_kind, throwaway_reg)],
+                        ),
+                        quote! {
+                            use majit_metainterp::jitcode::JitCodeRuntimeExt as _;
+                            let __sub_jitcode = #builder_path(__asm);
+                            let (__sub_return_kind, _) = __sub_jitcode
+                                .trailing_return_info()
+                                .expect("inline helper jitcode must end in a typed return opcode");
+                            let __sub_idx = __builder.add_sub_jitcode(__sub_jitcode);
+                            #inline_call
+                        },
+                    );
+                    self.emit_op(OpMeta::live_marker(), post_live);
+                }
                 crate::jit_interp::CallPolicyKind::MayForceVoid => {
                     if let Some(arg_regs) = int_arg_regs(&arg_bindings) {
                         let typed_args = quote! {