Merge pull request #73 from upstat-io/dev

feat(journey): deterministic scoring rubric, codegen fixes, Code Journeys web UI

Author: elucidsoft

compiler/ori_arc/src/decision_tree/emit.rs

@@ -24,28 +24,67 @@ use super::{DecisionTree, PathInstruction, ScrutineePath};
 /// variables that may be reassigned in arm bodies.
 pub(crate) struct EmitContext {
     /// The root scrutinee variable.
-    pub root_scrutinee: ArcVarId,
+    pub(crate) root_scrutinee: ArcVarId,
     /// Pool type of the root scrutinee (for type-aware path resolution).
-    pub root_scrutinee_ty: Idx,
+    pub(crate) root_scrutinee_ty: Idx,
     /// The merge block all arms jump to after executing their body.
-    pub merge_block: crate::ir::ArcBlockId,
+    pub(crate) merge_block: crate::ir::ArcBlockId,
     /// The body expression for each arm (indexed by `arm_index`).
-    pub arm_bodies: Vec<ori_ir::canon::CanId>,
+    pub(crate) arm_bodies: Vec<ori_ir::canon::CanId>,
     /// Span of the match expression.
-    pub span: Span,
+    pub(crate) span: Span,
     /// Scope snapshot from before the match. Each arm resets to this
     /// before lowering its body, ensuring arm-to-arm scope isolation.
-    pub pre_scope: ArcScope,
+    pub(crate) pre_scope: ArcScope,
     /// Mutable variable names to pass as merge block params (in order).
     /// These serve as SSA phi inputs at the match convergence point.
-    pub mutable_var_names: Vec<Name>,
+    pub(crate) mutable_var_names: Vec<Name>,
     /// Variant context stack for type-aware path resolution.
     ///
     /// Each entry is `(enum_type, variant_index)` pushed by `emit_tag_switch`
     /// when entering a specific variant's case block. `resolve_path` uses this
     /// to look up the actual field type for `TagPayload` steps, which is
     /// critical for recursive enums where fields may be RC-boxed pointers.
-    pub variant_stack: Vec<(Idx, u32)>,
+    variant_stack: Vec<(Idx, u32)>,
+}
+
+impl EmitContext {
+    /// Create a new emit context for decision tree emission.
+    pub(crate) fn new(
+        root_scrutinee: ArcVarId,
+        root_scrutinee_ty: Idx,
+        merge_block: crate::ir::ArcBlockId,
+        arm_bodies: Vec<ori_ir::canon::CanId>,
+        span: Span,
+        pre_scope: ArcScope,
+        mutable_var_names: Vec<Name>,
+    ) -> Self {
+        Self {
+            root_scrutinee,
+            root_scrutinee_ty,
+            merge_block,
+            arm_bodies,
+            span,
+            pre_scope,
+            mutable_var_names,
+            variant_stack: Vec::new(),
+        }
+    }
+
+    /// Push a variant onto the context stack (entering a variant's case block).
+    pub(crate) fn push_variant(&mut self, enum_type: Idx, variant_index: u32) {
+        self.variant_stack.push((enum_type, variant_index));
+    }
+
+    /// Pop the most recent variant from the context stack (leaving a variant's case block).
+    pub(crate) fn pop_variant(&mut self) {
+        self.variant_stack.pop();
+    }
+
+    /// Get the current variant stack (for path resolution).
+    pub(crate) fn variant_stack(&self) -> &[(Idx, u32)] {
+        &self.variant_stack
+    }
 }
 
 /// Emit a decision tree as ARC IR basic blocks.
@@ -266,10 +305,35 @@ pub(super) fn resolve_path(
                 };
                 (*idx, elem_ty)
             }
-            // List rest (slicing) not yet supported in LLVM backend.
-            // Emit element 0 as a placeholder — will be replaced when
-            // list pattern codegen is fully implemented.
-            PathInstruction::ListRest(_) => (0, Idx::UNIT),
+            PathInstruction::ListRest(start_idx) => {
+                // Emit a runtime call to slice the list from `start_idx` onward.
+                // The ARC IR uses Apply("ori_list_slice_drop", [list, start]),
+                // and the LLVM emitter expands this into the full sret call
+                // (extracting data/len/cap, computing elem_size, calling runtime).
+                let resolved = pool.resolve_fully(current_ty);
+                let list_ty = current_ty;
+                let elem_ty = if pool.tag(resolved) == Tag::List {
+                    pool.list_elem(resolved)
+                } else {
+                    Idx::UNIT
+                };
+                let _ = elem_ty; // Used by LLVM emitter via the list type
+                let start_const = lowerer.builder.emit_let(
+                    Idx::INT,
+                    crate::ir::ArcValue::Literal(crate::ir::LitValue::Int(i64::from(*start_idx))),
+                    Some(span),
+                );
+                let slice_fn = lowerer.interner.intern("ori_list_slice_drop");
+                let result = lowerer.builder.emit_apply(
+                    list_ty,
+                    slice_fn,
+                    vec![current, start_const],
+                    Some(span),
+                );
+                current = result;
+                current_ty = list_ty;
+                continue;
+            }
         };
         current = lowerer
             .builder
