Merge pull request #62 from upstat-io/dev

feat(eval): complete COW parity and extract bloated modules

Author: elucidsoft

.github/workflows/auto-release.yml

@@ -88,28 +88,41 @@ jobs:
           git tag "${{ steps.tag.outputs.tag }}"
           git push origin "${{ steps.tag.outputs.tag }}"
 
-      - name: Gather commit log
+      - name: Gather release context
         if: steps.tag.outputs.skip != 'true'
         id: commits
+        env:
+          GH_TOKEN: ${{ secrets.ORILANG_RELEASE_TOKEN }}
         run: |
           TAG="${{ steps.tag.outputs.tag }}"
 
           # Find previous tag for release notes range
           PREV_TAG=$(git tag --sort=-creatordate | grep '^v' | sed -n '2p')
 
           if [[ -n "$PREV_TAG" ]]; then
+            PREV_DATE=$(git log -1 --format=%aI "$PREV_TAG")
             LOG=$(git log "${PREV_TAG}..HEAD" --pretty=format:"- %s (%h)" --no-merges)
-            DIFF_STAT=$(git diff "${PREV_TAG}..HEAD" --stat | tail -1)
           else
+            PREV_DATE=""
             LOG=$(git log --pretty=format:"- %s (%h)" --no-merges -20)
-            DIFF_STAT=""
+          fi
+
+          # Fetch merged PR descriptions — the richest context available
+          if [[ -n "$PREV_DATE" ]]; then
+            PR_BODIES=$(gh pr list --state merged --base master --limit 20 \
+              --json number,title,body,mergedAt \
+              --jq "[.[] | select(.mergedAt >= \"$PREV_DATE\")] | .[] | \"## PR #\\(.number): \\(.title)\\n\\(.body // \"(no description)\")\\n\"")
+          else
+            PR_BODIES=$(gh pr list --state merged --base master --limit 5 \
+              --json number,title,body \
+              --jq '.[] | "## PR #\(.number): \(.title)\n\(.body // "(no description)")\n"')
           fi
 
           echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
 
-          # Write to file to avoid shell quoting issues
+          # Write to files to avoid shell quoting issues
           echo "$LOG" > /tmp/commit-log.txt
-          echo "$DIFF_STAT" > /tmp/diff-stat.txt
+          echo "$PR_BODIES" > /tmp/pr-bodies.txt
 
       - name: Generate AI release notes
         if: steps.tag.outputs.skip != 'true'
@@ -118,7 +131,7 @@ jobs:
           COPILOT_GITHUB_TOKEN: ${{ secrets.COPILOT_GITHUB_TOKEN }}
         run: |
           COMMIT_LOG=$(cat /tmp/commit-log.txt)
-          DIFF_STAT=$(cat /tmp/diff-stat.txt)
+          PR_BODIES=$(cat /tmp/pr-bodies.txt)
           TAG="${{ steps.tag.outputs.tag }}"
           PREV_TAG="${{ steps.commits.outputs.prev_tag }}"
 
@@ -127,25 +140,43 @@ jobs:
           import asyncio, sys, os
 
           COMMIT_LOG = """${COMMIT_LOG}"""
-          DIFF_STAT = """${DIFF_STAT}"""
+          PR_BODIES = """${PR_BODIES}"""
           TAG = "${TAG}"
           PREV_TAG = "${PREV_TAG}" or "beginning"
 
