hecks 3.13.0 → 4.0.0

data/rust/lsp/Cargo.toml

@@ -14,3 +14,39 @@ path = "src/main.rs"
 # and src/json.rs vendors a minimal JSON pair as rust/build/src/json.rs does.
 # Revisit if it ever needs to serve concurrent requests.
 [dependencies]
+
+# Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
+# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# The same table is in every crate's Cargo.toml; change them together.
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "warn"
+expect_used = "warn"
+panic = "warn"
+dbg_macro = "warn"
+todo = "warn"
+unimplemented = "warn"
+# Lints that ask for prose or an attribute on every item rather than for better code.
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+module_name_repetitions = "allow"
+too_many_lines = "allow"
+too_long_first_doc_paragraph = "allow"
+doc_markdown = "allow"
+# Numeric conversions here are deliberate: JSON numbers are f64 and ids are small.
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+# Naming heuristics that fire on ordinary short names.
+similar_names = "allow"
+many_single_char_names = "allow"
+struct_field_names = "allow"
+# Heuristics that cost more clarity than they buy here.
+redundant_pub_crate = "allow"
+future_not_send = "allow"
+significant_drop_tightening = "allow"
+match_same_arms = "allow"

data/rust/lsp/clippy.toml

@@ -0,0 +1,4 @@
+# The restriction lints (unwrap, expect, panic) guard library code; a test panics to fail.
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
+allow-panic-in-tests = true

data/rust/lsp/src/json.rs