@@ -332,7 +396,7 @@ fn bind_pattern_variables(
             ctx.root_scrutinee_ty,
             path,
             ctx.span,
-            &ctx.variant_stack,
+            ctx.variant_stack(),
         );
         lowerer.scope.bind(*name, var);
     }

compiler/ori_arc/src/decision_tree/emit_switches/mod.rs

@@ -34,7 +34,7 @@ pub(super) fn emit_switch(
         ctx.root_scrutinee_ty,
         path,
         ctx.span,
-        &ctx.variant_stack,
+        ctx.variant_stack(),
     );
 
     match test_kind {

compiler/ori_arc/src/decision_tree/emit_switches/tag.rs

@@ -59,9 +59,9 @@ pub(in crate::decision_tree) fn emit_tag_switch(
             TestValue::Tag { variant_index, .. } => *variant_index,
             _ => 0,
         };
-        ctx.variant_stack.push((scrut_ty, variant_index));
+        ctx.push_variant(scrut_ty, variant_index);
         emit_tree(lowerer, subtree, ctx);
-        ctx.variant_stack.pop();
+        ctx.pop_variant();
     }
 
     // Emit the default block.

compiler/ori_arc/src/decision_tree/flatten.rs

@@ -229,10 +229,11 @@ impl<'a> FlattenCtx<'a> {
 
     /// Resolve a variant name to its discriminant index.
     ///
-    /// Handles three cases:
+    /// Handles four cases:
     /// - `Tag::Enum`: looks up variant by name in the enum definition
     /// - `Tag::Option`: `Some` = 0, `None` = 1
     /// - `Tag::Result`: `Ok` = 0, `Err` = 1
+    /// - `Tag::Ordering`: `Less` = 0, `Equal` = 1, `Greater` = 2
     #[expect(
         clippy::cast_possible_truncation,
         reason = "variant indices never exceed u32"
@@ -258,6 +259,19 @@ impl<'a> FlattenCtx<'a> {
                 // Convention: Ok = 0, Err = 1 (matches evaluator's Value::Ok/Err)
                 return u32::from(self.interner.lookup(variant_name) == "Err");
             }
+            Tag::Ordering => {
+                // Convention: Less = 0, Equal = 1, Greater = 2
+                let name_str = self.interner.lookup(variant_name);
+                return match name_str {
+                    "Less" => 0,
+                    "Equal" => 1,
+                    "Greater" => 2,
+                    other => {
+                        debug_assert!(false, "unknown Ordering variant: {other}");
+                        0
+                    }
+                };
+            }
             _ => {}
         }
         tracing::debug!(
@@ -270,11 +284,12 @@ impl<'a> FlattenCtx<'a> {
         0
     }
 
-    /// Get the field types for a specific variant of an enum, Option, or Result.
+    /// Get the field types for a specific variant of an enum, Option, Result, or Ordering.
     ///
     /// - `Tag::Enum`: returns field types from the enum definition
     /// - `Tag::Option`: `Some` (index 0) has one field (the inner type), `None` (index 1) has none
     /// - `Tag::Result`: `Ok` (index 0) has one field (ok type), `Err` (index 1) has one field (err type)
+    /// - `Tag::Ordering`: all variants (Less, Equal, Greater) are unit — no fields
     fn resolve_variant_field_types(
         &self,
         enum_ty: ori_types::Idx,
@@ -305,6 +320,8 @@ impl<'a> FlattenCtx<'a> {
                 }
                 return vec![self.pool.result_ok(resolved)];
             }
+            // Ordering variants (Less, Equal, Greater) are all unit — no fields.
+            Tag::Ordering => return Vec::new(),
             _ => {}
         }
         Vec::new()

compiler/ori_arc/src/decision_tree/mod.rs

@@ -15,6 +15,12 @@
 //! Type definitions live in `ori_ir::canon::tree` (shared across crates).
 //! The compilation algorithm and ARC IR emission logic live here in `ori_arc`.
 //!
+//! NOTE: `decision_tree::compile` and `flatten` are pattern-matching primitives
+//! temporarily housed in `ori_arc`. They are consumed by `ori_canon` (which
+//! imports `ori_arc`), creating an upward dependency from canonicalization into
+//! ARC optimization. These will move to `ori_canon::patterns` in `eval_v2`
+//! Section 03 — see `ori_ir::canon::tree` for the migration plan.
+//!
 //! # References
 //!
 //! - Maranget (2008): foundational algorithm

compiler/ori_arc/src/lower/control_flow/mod.rs