-          PROMPT = f"""You are writing release notes for "Ori", a statically-typed, expression-based programming language compiler. Given the commit log below, write concise, user-friendly release notes in markdown.
+          PROMPT = f"""You are writing release notes for **Ori** ({TAG}), an alpha-stage statically-typed, expression-based programming language with HM type inference, ARC memory management, and capability-based effects. The audience is developers and language enthusiasts following the project.
+
+          Write detailed, informative release notes in markdown. Do NOT wrap in \`\`\`markdown fences.
+
+          ## Format
 
-          Rules:
-          - Group changes into sections: **Features**, **Bug Fixes**, **Improvements**, **Internal** (only if meaningful)
-          - Omit empty sections
+          Start with a 1-2 sentence summary blurb describing the theme of this release.
+
+          Then group changes into sections (omit empty ones):
+          - **Features** — new user-facing capabilities
+          - **Bug Fixes** — corrected behavior
+          - **Improvements** — enhancements to existing features, performance, error messages
+          - **Compiler Internals** — refactoring, architecture changes, code quality (always include if applicable — compiler development IS the product at alpha stage)
+
+          For each bullet:
+          - **Bold title** followed by 1-2 sentences explaining what changed and why it matters
           - Use past tense ("Added", "Fixed", "Improved")
-          - Keep each bullet to one line
-          - Skip merge commits and CI-only changes
-          - If there are no user-facing changes, just say "Internal improvements and maintenance."
-          - Do NOT wrap in \`\`\`markdown fences
+          - Reference affected areas (e.g., type checker, evaluator, LLVM codegen, parser)
 
-          Commit log ({PREV_TAG}..{TAG}):
-          {COMMIT_LOG}
+          ## Rules
+          - The PR descriptions are your PRIMARY source — they contain human-written summaries of what changed and why
+          - The commit log is supplementary — use it to catch anything the PRs missed
+          - Never say "Internal improvements and maintenance" — every change gets a meaningful description
+          - Skip "nightly" automation PRs — focus on substantive changes
+          - Do not reproduce test plan checklists — focus on what changed, not how it was tested
+
+          ## Input
 
-          Diff stats: {DIFF_STAT}"""
+          Pull request descriptions (primary source):
+          {PR_BODIES}
+
+          Commit log ({PREV_TAG}..{TAG}):
+          {COMMIT_LOG}"""
 
           async def main():
               from copilot import CopilotClient, PermissionHandler
@@ -187,8 +218,29 @@ jobs:
               asyncio.run(main())
           except Exception as e:
               print(f"::warning::AI release notes failed ({e}), falling back to commit log")
+              # Categorize commits by conventional commit prefix
+              sections = {"Features": [], "Bug Fixes": [], "Improvements": [], "Other": []}
+              for line in COMMIT_LOG.strip().split("\n"):
+                  line = line.strip()
+                  if not line or not line.startswith("- "):
+                      continue
+                  subject = line[2:]  # strip "- " prefix
+                  if subject.startswith("feat"):
+                      sections["Features"].append(line)
+                  elif subject.startswith("fix"):
+                      sections["Bug Fixes"].append(line)
+                  elif subject.startswith("refactor") or subject.startswith("perf"):
+                      sections["Improvements"].append(line)
+                  else:
+                      sections["Other"].append(line)
+              body = ""
+              for section, items in sections.items():
+                  if items:
+                      body += f"## {section}\n\n" + "\n".join(items) + "\n\n"
+              if not body.strip():
+                  body = "## Changes\n\n" + COMMIT_LOG
               with open("/tmp/release-notes.txt", "w") as f:
-                  f.write(f"## Changes\n\n{COMMIT_LOG}")
+                  f.write(body.strip())
           PYEOF
 
       - name: Create release

compiler/ori_eval/src/interpreter/can_eval/mod.rs

@@ -18,10 +18,11 @@
 mod control_flow;
 mod function_exp;
 mod operators;
+mod trace;
 
 use ori_ir::canon::{CanExpr, CanId, CanRange, CanonResult};
 use ori_ir::{Name, Span};
-use ori_patterns::{ControlAction, EvalError, EvalResult, TraceEntryData, Value};
+use ori_patterns::{ControlAction, EvalError, EvalResult, Value};
 use ori_stack::ensure_sufficient_stack;
 use smallvec::SmallVec;
 
@@ -64,86 +65,6 @@ impl Interpreter<'_> {
         self.canon_ref().arena.span(can_id)
     }
 
-    /// Inject a trace entry into an error value at a `?` operator site.
-    ///
-    /// If the value is `Value::Err(Value::Error(...))`, appends a `TraceEntryData`
-    /// recording the current function name and source location. Non-error values
-    /// are returned unchanged.
-    ///
-    /// Uses `Heap::make_mut` for copy-on-write: when the error is uniquely owned
-    /// (common case — errors propagate linearly through `?`), the trace entry
-    /// is appended in place with no cloning.
-    fn inject_trace_entry(&self, mut value: Value, can_id: CanId) -> Value {
-        // Guard: only Err(Error(...)) values carry traces
-        if !matches!(&value, Value::Err(inner) if matches!(&**inner, Value::Error(_))) {
-            return value;
-        }
-
-        // Build the function name from the call stack
-        let function_name = self.call_stack.current_frame().map_or_else(
-            || "<top-level>".to_string(),
-            |f| self.interner.lookup(f.name).to_string(),
-        );
-
-        // Compute line/column from span byte offset
-        let span = self.can_span(can_id);
-        let (line, column) = self.line_col_from_offset(span.start);
-
-        let file = self
-            .source_file_path
-            .as_deref()
-            .cloned()
-            .unwrap_or_else(|| "<unknown>".to_string());
-
-        let entry = TraceEntryData {
-            function: function_name,
-            file,
-            line,
-            column,
-        };
-
-        // Copy-on-write through two Heap layers: Err(Heap<Value>) → Error(Heap<ErrorValue>)
-        if let Value::Err(ref mut outer) = value {
-            if let Value::Error(ref mut ev_heap) = *outer.make_mut() {
-                ev_heap.make_mut().push_trace(entry);
-            }
-        }
-        value
-    }
-
-    /// Compute 1-based line and column from a byte offset in the source text.
-    ///
-    /// Counts newlines in `source_text[..offset]` to determine line number,
-    /// then computes column from the last newline position. If no source text
-    /// is available, returns `(0, 0)`.
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "u32↔usize: source offsets and line/column numbers fit in u32"
-    )]
-    #[expect(
-        clippy::arithmetic_side_effects,
-        reason = "column = (end - last_newline) + 1: last_newline ≤ end by construction"
-    )]
-    fn line_col_from_offset(&self, offset: u32) -> (u32, u32) {
-        let Some(src) = &self.source_text else {
-            return (0, 0);
-        };
-        let offset = offset as usize;
-        let bytes = src.as_bytes();
-        let end = offset.min(bytes.len());
-
-        let mut line: u32 = 1;
-        let mut last_newline: usize = 0;
-        for (i, &b) in bytes[..end].iter().enumerate() {
-            if b == b'\n' {
-                line = line.wrapping_add(1);
-                last_newline = i.wrapping_add(1);
-            }
-        }
-        let column = (end - last_newline) as u32 + 1;
-        (line, column)
-    }
-
     /// Evaluate a list of canonical expressions from a `CanRange`.
     fn eval_can_expr_list(&mut self, range: CanRange) -> Result<Vec<Value>, ControlAction> {
         let ids: SmallVec<[CanId; 8]> =
@@ -284,7 +205,7 @@ impl Interpreter<'_> {
                 let value = self.eval_can(receiver)?;
 
                 // Built-in types: fast path with # (hash length) support
-                if super::is_builtin_indexable(&value) {
+                if super::operator_dispatch::is_builtin_indexable(&value) {
                     let length = expr::get_collection_length(&value)
                         .map_err(|e| Self::attach_span(e.into(), span))?;
                     let idx = self.eval_can_with_hash_length(index, length)?;

compiler/ori_eval/src/interpreter/can_eval/operators.rs

@@ -72,15 +72,17 @@ impl Interpreter<'_> {
         let right_val = self.eval_can(right)?;
 
         // Primitive types use direct evaluation
-        if super::super::is_primitive_value(&left_val)
-            && super::super::is_primitive_value(&right_val)
+        if super::super::operator_dispatch::is_primitive_value(&left_val)
+            && super::super::operator_dispatch::is_primitive_value(&right_val)
         {
             return evaluate_binary(left_val, right_val, op)
                 .map_err(|e| Self::attach_span(e, span));
         }
 
         // User-defined types: dispatch through method system
-        if let Some(method) = super::super::binary_op_to_method(op, self.op_names) {
+        if let Some(method) =
+            super::super::operator_dispatch::binary_op_to_method(op, self.op_names)
+        {
             return self.eval_method_call(left_val, method, vec![right_val]);
         }
 
@@ -97,11 +99,12 @@ impl Interpreter<'_> {
         let value = self.eval_can(operand)?;
         let span = self.can_span(expr_id);
 
-        if super::super::is_primitive_value(&value) {
+        if super::super::operator_dispatch::is_primitive_value(&value) {
             return evaluate_unary(value, op).map_err(|e| Self::attach_span(e, span));
         }
 
-        if let Some(method) = super::super::unary_op_to_method(op, self.op_names) {
+        if let Some(method) = super::super::operator_dispatch::unary_op_to_method(op, self.op_names)
+        {
             return self.eval_method_call(value, method, vec![]);
         }
 

compiler/ori_eval/src/interpreter/can_eval/trace.rs

@@ -0,0 +1,93 @@
+//! Error trace injection for the `?` operator.
+//!
+//! When `?` propagates an `Err(Error(...))`, these helpers append a
+//! `TraceEntryData` with the current source location (function, file,
+//! line, column). Extracted from `can_eval/mod.rs` to keep the main
+//! dispatch module focused.
+
+use ori_ir::canon::CanId;
+use ori_patterns::{TraceEntryData, Value};
+
+use super::Interpreter;
+
+impl Interpreter<'_> {
+    /// Inject a trace entry into an error value at a `?` operator site.
+    ///
+    /// If the value is `Value::Err(Value::Error(...))`, appends a `TraceEntryData`
+    /// recording the current function name and source location. Non-error values
+    /// are returned unchanged.
+    ///
+    /// Uses `Heap::make_mut` for copy-on-write: when the error is uniquely owned
+    /// (common case — errors propagate linearly through `?`), the trace entry
+    /// is appended in place with no cloning.
+    pub(super) fn inject_trace_entry(&self, mut value: Value, can_id: CanId) -> Value {
+        // Guard: only Err(Error(...)) values carry traces
+        if !matches!(&value, Value::Err(inner) if matches!(&**inner, Value::Error(_))) {
+            return value;
+        }
+
+        // Build the function name from the call stack
+        let function_name = self.call_stack.current_frame().map_or_else(
+            || "<top-level>".to_string(),
+            |f| self.interner.lookup(f.name).to_string(),
+        );
+
+        // Compute line/column from span byte offset
+        let span = self.can_span(can_id);
+        let (line, column) = self.line_col_from_offset(span.start);
+
+        let file = self
+            .source_file_path
+            .as_deref()
+            .cloned()
+            .unwrap_or_else(|| "<unknown>".to_string());
+
+        let entry = TraceEntryData {
+            function: function_name,
+            file,
+            line,
+            column,
+        };
+
+        // Copy-on-write through two Heap layers: Err(Heap<Value>) → Error(Heap<ErrorValue>)
+        if let Value::Err(ref mut outer) = value {
+            if let Value::Error(ref mut ev_heap) = *outer.make_mut() {
+                ev_heap.make_mut().push_trace(entry);
+            }
+        }
+        value
+    }
+
+    /// Compute 1-based line and column from a byte offset in the source text.
+    ///
+    /// Counts newlines in `source_text[..offset]` to determine line number,
+    /// then computes column from the last newline position. If no source text
+    /// is available, returns `(0, 0)`.
+    #[expect(
+        clippy::cast_possible_truncation,
+        reason = "u32↔usize: source offsets and line/column numbers fit in u32"
+    )]
+    #[expect(
+        clippy::arithmetic_side_effects,
+        reason = "column = (end - last_newline) + 1: last_newline ≤ end by construction"
+    )]
+    pub(super) fn line_col_from_offset(&self, offset: u32) -> (u32, u32) {
+        let Some(src) = &self.source_text else {
+            return (0, 0);
+        };
+        let offset = offset as usize;
+        let bytes = src.as_bytes();
+        let end = offset.min(bytes.len());
+
+        let mut line: u32 = 1;
+        let mut last_newline: usize = 0;
+        for (i, &b) in bytes[..end].iter().enumerate() {
+            if b == b'\n' {
+                line = line.wrapping_add(1);
+                last_newline = i.wrapping_add(1);
+            }
+        }
+        let column = (end - last_newline) as u32 + 1;
+        (line, column)
+    }
+}

compiler/ori_eval/src/interpreter/method_dispatch/iterator/mod.rs

@@ -11,6 +11,7 @@
 
 mod consumers;
 mod next;
+mod stateful;
 
 use ori_patterns::IteratorValue;