test(coverage): cover reported uncovered lines across cli/lsp/planner/query

Genuine missing tests:
- planner/check_expr_parser: OR/AND second-operand unparseable paths
- planner/check_self_contradiction: OR-conjunct skip in group_predicates_by_column
- planner/schema: nullable primary-key column rejection
- lsp/position: has_windows_drive_prefix (call site is cfg!(windows)-gated)
- lsp/{drift::compute,references::search,symbols}: path_to_uri leading-slash branch

Eliminate defensive/unreachable branches (mirrors symbols.rs while-let pattern):
- check_expr_parser: drop unreachable parse_predicate guard + dead bump()
- unwrap_yaml else (types/inlay_hints/classify_yaml): fused while-let
- locator: fuse pair_key_matches let-else; symbols: drop dead let _ = stripped

Restructure LLVM attribution-flaky regions to single coverage regions:
- cli/erd/dot.rs: escape arm -> escaped.extend
- query/add_constraint/foreign_key: closure chains -> explicit for loops

Author: owjs3901

crates/vespertide-cli/src/commands/erd/dot.rs

@@ -76,10 +76,11 @@ fn escape_record_field(value: &str) -> String {
 
     for ch in value.chars() {
         match ch {
-            '\\' | '{' | '}' | '|' | '<' | '>' | '"' => {
-                escaped.push('\\');
-                escaped.push(ch);
-            }
+            // Single-statement push of the escape byte + the char so the
+            // taken-arm body maps to one coverage region (two sequential
+            // `push` calls split into adjacent regions that LLVM coverage
+            // attributes inconsistently).
+            '\\' | '{' | '}' | '|' | '<' | '>' | '"' => escaped.extend(['\\', ch]),
             _ => escaped.push(ch),
         }
     }

crates/vespertide-lsp/src/diagnostics/locator.rs

@@ -416,10 +416,11 @@ fn is_pair(node: tree_sitter::Node<'_>) -> bool {
 }
 
 fn pair_key_matches(node: tree_sitter::Node<'_>, source: &[u8], expected: &str) -> bool {
-    let Some(key) = node.named_child(0) else {
-        return false;
-    };
-    node_text(key, source).is_some_and(|text| strip_quotes(text) == expected)
+    // Fused chain so a key-less pair (no `named_child(0)`) folds into the
+    // same `false` result without a separate defensive `return` line.
+    node.named_child(0)
+        .and_then(|key| node_text(key, source))
+        .is_some_and(|text| strip_quotes(text) == expected)
 }
 
 fn node_text<'a>(node: tree_sitter::Node<'_>, source: &'a [u8]) -> Option<&'a str> {

crates/vespertide-lsp/src/diagnostics/validation/types.rs

@@ -36,16 +36,17 @@ pub(super) struct EnumValueDescriptor {
 
 /// Peel YAML's `flow_node` / `block_node` wrappers (no-op on JSON).
 pub(super) fn unwrap_yaml_node(node: tree_sitter::Node<'_>) -> tree_sitter::Node<'_> {
+    // Fused while-let so the empty-wrapper case (no usable `named_child(0)`)
+    // and the kind-mismatch case share the same loop exit — no defensive
+    // `return` line that only an (unobservable) empty tree-sitter wrapper
+    // could reach.
     let mut current = node;
-    while matches!(current.kind(), "flow_node" | "block_node") {
-        if let Some(inner) = current
+    while matches!(current.kind(), "flow_node" | "block_node")
+        && let Some(inner) = current
             .named_child(0)
             .filter(|inner| inner.id() != current.id())
-        {
-            current = inner;
-        } else {
-            return current;
-        }
+    {
+        current = inner;
     }
     current
 }

crates/vespertide-lsp/src/drift/compute.rs

@@ -365,4 +365,22 @@ mod tests {
         assert!(guess_uri(tmp.path(), "user").is_some());
         assert!(guess_uri(tmp.path(), "missing").is_none());
     }
+
+    #[test]
+    fn path_to_uri_prepends_leading_slash_for_relative_path() {
+        // A relative path never starts with `/` on any platform, so this
+        // exercises the leading-slash normalization branch deterministically
+        // (absolute POSIX paths on CI would otherwise skip it).
+        let uri = path_to_uri(std::path::Path::new("models/user.json")).expect("uri");
+        assert!(
+            uri.as_str().starts_with("file:///"),
+            "got: {}",
+            uri.as_str()
+        );
+        assert!(
+            uri.as_str().ends_with("models/user.json"),
+            "got: {}",
+            uri.as_str()
+        );
+    }
 }

crates/vespertide-lsp/src/inlay_hints.rs

@@ -372,16 +372,17 @@ fn find_pair_with_key<'tree>(
 }
 
 fn unwrap_yaml_node(node: tree_sitter::Node<'_>) -> tree_sitter::Node<'_> {
+    // Fused while-let so the empty-wrapper case (no usable `named_child(0)`)
+    // and the kind-mismatch case share the same loop exit — no defensive
+    // `return` line that only an (unobservable) empty tree-sitter wrapper
+    // could reach.
     let mut current = node;
-    while matches!(current.kind(), "flow_node" | "block_node") {
-        if let Some(inner) = current
+    while matches!(current.kind(), "flow_node" | "block_node")
+        && let Some(inner) = current
             .named_child(0)
             .filter(|inner| inner.id() != current.id())
-        {
-            current = inner;
-        } else {
-            return current;
-        }
+    {
+        current = inner;
     }
     current
 }

crates/vespertide-lsp/src/position.rs

@@ -297,4 +297,15 @@ mod tests {
 
         assert_eq!(byte_to_lsp_position(&doc, byte), pos);
     }
+
+    #[test]
+    fn has_windows_drive_prefix_detects_and_rejects() {
+        // Tested directly: the only call site sits behind `if cfg!(windows)`,
+        // so on non-Windows CI the function is otherwise never invoked.
+        assert!(has_windows_drive_prefix("C:/Users/x"));
+        assert!(has_windows_drive_prefix("d:/data"));
+        assert!(!has_windows_drive_prefix("/usr/local"));
+        assert!(!has_windows_drive_prefix("ab"));
+        assert!(!has_windows_drive_prefix(""));
+    }
 }

crates/vespertide-lsp/src/references/search.rs

@@ -735,4 +735,16 @@ mod tests {
             "declaration and CHECK expression should both be found: {out:?}"
         );
     }
+
+    #[test]
+    fn path_to_uri_prepends_leading_slash_for_relative_path() {
+        // A relative path never starts with `/` on any platform, so this
+        // exercises the leading-slash normalization branch deterministically.
+        let uri = path_to_uri(std::path::Path::new("models/user.json"));
+        assert!(
+            uri.as_str().starts_with("file:///"),
+            "got: {}",
+            uri.as_str()
+        );
+    }
 }

crates/vespertide-lsp/src/semantic_tokens/classify_yaml.rs

@@ -298,16 +298,17 @@ fn inner_scalar_range(node: tree_sitter::Node<'_>) -> std::ops::Range<usize> {
 }
 
 fn unwrap_yaml(node: tree_sitter::Node<'_>) -> tree_sitter::Node<'_> {
+    // Fused while-let so the empty-wrapper case (no usable `named_child(0)`)
+    // and the kind-mismatch case share the same loop exit — no defensive
+    // `return` line that only an (unobservable) empty tree-sitter wrapper
+    // could reach.
     let mut current = node;
-    while matches!(current.kind(), "flow_node" | "block_node") {
-        if let Some(inner) = current
+    while matches!(current.kind(), "flow_node" | "block_node")
+        && let Some(inner) = current
             .named_child(0)
             .filter(|inner| inner.id() != current.id())
-        {
-            current = inner;
-        } else {
-            return current;
-        }
+    {
+        current = inner;
     }
     current
 }

crates/vespertide-lsp/src/symbols.rs

@@ -286,7 +286,6 @@ fn direct_pair_value<'a>(
     let value = unwrap_yaml_node(pair.named_child(1)?);
     let raw = source.get(value.byte_range())?;
     let text = std::str::from_utf8(raw).ok()?;
-    let stripped = strip_quotes(text);
     // Adjust byte range to skip quotes when the value is a quoted string.
     let range = match value.kind() {
         "string" => value.named_child(0).map_or_else(
@@ -296,9 +295,6 @@ fn direct_pair_value<'a>(
         "double_quote_scalar" | "single_quote_scalar" => trim_one_byte(&value.byte_range()),
         _ => value.byte_range(),
     };
-    // Defensive: if stripping changed the byte length unexpectedly, fall
-    // back to the raw range so we never panic on slice indexing.
-    let _ = stripped;
     Some((strip_quotes(text), range))
 }
 
@@ -1005,4 +1001,16 @@ mod tests {
 
         assert!(compute("xyz_nothing_matches", &docs, None).is_empty());
     }
+
+    #[test]
+    fn path_to_uri_prepends_leading_slash_for_relative_path() {
+        // A relative path never starts with `/` on any platform, so this
+        // exercises the leading-slash normalization branch deterministically.
+        let uri = path_to_uri(std::path::Path::new("models/user.json")).expect("uri");
+        assert!(
+            uri.as_str().starts_with("file:///"),
+            "got: {}",
+            uri.as_str()
+        );
+    }
 }

crates/vespertide-planner/src/validate/check_expr_parser.rs

@@ -489,14 +489,6 @@ impl Parser {
         self.tokens.get(self.pos)
     }
 
-    fn bump(&mut self) -> Option<Token> {
-        let t = self.tokens.get(self.pos).cloned();
-        if t.is_some() {
-            self.pos += 1;
-        }
-        t
-    }
-
     fn eat_keyword(&mut self, kw: Keyword) -> bool {
         if matches!(self.peek(), Some(Token::Keyword(k)) if *k == kw) {
             self.pos += 1;
@@ -577,15 +569,20 @@ impl Parser {
                 self.pos += 1;
                 inner
             }
-            Some(Token::Ident(_)) => self.parse_predicate(),
+            Some(Token::Ident(column)) => {
+                // `peek` already confirmed the next token is an identifier;
+                // clone the column name and advance past it so `parse_predicate`
+                // receives a guaranteed-present column without a redundant
+                // (and otherwise-unreachable) re-check.
+                let column = column.clone();
+                self.pos += 1;
+                self.parse_predicate(column)
+            }
             _ => CheckExpr::Unparseable,
         }
     }
 
-    fn parse_predicate(&mut self) -> CheckExpr {
-        let Some(Token::Ident(column)) = self.bump() else {
-            return CheckExpr::Unparseable;
-        };
+    fn parse_predicate(&mut self, column: String) -> CheckExpr {
         // Look at next token to decide the predicate shape.
         let negated_for_in_or_between = self.eat_keyword(Keyword::Not);
         match self.peek().cloned() {