hecks 3.14.0 → 5.0.0

data/rust/parser/src/lex.rs

@@ -93,7 +93,6 @@ fn ends_outside_quotes(text: &str) -> bool {
         }
         if ch == '"' {
             quoting = !quoting;
-            continue;
         }
     }
     !quoting
@@ -163,12 +162,8 @@ fn strip_comment(line: &str) -> &str {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Opener {
     None,
-    DoBlock {
-        params: Option<String>,
-    },
-    BraceBlock {
-        body: String,
-    },
+    DoBlock { params: Option<String> },
+    BraceBlock { body: String },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -194,7 +189,7 @@ const FORBIDDEN_LEADING_WORDS: &[&str] = &[
 /// Only a file's top line is receiver-qualified; a nested `Hecks.x` must stay an error.
 const FILE_RECEIVER_PREFIX: &str = "Hecks.";
 
-pub fn classify<'a>(file: &str, line: &SourceLine<'a>) -> Result<LineShape, Diagnostic> {
+pub fn classify(file: &str, line: &SourceLine<'_>) -> Result<LineShape, Diagnostic> {
     let text = line
         .text
         .strip_prefix(FILE_RECEIVER_PREFIX)
@@ -232,9 +227,8 @@ pub fn classify<'a>(file: &str, line: &SourceLine<'a>) -> Result<LineShape, Diag
             file,
             line.number,
             format!(
-                "'{}' looks like a local variable assignment at byte {top_level_eq} — this \
-                 parser never interprets bare Ruby expressions or assignment",
-                text
+                "'{text}' looks like a local variable assignment at byte {top_level_eq} — this \
+                 parser never interprets bare Ruby expressions or assignment"
             ),
         ));
     }