@@ -322,17 +322,21 @@ impl ArcLowerer<'_> {
                 }
             }
             CanExpr::Field { receiver, field: _ } => {
-                let recv = self.lower_expr(receiver);
-                let setter_fn = self.interner.intern("__set_field");
-                self.builder
-                    .emit_apply(Idx::UNIT, setter_fn, vec![recv, rhs], Some(span));
+                let _recv = self.lower_expr(receiver);
+                // TODO(section-03): field assignment in ARC lowering — blocked on COW
+                // codegen. `__set_field` does not exist as a runtime function or LLVM
+                // intrinsic. The evaluator desugars `obj.field = val` into
+                // `obj = { ...obj, field: val }` before it reaches ARC lowering, so
+                // this arm should be unreachable once desugaring is complete.
+                tracing::warn!("field assignment not yet supported in ARC lowering");
             }
             CanExpr::Index { receiver, index } => {
-                let recv = self.lower_expr(receiver);
-                let idx_var = self.lower_expr(index);
-                let setter_fn = self.interner.intern("__set_index");
-                self.builder
-                    .emit_apply(Idx::UNIT, setter_fn, vec![recv, idx_var, rhs], Some(span));
+                let _recv = self.lower_expr(receiver);
+                let _idx_var = self.lower_expr(index);
+                // TODO(section-03): index assignment in ARC lowering — blocked on COW
+                // codegen. `__set_index` does not exist as a runtime function or LLVM
+                // intrinsic. See field assignment comment above.
+                tracing::warn!("index assignment not yet supported in ARC lowering");
             }
             _ => {
                 tracing::warn!("unsupported assignment target in ARC IR");
@@ -395,16 +399,15 @@ impl ArcLowerer<'_> {
         let tree = self.canon.decision_trees.get_shared(tree_id);
 
         let scrut_ty = self.builder.var_type(scrut_var);
-        let mut ctx = crate::decision_tree::emit::EmitContext {
-            root_scrutinee: scrut_var,
-            root_scrutinee_ty: scrut_ty,
+        let mut ctx = crate::decision_tree::emit::EmitContext::new(
+            scrut_var,
+            scrut_ty,
             merge_block,
-            arm_bodies: arm_ids,
+            arm_ids,
             span,
-            pre_scope: pre_scope.clone(),
+            pre_scope.clone(),
             mutable_var_names,
-            variant_stack: Vec::new(),
-        };
+        );
 
         crate::decision_tree::emit::emit_tree(self, &tree, &mut ctx);
 

compiler/ori_arc/src/rc_insert/block_rc.rs

@@ -96,6 +96,20 @@ pub(super) fn process_block_rc(
             }
         }
 
+        // ApplyIndirect borrows the closure (position 0): the callee is
+        // invoked through the closure's fn_ptr but does not take ownership
+        // of the environment. The caller must Dec the closure after its
+        // last use, just like any other borrowing position.
+        if let ArcInstr::ApplyIndirect { closure, .. } = instr {
+            if needs_rc_trackable(*closure, ctx) && !live.contains(closure) {
+                new_body.push(ArcInstr::RcDec {
+                    var: *closure,
+                    strategy: rc_strategy(ctx, *closure),
+                });
+                new_spans.push(None);
+            }
+        }
+
         new_body.push(instr.clone());
         new_spans.push(span);
 
@@ -307,6 +321,16 @@ fn process_instruction_uses(
             continue;
         }
 
+        // ApplyIndirect borrows the closure (position 0): calling through
+        // a closure's fn_ptr does not consume the closure environment.
+        // Treat as a borrowing use — add to live, no Inc.
+        if let ArcInstr::ApplyIndirect { closure, .. } = instr {
+            if var == *closure {
+                live.insert(var);
+                continue;
+            }
+        }
+
         // Normal (non-borrowed) var.
         if !seen.insert(var) {
             // Duplicate arg in the same instruction — already handled below.

compiler/ori_canon/src/const_fold/arithmetic.rs

@@ -66,7 +66,6 @@ pub(super) fn fold_binary(
                 }
             })
         }
-
         // Float arithmetic.
         (BinaryOp::Add, ConstValue::Float(a), ConstValue::Float(b)) => Some(ConstValue::Float(
             (f64::from_bits(*a) + f64::from_bits(*b)).to_bits(),

compiler/ori_canon/src/exhaustiveness/mod.rs

@@ -203,6 +203,9 @@ fn check_enum_tag(
         ori_types::Tag::Result => {
             check_result(&covered, missing, nesting);
         }
+        ori_types::Tag::Ordering => {
+            check_ordering(&covered, missing, nesting);
+        }
         // Unknown or non-enum type at this path — skip (conservative).
         // This can happen if the type checker couldn't resolve the scrutinee.
         _ => {}
@@ -290,6 +293,25 @@ fn check_result(
     }
 }
 
+/// Check coverage for the builtin `Ordering` type.
+///
+/// Ordering has exactly 3 variants: `Less` (index 0), `Equal` (index 1), `Greater` (index 2).
+fn check_ordering(
+    covered: &rustc_hash::FxHashSet<u32>,
+    missing: &mut Vec<String>,
+    nesting: &[String],
+) {
+    if !covered.contains(&0) {
+        missing.push(wrap_pattern(nesting, "Less"));
+    }
+    if !covered.contains(&1) {
+        missing.push(wrap_pattern(nesting, "Equal"));
+    }
+    if !covered.contains(&2) {
+        missing.push(wrap_pattern(nesting, "Greater"));
+    }
+}
+
 /// Check coverage for a `ListLen` switch with no default.
 ///
 /// List lengths are quasi-finite: a rest pattern (`[x, ..rest]`, encoded as