@@ -9,14 +9,17 @@ pub enum Json {
     Bool(bool),
     Number(i64),
     String(String),
-    Array(Vec<Json>),
+    Array(Vec<Self>),
     /// Insertion-ordered pairs.
-    Object(Vec<(String, Json)>),
+    Object(Vec<(String, Self)>),
 }
 
 impl Json {
-    pub fn parse(text: &str) -> Result<Json, String> {
-        let mut p = Parser { bytes: text.as_bytes(), pos: 0 };
+    pub fn parse(text: &str) -> Result<Self, String> {
+        let mut p = Parser {
+            bytes: text.as_bytes(),
+            pos: 0,
+        };
         p.skip_ws();
         let value = p.parse_value()?;
         p.skip_ws();
@@ -26,43 +29,43 @@ impl Json {
         Ok(value)
     }
 
-    pub fn get(&self, key: &str) -> Option<&Json> {
+    pub fn get(&self, key: &str) -> Option<&Self> {
         match self {
-            Json::Object(pairs) => pairs
+            Self::Object(pairs) => pairs
                 .iter()
-                .find(|(k, v)| k == key && !matches!(v, Json::Null))
+                .find(|(k, v)| k == key && !matches!(v, Self::Null))
                 .map(|(_, v)| v),
             _ => None,
         }
     }
 
-    pub fn as_str(&self) -> Option<&str> {
+    pub const fn as_str(&self) -> Option<&str> {
         match self {
-            Json::String(s) => Some(s.as_str()),
+            Self::String(s) => Some(s.as_str()),
             _ => None,
         }
     }
 
-    pub fn as_i64(&self) -> Option<i64> {
+    pub const fn as_i64(&self) -> Option<i64> {
         match self {
-            Json::Number(n) => Some(*n),
+            Self::Number(n) => Some(*n),
             _ => None,
         }
     }
 
-    pub fn as_array(&self) -> Option<&[Json]> {
+    pub const fn as_array(&self) -> Option<&[Self]> {
         match self {
-            Json::Array(items) => Some(items.as_slice()),
+            Self::Array(items) => Some(items.as_slice()),
             _ => None,
         }
     }
 
-    pub fn string(s: impl Into<String>) -> Json {
-        Json::String(s.into())
+    pub fn string(s: impl Into<String>) -> Self {
+        Self::String(s.into())
     }
 
-    pub fn object(pairs: Vec<(&str, Json)>) -> Json {
-        Json::Object(pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
+    pub fn object(pairs: Vec<(&str, Self)>) -> Self {
+        Self::Object(pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
     }
 }
 
@@ -71,7 +74,7 @@ struct Parser<'a> {
     pos: usize,
 }
 
-impl<'a> Parser<'a> {
+impl Parser<'_> {
     fn peek(&self) -> Option<u8> {
         self.bytes.get(self.pos).copied()
     }
@@ -261,7 +264,8 @@ impl<'a> Parser<'a> {
                 }
                 Some(_) => {
                     let start = self.pos;
-                    let rest = std::str::from_utf8(&self.bytes[start..]).map_err(|e| e.to_string())?;
+                    let rest =
+                        std::str::from_utf8(&self.bytes[start..]).map_err(|e| e.to_string())?;
                     let ch = rest.chars().next().ok_or("empty remainder")?;
                     out.push(ch);
                     self.pos += ch.len_utf8();
@@ -286,9 +290,9 @@ impl<'a> Parser<'a> {
                 self.pos += 1;
             }
         }
-        if matches!(self.peek(), Some(b'e') | Some(b'E')) {
+        if matches!(self.peek(), Some(b'e' | b'E')) {
             self.pos += 1;
-            if matches!(self.peek(), Some(b'+') | Some(b'-')) {
+            if matches!(self.peek(), Some(b'+' | b'-')) {
                 self.pos += 1;
             }
             while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
@@ -369,7 +373,10 @@ mod tests {
     fn round_trips_a_request() {
         let text = r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}"#;
         let value = Json::parse(text).expect("parses");
-        assert_eq!(value.get("method").and_then(Json::as_str), Some("initialize"));
+        assert_eq!(
+            value.get("method").and_then(Json::as_str),
+            Some("initialize")
+        );
         assert_eq!(value.get("id"), Some(&Json::Number(1)));
     }
 

data/rust/lsp/src/main.rs

@@ -8,6 +8,7 @@ mod rpc;
 
 use json::Json;
 use std::collections::HashMap;
+use std::fmt::Write as _;
 use std::io::{self, BufReader, Write};
 use std::path::{Path, PathBuf};
 
@@ -88,9 +89,10 @@ impl Server {
             "exit" => return false,
             "textDocument/didOpen" => {
                 if let Some(doc) = message.get("params").and_then(|p| p.get("textDocument")) {
-                    if let (Some(uri), Some(text)) =
-                        (doc.get("uri").and_then(Json::as_str), doc.get("text").and_then(Json::as_str))
-                    {
+                    if let (Some(uri), Some(text)) = (
+                        doc.get("uri").and_then(Json::as_str),
+                        doc.get("text").and_then(Json::as_str),
+                    ) {
                         self.documents.insert(uri.to_string(), text.to_string());
                         self.check_document(uri, out);
                     }
@@ -131,12 +133,15 @@ impl Server {
                         .and_then(|p| p.get("textDocument"))
                         .and_then(|t| t.get("uri"))
                         .and_then(Json::as_str);
-                    let result = match uri.and_then(|u| self.documents.get(u)) {
-                        Some(text) => {
-                            Json::Array(outline::outline(text).iter().map(document_symbol_json).collect())
-                        }
-                        None => Json::Array(Vec::new()),
-                    };
+                    let result = Json::Array(uri.and_then(|u| self.documents.get(u)).map_or_else(
+                        Vec::new,
+                        |text| {
+                            outline::outline(text)
+                                .iter()
+                                .map(document_symbol_json)
+                                .collect()
+                        },
+                    ));
                     let _ = rpc::write_message(out, &rpc::response(id, result));
                 }
             }
@@ -200,7 +205,11 @@ impl Server {
             let _ = std::fs::create_dir_all(parent);
         }
         if let Err(e) = std::fs::write(&temp_path, &text) {
-            log(out, 1, &format!("hecks-lsp: could not stage {}: {e}", temp_path.display()));
+            log(
+                out,
+                1,
+                &format!("hecks-lsp: could not stage {}: {e}", temp_path.display()),
+            );
             return;
         }
 
@@ -233,18 +242,23 @@ impl Server {
         let dir = path.parent()?;
         let mut siblings: Vec<PathBuf> = std::fs::read_dir(dir)
             .ok()?
-            .filter_map(|e| e.ok())
+            .filter_map(std::result::Result::ok)
             .map(|e| e.path())
             .filter(|p| {
                 *p != path
-                    && matches!(p.extension().and_then(|e| e.to_str()), Some("bluebook") | Some("hecksagon"))
+                    && matches!(
+                        p.extension().and_then(|e| e.to_str()),
+                        Some("bluebook" | "hecksagon")
+                    )
             })
             .collect();
         // Sorted so a name declared in several siblings resolves deterministically.
         siblings.sort();
 
         for sibling in siblings {
-            let Ok(sibling_text) = std::fs::read_to_string(&sibling) else { continue };
+            let Ok(sibling_text) = std::fs::read_to_string(&sibling) else {
+                continue;
+            };
             let roots = outline::outline(&sibling_text);
             if let Some(symbol) = outline::find_by_name(&roots, &identifier) {
                 return Some(location(&path_to_uri(&sibling), symbol.start_line));
@@ -280,10 +294,16 @@ fn identifier_at(line_text: &str, character: usize) -> Option<String> {
 /// A zero-width `Location` at the declaring line; the outline is line-based, so no column.
 fn location(uri: &str, line_1_indexed: usize) -> Json {
     let line0 = line_1_indexed.saturating_sub(1) as i64;
-    let point = Json::object(vec![("line", Json::Number(line0)), ("character", Json::Number(0))]);
+    let point = Json::object(vec![
+        ("line", Json::Number(line0)),
+        ("character", Json::Number(0)),
+    ]);
     Json::object(vec![
         ("uri", Json::string(uri)),
-        ("range", Json::object(vec![("start", point.clone()), ("end", point)])),
+        (
+            "range",
+            Json::object(vec![("start", point.clone()), ("end", point)]),
+        ),
     ])
 }
 
@@ -291,21 +311,38 @@ fn document_symbol_json(symbol: &outline::Symbol) -> Json {
     let start0 = symbol.start_line.saturating_sub(1) as i64;
     let end0 = symbol.end_line.max(symbol.start_line).saturating_sub(1) as i64;
     let range = Json::object(vec![
-        ("start", Json::object(vec![("line", Json::Number(start0)), ("character", Json::Number(0))])),
-        ("end", Json::object(vec![("line", Json::Number(end0)), ("character", Json::Number(0))])),
+        (
+            "start",
+            Json::object(vec![
+                ("line", Json::Number(start0)),
+                ("character", Json::Number(0)),
+            ]),
+        ),
+        (
+            "end",
+            Json::object(vec![
+                ("line", Json::Number(end0)),
+                ("character", Json::Number(0)),
+            ]),
+        ),
     ]);
     Json::object(vec![
         ("name", Json::string(symbol.name.clone())),
         ("kind", Json::Number(lsp_symbol_kind(symbol.kind))),
         ("range", range.clone()),
         ("selectionRange", range),
-        ("children", Json::Array(symbol.children.iter().map(document_symbol_json).collect())),
+        (
+            "children",
+            Json::Array(symbol.children.iter().map(document_symbol_json).collect()),
+        ),
     ])
 }
 
 /// Maps a construct to an LSP `SymbolKind` number by how it reads in an outline.
-fn lsp_symbol_kind(kind: outline::Kind) -> i64 {
-    use outline::Kind::*;
+const fn lsp_symbol_kind(kind: outline::Kind) -> i64 {
+    use outline::Kind::{
+        Aggregate, Command, Entity, Policy, ProcessManager, Query, ReadModel, ValueObject,
+    };
     match kind {
         Aggregate => 5,      // Class
         ProcessManager => 5, // Class
@@ -332,11 +369,17 @@ fn publish_diagnostics(out: &mut impl Write, uri: &str, diagnostics: Vec<Json>)
         ("uri", Json::string(uri)),
         ("diagnostics", Json::Array(diagnostics)),
     ]);
-    let _ = rpc::write_message(out, &rpc::notification("textDocument/publishDiagnostics", params));
+    let _ = rpc::write_message(
+        out,
+        &rpc::notification("textDocument/publishDiagnostics", params),
+    );
 }
 
 fn log(out: &mut impl Write, severity: i64, message: &str) {
-    let params = Json::object(vec![("type", Json::Number(severity)), ("message", Json::string(message))]);
+    let params = Json::object(vec![
+        ("type", Json::Number(severity)),
+        ("message", Json::string(message)),
+    ]);
     let _ = rpc::write_message(out, &rpc::notification("window/logMessage", params));
 }
 
@@ -347,13 +390,12 @@ fn lsp_diagnostic(diag: &diagnostics::FileDiagnostic, text: &str) -> Json {
     let line_len = text
         .lines()
         .nth(diag.line.saturating_sub(1))
-        .map(|l| l.chars().count() as i64)
-        .unwrap_or(0)
+        .map_or(0, |l| l.chars().count() as i64)
         .max(1);
 
     let mut message = diag.message.clone();
     if !diag.expected.is_empty() {
-        message.push_str(&format!(" (expected one of: {})", diag.expected.join(", ")));
+        let _ = write!(message, " (expected one of: {})", diag.expected.join(", "));
     }
 
     Json::object(vec![
@@ -362,7 +404,10 @@ fn lsp_diagnostic(diag: &diagnostics::FileDiagnostic, text: &str) -> Json {
             Json::object(vec![
                 (
                     "start",
-                    Json::object(vec![("line", Json::Number(zero_based_line)), ("character", Json::Number(0))]),
+                    Json::object(vec![
+                        ("line", Json::Number(zero_based_line)),
+                        ("character", Json::Number(0)),
+                    ]),
                 ),
                 (
                     "end",
@@ -374,7 +419,10 @@ fn lsp_diagnostic(diag: &diagnostics::FileDiagnostic, text: &str) -> Json {
             ]),
         ),
         // 1 = Error, 2 = Warning (LSP DiagnosticSeverity).
-        ("severity", Json::Number(if diag.not_yet_implemented { 2 } else { 1 })),
+        (
+            "severity",
+            Json::Number(if diag.not_yet_implemented { 2 } else { 1 }),
+        ),
         ("source", Json::string("hecks-parse")),
         ("message", Json::string(message)),
     ])
@@ -386,14 +434,16 @@ fn lsp_diagnostic(diag: &diagnostics::FileDiagnostic, text: &str) -> Json {
 fn temp_path_for(uri: &str) -> PathBuf {
     let hash = fnv1a(uri.as_bytes());
     let basename = uri.rsplit('/').next().unwrap_or("buffer.bluebook");
-    std::env::temp_dir().join("hecks-lsp").join(format!("{hash:016x}-{basename}"))
+    std::env::temp_dir()
+        .join("hecks-lsp")
+        .join(format!("{hash:016x}-{basename}"))
 }
 
 fn fnv1a(bytes: &[u8]) -> u64 {
-    let mut hash: u64 = 0xcbf29ce484222325;
+    let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
     for &b in bytes {
-        hash ^= b as u64;
-        hash = hash.wrapping_mul(0x100000001b3);
+        hash ^= u64::from(b);
+        hash = hash.wrapping_mul(0x0100_0000_01b3);
     }
     hash
 }

data/rust/lsp/src/outline.rs

@@ -7,7 +7,7 @@ pub struct Symbol {
     pub kind: Kind,
     pub start_line: usize, // 1-indexed declaring line
     pub end_line: usize,   // 1-indexed line of the closing `end`
-    pub children: Vec<Symbol>,
+    pub children: Vec<Self>,
 }
 
 /// The construct keywords the outline recognizes.
@@ -35,7 +35,7 @@ const CONSTRUCTS: &[(&str, Kind)] = &[
 ];
 
 /// Whether a bare identifier can name this kind; only these are definition targets.
-pub fn is_reference_target(kind: Kind) -> bool {
+pub const fn is_reference_target(kind: Kind) -> bool {
     matches!(kind, Kind::Aggregate | Kind::Entity | Kind::ValueObject)
 }
 
@@ -57,7 +57,13 @@ pub fn outline(text: &str) -> Vec<Symbol> {
         let trimmed = raw_line.trim();
 
         if let Some((name, kind)) = opens_construct(trimmed) {
-            stack.push(Frame { name, kind, start_line: line_no, depth_at_push: depth, children: Vec::new() });
+            stack.push(Frame {
+                name,
+                kind,
+                start_line: line_no,
+                depth_at_push: depth,
+                children: Vec::new(),
+            });
             depth += 1;
             continue;
         }
@@ -69,8 +75,13 @@ pub fn outline(text: &str) -> Vec<Symbol> {
 
         if trimmed == "end" {
             depth = depth.saturating_sub(1);
-            if matches!(stack.last(), Some(frame) if frame.depth_at_push == depth) {
-                let frame = stack.pop().expect("just matched Some(frame) above");
+            if stack
+                .last()
+                .is_some_and(|frame| frame.depth_at_push == depth)
+            {
+                let Some(frame) = stack.pop() else {
+                    continue;
+                };
                 let symbol = Symbol {
                     name: frame.name,
                     kind: frame.kind,
@@ -91,10 +102,15 @@ pub fn outline(text: &str) -> Vec<Symbol> {
 
 fn opens_construct(trimmed: &str) -> Option<(String, Kind)> {
     for (keyword, kind) in CONSTRUCTS {
-        let Some(after) = trimmed.strip_prefix(keyword).and_then(|r| r.strip_prefix(" \"")) else {
+        let Some(after) = trimmed
+            .strip_prefix(keyword)
+            .and_then(|r| r.strip_prefix(" \""))
+        else {
+            continue;
+        };
+        let Some(end_quote) = after.find('"') else {
             continue;
         };
-        let Some(end_quote) = after.find('"') else { continue };
         if after[end_quote + 1..].trim() == "do" {
             return Some((after[..end_quote].to_string(), *kind));
         }

data/rust/lsp/src/rpc.rs

@@ -19,13 +19,19 @@ pub fn read_message(stdin: &mut impl BufRead) -> io::Result<Option<Json>> {
         }
         if let Some(value) = line.strip_prefix("Content-Length:") {
             content_length = Some(value.trim().parse().map_err(|e| {
-                io::Error::new(io::ErrorKind::InvalidData, format!("bad Content-Length: {e}"))
+                io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    format!("bad Content-Length: {e}"),
+                )
             })?);
         }
     }
 
     let len = content_length.ok_or_else(|| {
-        io::Error::new(io::ErrorKind::InvalidData, "message had no Content-Length header")
+        io::Error::new(
+            io::ErrorKind::InvalidData,
+            "message had no Content-Length header",
+        )
     })?;
     let mut buf = vec![0u8; len];
     stdin.read_exact(&mut buf)?;
@@ -44,7 +50,11 @@ pub fn write_message(stdout: &mut impl Write, value: &Json) -> io::Result<()> {
 }
 
 pub fn response(id: Json, result: Json) -> Json {
-    Json::object(vec![("jsonrpc", Json::string("2.0")), ("id", id), ("result", result)])
+    Json::object(vec![
+        ("jsonrpc", Json::string("2.0")),
+        ("id", id),
+        ("result", result),
+    ])
 }
 
 pub fn notification(method: &str, params: Json) -> Json {
@@ -61,7 +71,10 @@ pub fn error_response(id: Json, code: i64, message: &str) -> Json {
         ("id", id),
         (
             "error",
-            Json::object(vec![("code", Json::Number(code)), ("message", Json::string(message))]),
+            Json::object(vec![
+                ("code", Json::Number(code)),
+                ("message", Json::string(message)),
+            ]),
         ),
     ])
 }

data/rust/parser/Cargo.toml

@@ -19,3 +19,39 @@ path = "src/main.rs"
 # CI never attaches a debugger to dev binaries, so skip debuginfo to save build time.
 [profile.dev]
 debug = 0
+
+# Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
+# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# The same table is in every crate's Cargo.toml; change them together.
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "warn"
+expect_used = "warn"
+panic = "warn"
+dbg_macro = "warn"
+todo = "warn"
+unimplemented = "warn"
+# Lints that ask for prose or an attribute on every item rather than for better code.
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+module_name_repetitions = "allow"
+too_many_lines = "allow"
+too_long_first_doc_paragraph = "allow"
+doc_markdown = "allow"
+# Numeric conversions here are deliberate: JSON numbers are f64 and ids are small.
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+# Naming heuristics that fire on ordinary short names.
+similar_names = "allow"
+many_single_char_names = "allow"
+struct_field_names = "allow"
+# Heuristics that cost more clarity than they buy here.
+redundant_pub_crate = "allow"
+future_not_send = "allow"
+significant_drop_tightening = "allow"
+match_same_arms = "allow"

data/rust/parser/clippy.toml

@@ -0,0 +1,4 @@
+# The restriction lints (unwrap, expect, panic) guard library code; a test panics to fail.
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
+allow-panic-in-tests = true

data/rust/parser/src/build/closed_sets.rs

@@ -21,7 +21,12 @@ pub fn synthesize(field_name: &str, values: &[String]) -> ir::ValueObject {
         closed_set: true,
         members: values
             .iter()
-            .map(|value| vec![("value".to_string(), crate::ruby_value::Value::Str(value.clone()))])
+            .map(|value| {
+                vec![(
+                    "value".to_string(),
+                    crate::ruby_value::Value::Str(value.clone()),
+                )]
+            })
             .collect(),
     }
 }

data/rust/parser/src/build/identity.rs

@@ -70,9 +70,10 @@ pub fn resolve_identity_type(
         ));
     }
 
-    let field = as_field
-        .map(|s| s.to_string())
-        .unwrap_or_else(|| crate::build::naming::snake(&target));
+    let field = as_field.map_or_else(
+        || crate::build::naming::snake(&target),
+        std::string::ToString::to_string,
+    );
     if attributes.iter().any(|attribute| attribute.name == field) {
         return Err(Diagnostic::new(
             file,

data/rust/parser/src/build/mod.rs

@@ -3,6 +3,7 @@
 
 pub mod closed_sets;
 pub mod identity;
+pub mod named_pattern;
 pub mod naming;
 pub mod pattern_subset;
 pub mod query_derive;

data/rust/parser/src/build/named_pattern.rs

@@ -0,0 +1,26 @@
+//! The patterns a bluebook names instead of spelling: `matches: :snake_name` stands for exactly
+//! its regex. Mirrors `Hecks::Bluebook::NamedPattern`; spec/named_pattern_spec.rb holds the two
+//! tables to each other.
+
+/// Name => the regex source it stands for.
+const TABLE: &[(&str, &str)] = &[
+    ("present", r"[^ \t\n\r]"),
+    ("not_empty", r"[^\t\n\r]"),
+    ("no_whitespace", r"^[^ \t\n\r]+$"),
+    ("snake_name", r"^[a-z][a-z0-9_]*$"),
+    ("git_sha", r"^[0-9a-fA-F]{7,40}$"),
+    ("digits", r"^[0-9]+$"),
+];
+
+/// The regex source `name` stands for, or `None` when the language gives no such name.
+pub fn source(name: &str) -> Option<&'static str> {
+    TABLE
+        .iter()
+        .find(|(given, _)| *given == name)
+        .map(|(_, source)| *source)
+}
+
+/// Every name the language gives, in table order.
+pub fn names() -> Vec<&'static str> {
+    TABLE.iter().map(|(name, _)| *name).collect()
+}