@@ -256,9 +250,8 @@ fn leading_identifier_end(text: &str) -> usize {
             if ch.is_ascii_alphabetic() || ch == '_' {
                 end = idx + ch.len_utf8();
                 continue;
-            } else {
-                return 0;
             }
+            return 0;
         }
         if ch.is_ascii_alphanumeric() || ch == '_' {
             end = idx + ch.len_utf8();
@@ -346,8 +339,7 @@ fn trailing_do(rest: &str) -> Option<(&str, Option<String>)> {
     if let Some(before) = trimmed.strip_suffix(" do") {
         return Some((before, None));
     }
-    if trimmed.ends_with('|') {
-        let without_trailing_pipe = &trimmed[..trimmed.len() - 1];
+    if let Some(without_trailing_pipe) = trimmed.strip_suffix('|') {
         if let Some(open_pipe) = without_trailing_pipe.rfind('|') {
             let params = &without_trailing_pipe[open_pipe + 1..];
             let before_pipe = trimmed[..open_pipe].trim_end();
@@ -400,10 +392,7 @@ fn find_top_level_brace(text: &str) -> Option<usize> {
 
 /// A `{` after `:`, `,` or `>` opens a hash literal; `>` covers a parenless `:k => { ... }`.
 fn is_hash_literal_brace(before: &str) -> bool {
-    matches!(
-        before.trim_end().chars().last(),
-        Some(':') | Some(',') | Some('>')
-    )
+    matches!(before.trim_end().chars().last(), Some(':' | ',' | '>'))
 }
 
 fn matching_brace_body(text: &str) -> Option<(String, &str)> {
@@ -488,7 +477,7 @@ pub fn capture_do_block_body<'a>(
 
     loop {
         let line = *lines.get(*pos).ok_or_else(|| {
-            let last = lines.last().map(|l| l.number).unwrap_or(0);
+            let last = lines.last().map_or(0, |l| l.number);
             Diagnostic::new(
                 file,
                 last,
@@ -566,10 +555,7 @@ mod tests {
 
     #[test]
     fn does_not_strip_a_bare_lowercase_call() {
-        assert_eq!(
-            strip_aggregate_receiver("attaches \"Governance\""),
-            None
-        );
+        assert_eq!(strip_aggregate_receiver("attaches \"Governance\""), None);
         assert_eq!(strip_aggregate_receiver("subscribe \"Deposited\""), None);
     }
 
@@ -615,7 +601,7 @@ mod tests {
             shape,
             LineShape::Call(Call {
                 word: "identified_by".to_string(),
-                args: "".to_string(),
+                args: String::new(),
                 opener: Opener::BraceBlock {
                     body: "name.value".to_string()
                 }

data/rust/parser/src/lib.rs

@@ -0,0 +1 @@
+

data/rust/parser/src/main.rs

@@ -6,7 +6,14 @@ mod canonical;
 mod diag;
 mod emit;
 mod expr;
+// The one `Hecks::Naming` port, compiled from `hecks-codegen`'s source: neither crate depends on
+// the other. This crate reads only part of it.
+#[allow(dead_code)]
+#[path = "../../codegen/src/hecks_naming.rs"]
+mod hecks_naming;
 mod ir;
+// Generated table; not every column is consumed by this binary.
+#[allow(dead_code)]
 mod keywords;
 mod lex;
 mod parse;
@@ -37,7 +44,7 @@ enum RunError {
 
 impl From<diag::Diagnostic> for RunError {
     fn from(d: diag::Diagnostic) -> Self {
-        RunError::Parse(d)
+        Self::Parse(d)
     }
 }
 
@@ -45,12 +52,17 @@ fn run(args: &[String]) -> Result<(), RunError> {
     match args.first().map(String::as_str) {
         Some("chapter") => run_chapter(&args[1..]),
         Some("resolve") => run_resolve(&args[1..]),
-        Some("coverage") => run_coverage(&args[1..]),
+        Some("adapter") => run_adapter(&args[1..]),
+        Some("world") => run_world(&args[1..]),
+        Some("coverage") => {
+            run_coverage();
+            Ok(())
+        }
         Some(other) => Err(RunError::Usage(format!(
-            "unknown subcommand '{other}' — expected 'chapter', 'resolve', or 'coverage'"
+            "unknown subcommand '{other}' — expected 'chapter', 'resolve', 'adapter', 'world', or 'coverage'"
         ))),
         None => Err(RunError::Usage(
-            "hecks-parse <chapter|resolve|coverage> ...".to_string(),
+            "hecks-parse <chapter|resolve|adapter|world|coverage> ...".to_string(),
         )),
     }
 }
@@ -143,11 +155,59 @@ fn run_resolve(args: &[String]) -> Result<(), RunError> {
     Ok(())
 }
 
+/// `hecks-parse adapter <file.adapter>...`: prints the declared adapters as a JSON array, in
+/// file order then declaration order.
+fn run_adapter(args: &[String]) -> Result<(), RunError> {
+    if args.is_empty() {
+        return Err(RunError::Usage(
+            "hecks-parse adapter <file.adapter>...".to_string(),
+        ));
+    }
+    let mut adapters = Vec::new();
+    for path in args {
+        let source = fs::read_to_string(path)
+            .map_err(|e| RunError::Usage(format!("could not read '{path}': {e}")))?;
+        adapters.extend(parse::adapter::parse_file(path, &source)?);
+    }
+    let value = emit::JsonValue::Array(adapters.iter().map(emit::adapter_json).collect());
+    println!("{}", emit::write(&value));
+    Ok(())
+}
+
+/// `hecks-parse world <file.world>...`: prints one world per distinct domain, in order of first
+/// appearance across the files, later blocks of a domain merged into the first.
+fn run_world(args: &[String]) -> Result<(), RunError> {
+    if args.is_empty() {
+        return Err(RunError::Usage(
+            "hecks-parse world <file.world>...".to_string(),
+        ));
+    }
+    let mut blocks = Vec::new();
+    for path in args {
+        let source = fs::read_to_string(path)
+            .map_err(|e| RunError::Usage(format!("could not read '{path}': {e}")))?;
+        blocks.extend(parse::world::parse_file(path, &source)?);
+    }
+    let worlds = parse::world::merge(blocks);
+    let value = emit::JsonValue::Array(worlds.iter().map(emit::world_json).collect());
+    println!("{}", emit::write(&value));
+    Ok(())
+}
+
 /// `(word, context)` pairs this parser builds real IR for, printed by `hecks-parse coverage`.
 /// A word that is only gated, never built into IR, must stay off this list.
 const COVERED_PAIRS: &[(&str, &str)] = &[
     ("bluebook", "File"),
     ("hecksagon", "File"),
+    ("adapter", "File"),
+    ("port", "Adapter"),
+    ("field", "Adapter"),
+    ("secret", "Adapter"),
+    ("world", "File"),
+    ("realm", "World"),
+    ("latest", "World"),
+    ("default_database", "World"),
+    ("default_adapter", "World"),
     ("vision", "Bluebook"),
     ("core", "Bluebook"),
     ("supporting", "Bluebook"),
@@ -248,11 +308,10 @@ const COVERED_PAIRS: &[(&str, &str)] = &[
     ("one_of", "Type"),
 ];
 
-fn run_coverage(_args: &[String]) -> Result<(), RunError> {
+fn run_coverage() {
     let pairs: Vec<String> = COVERED_PAIRS
         .iter()
         .map(|(word, context)| format!("[\"{word}\", \"{context}\"]"))
         .collect();
     println!("[{}]", pairs.join(", "));
-    Ok(())
 }

data/rust/parser/src/parse/adapter.rs

@@ -0,0 +1,157 @@
+//! The `Adapter` construct: a `.adapter` file's `Hecks.adapter "Name" do ... end` blocks, each
+//! declaring a `port`, `field`s (optionally defaulted) and `secret`s. Printed by
+//! `hecks-parse adapter`; adapters never enter `ir.json`.
+
+use crate::diag::{Diagnostic, ParseResult};
+use crate::ir;
+use crate::lex::{self, SourceLine};
+use crate::ruby_value::{self, Value};
+
+/// Parses every top-level `adapter` block of one `.adapter` file, in file order.
+///
+/// A top-level line that is exactly `require "path"` is plain Ruby, not grammar, and is skipped;
+/// any other top-level word goes through the normal gates and refuses there.
+pub fn parse_file(path: &str, source: &str) -> ParseResult<Vec<ir::Adapter>> {
+    let joined = lex::join_continuations(source);
+    let lines = lex::lines(&joined);
+    let mut pos = 0usize;
+    let mut adapters = Vec::new();
+
+    while pos < lines.len() {
+        if is_require_line(lines[pos].text) {
+            pos += 1;
+            continue;
+        }
+        let (row, call, header_line) = super::file::parse_header(path, &lines, &mut pos)?;
+        if row.inner != "Adapter" {
+            return Err(Diagnostic::new(
+                path,
+                header_line,
+                format!(
+                    "a .adapter file's own top-level blocks must all be 'adapter'; got '{}'",
+                    call.word
+                ),
+            ));
+        }
+        let name = super::file::header_name(&call)
+            .ok_or_else(|| Diagnostic::new(path, header_line, "'adapter' needs a quoted name"))?;
+        adapters.push(parse_body(path, &lines, &mut pos, name)?);
+    }
+    Ok(adapters)
+}
+
+/// `require` followed by exactly one double-quoted string, nothing else.
+fn is_require_line(text: &str) -> bool {
+    let Some(rest) = text.strip_prefix("require ") else {
+        return false;
+    };
+    let rest = rest.trim();
+    rest.len() >= 2
+        && rest.starts_with('"')
+        && rest.ends_with('"')
+        && !rest[1..rest.len() - 1].contains(['"', '\\'])
+}
+
+fn parse_body(
+    file: &str,
+    lines: &[SourceLine],
+    pos: &mut usize,
+    name: String,
+) -> ParseResult<ir::Adapter> {
+    let mut adapter = ir::Adapter {
+        name,
+        ..ir::Adapter::default()
+    };
+    while let Some(gated) = super::next_line(file, lines, pos, "Adapter")? {
+        let number = gated.line.number;
+        match gated.row.word {
+            // A repeat replaces the earlier value, as the Ruby builder's setter does.
+            "port" => {
+                adapter.port = Some(super::positional_text(
+                    file,
+                    number,
+                    "port",
+                    &gated.args,
+                    1,
+                )?);
+            }
+            "field" => {
+                let field = super::positional_symbol(file, number, "field", &gated.args, 1)?;
+                if let Some(raw) = super::named_raw(&gated.args, "default") {
+                    let value = default_value(file, number, raw)?;
+                    // A repeated key keeps its first position with the last value.
+                    match adapter.defaults.iter_mut().find(|(k, _)| *k == field) {
+                        Some(slot) => slot.1 = value,
+                        None => adapter.defaults.push((field.clone(), value)),
+                    }
+                }
+                adapter.fields.push(field);
+            }
+            "secret" => {
+                adapter.secrets.push(super::positional_symbol(
+                    file,
+                    number,
+                    "secret",
+                    &gated.args,
+                    1,
+                )?);
+            }
+            _ => {
+                return Err(super::not_built_yet(
+                    "Adapter",
+                    gated.row,
+                    file,
+                    number,
+                    &gated.call.word,
+                ))
+            }
+        }
+    }
+    Ok(adapter)
+}
+
+/// A JSON-native default: string, integer, boolean or nil. Anything else is refused rather than
+/// guessed at, and a string may use braces only for the `{name}` and `{storage_name}`
+/// placeholders (Ruby's `^(?:[^{}]|\{(?:name|storage_name)\})*$`).
+fn default_value(file: &str, line: usize, raw: &str) -> ParseResult<Value> {
+    let value = ruby_value::read(raw);
+    match &value {
+        Value::Nil | Value::Bool(_) | Value::Int(_) => {}
+        Value::Str(text) if braces_are_placeholders(text) => {}
+        Value::Str(text) => {
+            return Err(Diagnostic::new(
+                file,
+                line,
+                format!(
+                    "'field' default \"{text}\" uses braces; only {{name}} and {{storage_name}} are allowed"
+                ),
+            ))
+        }
+        _ => {
+            return Err(Diagnostic::new(
+                file,
+                line,
+                format!(
+                    "'field' default ({}) must be a string, integer, true, false or nil",
+                    raw.trim()
+                ),
+            ))
+        }
+    }
+    Ok(value)
+}
+
+fn braces_are_placeholders(text: &str) -> bool {
+    let mut rest = text;
+    while let Some(at) = rest.find(['{', '}']) {
+        let tail = &rest[at..];
+        let Some(after) = ["{name}", "{storage_name}"]
+            .iter()
+            .find_map(|p| tail.strip_prefix(p))
+        else {
+            return false;
+        };
+        rest = after;
+    }
+    true
+}

data/rust/parser/src/parse/aggregate.rs

@@ -107,6 +107,16 @@ pub struct PendingChapterGiven {
     pub file: String,
     pub line: usize,
 }
+/// An aggregate with its policies and the givens left for the chapter to resolve.
+pub type ParsedAggregate = (
+    ir::Aggregate,
+    Vec<ir::Policy>,
+    Vec<PendingChapterGiven>,
+    Vec<(usize, command::PendingCommandGiven)>,
+    Vec<entity::PendingChapterEntityGiven>,
+    Vec<entity::PendingEntityCommandGiven>,
+);
+
 /// Type-form `identified_by` resolves after the loop: its value object may be declared later.
 pub fn parse_body(
     file: &str,
@@ -116,14 +126,7 @@ pub fn parse_body(
     chapter_named_givens: &mut Vec<(String, ir::Given)>,
     // Chapter-wide entity-scoped pool, passed unchanged to every top-level entity.
     chapter_entity_named_givens: &mut Vec<(String, ir::Given)>,
-) -> ParseResult<(
-    ir::Aggregate,
-    Vec<ir::Policy>,
-    Vec<PendingChapterGiven>,
-    Vec<(usize, command::PendingCommandGiven)>,
-    Vec<entity::PendingChapterEntityGiven>,
-    Vec<entity::PendingEntityCommandGiven>,
-)> {
+) -> ParseResult<ParsedAggregate> {
     let mut aggregate = ir::Aggregate {
         name: name.to_string(),
         ..Default::default()
@@ -189,7 +192,7 @@ pub fn parse_body(
                     "description",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             // Origin, not identity: captured raw, like a literal Hash default.
             "provenance" => {
@@ -600,7 +603,13 @@ pub fn parse_body(
         }
     }
 
-    lifecycle::seal_commands(file, *pos, &aggregate.name, aggregate.lifecycle.as_ref(), &aggregate.commands)?;
+    lifecycle::seal_commands(
+        file,
+        *pos,
+        &aggregate.name,
+        aggregate.lifecycle.as_ref(),
+        &aggregate.commands,
+    )?;
 
     Ok((
         aggregate,

data/rust/parser/src/parse/chapter.rs

@@ -58,15 +58,11 @@ pub fn parse_chapter(chapter_name: &str, files: &[(String, String)]) -> ParseRes
         match row.inner {
             "Bluebook" => {
                 let declared_version = super::file::header_version(&call);
-                if bluebook.is_none() {
-                    let mut built = ir::Bluebook {
-                        name: chapter_name.to_string(),
-                        ..Default::default()
-                    };
-                    built.version = declared_version.clone();
-                    bluebook = Some(built);
-                }
-                let target = bluebook.as_mut().expect("just set above");
+                let target = bluebook.get_or_insert_with(|| ir::Bluebook {
+                    name: chapter_name.to_string(),
+                    version: declared_version.clone(),
+                    ..Default::default()
+                });
                 if let Some(version) = declared_version {
                     match target.version.as_deref() {
                         Some(existing) if existing != version => {
@@ -373,6 +369,7 @@ pub fn resolve_hecksagon_dependencies(
 
 /// Parses a `Hecks.bluebook "Name" do ... end` body into an existing accumulator.
 /// Policies bubble as in `BluebookBuilder#build`: aggregate policies first, then chapter-level.
+#[allow(clippy::too_many_arguments)] // established signature
 fn parse_body_into(
     file: &str,
     lines: &[SourceLine],
@@ -389,10 +386,7 @@ fn parse_body_into(
 ) -> ParseResult<()> {
     // The given pool spans the whole chapter, not one file: a later concept file may reference
     // a named given an earlier one declared. Entries are (owner aggregate name, `Given`).
-    loop {
-        let Some(gated) = super::next_line(file, lines, pos, "Bluebook")? else {
-            break;
-        };
+    while let Some(gated) = super::next_line(file, lines, pos, "Bluebook")? {
         let line = gated.line.number;
 
         match gated.row.word {
@@ -403,11 +397,16 @@ fn parse_body_into(
                     "vision",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             "namespace" => {
-                bluebook.namespace =
-                    Some(super::positional_text(file, line, "namespace", &gated.args, 1)?)
+                bluebook.namespace = Some(super::positional_text(
+                    file,
+                    line,
+                    "namespace",
+                    &gated.args,
+                    1,
+                )?);
             }
             "formerly_known_as" => {
                 bluebook.formerly_known_as = Some(super::positional_text(
@@ -416,7 +415,7 @@ fn parse_body_into(
                     "formerly_known_as",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             // One `Provision` row per named argument, in source order; required keys are
             // checked by Ruby's `Validation#validate_provisions!`.

data/rust/parser/src/parse/command.rs

@@ -113,6 +113,7 @@ pub struct PendingCommandGiven {
 /// Parses a `command "Name" do ... end` body.
 /// `owner` tells a self `reference_to` from a cross-reference. `preconditions` and the `owner_*`
 /// slices hold what the owner declared so far, so declaration order matters.
+#[allow(clippy::too_many_arguments)] // established signature
 pub fn parse_body(
     file: &str,
     lines: &[SourceLine],
@@ -164,7 +165,13 @@ pub fn parse_body(
                 owner_entities,
             );
             refuse_duplicate_targets(file, *pos, &command)?;
-            super::needs::refuse_undeclared(file, *pos, &command.name, &command.needs, &command.attributes)?;
+            super::needs::refuse_undeclared(
+                file,
+                *pos,
+                &command.name,
+                &command.needs,
+                &command.attributes,
+            )?;
             return Ok((command, pending));
         };
         let line = gated.line.number;
@@ -177,7 +184,7 @@ pub fn parse_body(
                     "role",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             "goal" => {
                 command.goal = Some(super::positional_literal_text(
@@ -186,7 +193,7 @@ pub fn parse_body(
                     "goal",
                     &gated.args,
                     1,
-                )?)
+                )?);
             }
             // A synthesized inline `one_of(...)` closed set is dropped; `CommandBuilder#build`
             // ignores it.
@@ -218,7 +225,9 @@ pub fn parse_body(
                     canonical: canonical::apply(&raw),
                 });
             }
-            "needs" => super::needs::declare(file, line, &command.name, &gated.args, &mut command.needs)?,
+            "needs" => {
+                super::needs::declare(file, line, &command.name, &gated.args, &mut command.needs)?;
+            }
             "provenance" => {
                 let raw = super::named_raw(&gated.args, "from")
                     .ok_or_else(|| Diagnostic::new(file, line, "'provenance' requires a from:"))?;
@@ -283,7 +292,7 @@ fn resolve_implicit_attributes(
     for job in jobs {
         match job {
             Job::BareSet(target) => {
-                resolve_bare_set(&mut command.attributes, &target, owner_attributes)
+                resolve_bare_set(&mut command.attributes, &target, owner_attributes);
             }
             Job::Append { target, fields } => resolve_append_fields(
                 &mut command.attributes,
@@ -544,7 +553,11 @@ fn build_mutation(
     }
     // `state(:field)` is the record's own field, neither argument nor literal; classified
     // before the Symbol/literal split.
-    let computed = if op == "set" { crate::expr::resolver::arithmetic_text(raw.trim()) } else { None };
+    let computed = if op == "set" {
+        crate::expr::resolver::arithmetic_text(raw.trim())
+    } else {
+        None
+    };
     let source = match state_ref(raw.trim()) {
         Some(name) => ir::MutationSource::State(name),
         None if computed.is_some() => ir::MutationSource::Expression(computed.unwrap_or_default()),
@@ -581,13 +594,12 @@ fn build_delegation(
         ));
     }
 
-    let fields = match super::named_raw(args, "with") {
-        Some(raw) => parse_hash_literal_pairs(raw)
+    let fields = super::named_raw(args, "with").map_or_else(Vec::new, |raw| {
+        parse_hash_literal_pairs(raw)
             .into_iter()
             .map(|(k, v)| (k, ruby_value::render(&ruby_value::read(&v))))
-            .collect(),
-        None => Vec::new(),
-    };
+            .collect()
+    });
     Ok(ir::Mutation::Delegate { target, fields })
 }
 
@@ -613,15 +625,22 @@ fn build_correction(
         ));
     }
 
-    let as_field = match super::named_symbol(args, "as") {
-        Some(name) => ruby_value::render(&ruby_value::Value::Str(name)),
-        None => "nil".to_string(),
+    let as_field = super::named_symbol(args, "as").map_or_else(
+        || "nil".to_string(),
+        |name| ruby_value::render(&ruby_value::Value::Str(name)),
+    );
+    let reverses = if super::named_flag(args, "reverses") {
+        "true"
+    } else {
+        "false"
     };
-    let reverses = if super::named_flag(args, "reverses") { "true" } else { "false" };
 
     let fields = vec![
         ("as".to_string(), as_field),
-        ("reason".to_string(), ruby_value::render(&ruby_value::Value::Str(reason))),
+        (
+            "reason".to_string(),
+            ruby_value::render(&ruby_value::Value::Str(reason)),
+        ),
         ("reverses".to_string(), reverses.to_string()),
     ];
     Ok(ir::Mutation::Correction { target, fields })

data/rust/parser/src/parse/domain_port.rs

@@ -68,7 +68,7 @@ fn parse_operation_body(
 
     loop {
         let Some(gated) = super::next_line(file, lines, pos, "PortOperation")? else {
-            validate_operation(file, pos_line(lines, pos), &operation)?;
+            validate_operation(file, pos_line(lines, *pos), &operation)?;
             return Ok(operation);
         };
         let line = gated.line.number;
@@ -82,7 +82,7 @@ fn parse_operation_body(
             "emits" => {
                 operation
                     .emits
-                    .push(super::positional_text(file, line, "emits", &gated.args, 1)?)
+                    .push(super::positional_text(file, line, "emits", &gated.args, 1)?);
             }
             "reference_to" => {
                 let target_raw =
@@ -109,11 +109,8 @@ fn parse_operation_body(
 }
 
 /// The last consumed line, for diagnostics; 0 when none.
-fn pos_line(lines: &[SourceLine], pos: &usize) -> usize {
-    lines
-        .get(pos.saturating_sub(1))
-        .map(|l| l.number)
-        .unwrap_or(0)
+fn pos_line(lines: &[SourceLine], pos: usize) -> usize {
+    lines.get(pos.saturating_sub(1)).map_or(0, |l| l.number)
 }
 
 /// An inbound operation must emit something. The receiver comes from the routing envelope,