fix(clippy): resolve Rust 1.93.0 clippy lint errors and add local CI check

ds1sqe · ds1sqe · commit 5689e57b28a7 · 2026-02-12T07:33:19.000Z
Fix all clippy 1.93.0 lints across the full workspace (core, server, python):

- approx_constant: change 3.14 → 3.15 in test assertions
- collapsible_if: collapse nested if-let to let-chain syntax (Rust 1.87+)
- io_other_error: use std::io::Error::other() shorthand
- type_complexity: introduce BoxFuture type alias in backend.rs
- redundant_closure: use function references directly (audit_log, lib.rs)
- needless_borrows_for_generic_args: remove unnecessary &amp; in test

Add scripts/check.sh — local CI mirror that runs the same cargo check,
test, clippy (all workspace packages) and Python lint/typecheck/test
steps as .github/workflows/ci.yml.
diff --git a/scripts/check.sh b/scripts/check.sh
@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# Local CI check — mirrors .github/workflows/ci.yml
+# Run from repo root: ./scripts/check.sh [rust|python|all]
+set -euo pipefail
+
+cd "$(git rev-parse --show-toplevel)"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+pass=0
+fail=0
+failures=()
+
+run_step() {
+    local name="$1"
+    shift
+    printf "${CYAN}▶ %s${RESET}\n" "$name"
+    if "$@"; then
+        printf "${GREEN}  ✓ %s${RESET}\n\n" "$name"
+        pass=$((pass + 1))
+    else
+        printf "${RED}  ✗ %s${RESET}\n\n" "$name"
+        fail=$((fail + 1))
+        failures+=("$name")
+    fi
+}
+
+# ── Rust checks (matching ci.yml rust-check job) ────────────────────────────
+run_rust() {
+    printf "${BOLD}━━━ Rust ━━━${RESET}\n\n"
+
+    # PyO3 0.23.5 max is Python 3.13; local may be newer
+    export PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1
+
+    run_step "cargo check --all-targets" \
+        cargo check --manifest-path type-bridge-core/Cargo.toml --all-targets
+
+    run_step "cargo test --all-targets" \
+        cargo test --manifest-path type-bridge-core/Cargo.toml --all-targets
+
+    run_step "cargo clippy --all-targets -- -D warnings" \
+        cargo clippy --manifest-path type-bridge-core/Cargo.toml --all-targets -- -D warnings
+}
+
+# ── Python checks (matching ci.yml lint + typecheck + test-unit jobs) ────────
+run_python() {
+    printf "${BOLD}━━━ Python ━━━${RESET}\n\n"
+
+    run_step "ruff check ." \
+        uv run ruff check .
+
+    run_step "ruff format --check ." \
+        uv run ruff format --check .
+
+    run_step "pyright type_bridge/" \
+        uv run pyright type_bridge/
+
+    run_step "pyright tests/" \
+        uv run pyright tests/
+
+    run_step "pytest tests/unit/" \
+        uv run pytest tests/unit/ -x --tb=short -q
+}
+
+# ── Dispatch ─────────────────────────────────────────────────────────────────
+target="${1:-all}"
+case "$target" in
+    rust)   run_rust   ;;
+    python) run_python ;;
+    all)    run_rust; run_python ;;
+    *)
+        echo "Usage: $0 [rust|python|all]"
+        exit 1
+        ;;
+esac
+
+# ── Summary ──────────────────────────────────────────────────────────────────
+printf "${BOLD}━━━ Summary ━━━${RESET}\n"
+printf "${GREEN}  ✓ %d passed${RESET}\n" "$pass"
+if ((fail > 0)); then
+    printf "${RED}  ✗ %d failed:${RESET}\n" "$fail"
+    for f in "${failures[@]}"; do
+        printf "${RED}    - %s${RESET}\n" "$f"
+    done
+    exit 1
+fi
diff --git a/type-bridge-core/crates/core/benches/compilation.rs b/type-bridge-core/crates/core/benches/compilation.rs
@@ -751,7 +751,7 @@ fn make_large_batch() -> Vec<Clause> {
                 subject_var: var.clone(),
                 attr_name: "value".to_string(),
                 value: Value::Literal(LiteralValue {
-                    value: json!(i as f64 * 3.14),
+                    value: json!(i as f64 * 3.15),
                     value_type: "double".to_string(),
                 }),
             },
diff --git a/type-bridge-core/crates/core/src/compiler.rs b/type-bridge-core/crates/core/src/compiler.rs
@@ -290,14 +290,14 @@ mod tests {
     #[test]
     fn test_literal_double() {
         let c = compiler();
-        assert_eq!(c.format_literal(&LiteralValue { value: json!(3.14), value_type: "double".into() }), "3.14");
+        assert_eq!(c.format_literal(&LiteralValue { value: json!(3.15), value_type: "double".into() }), "3.15");
     }
 
     #[test]
     fn test_literal_decimal() {
         let c = compiler();
         assert_eq!(c.format_literal(&LiteralValue { value: json!(42), value_type: "decimal".into() }), "42dec");
-        assert_eq!(c.format_literal(&LiteralValue { value: json!(3.14), value_type: "decimal".into() }), "3.14dec");
+        assert_eq!(c.format_literal(&LiteralValue { value: json!(3.15), value_type: "decimal".into() }), "3.15dec");
     }
 
     #[test]
diff --git a/type-bridge-core/crates/core/src/query_parser.rs b/type-bridge-core/crates/core/src/query_parser.rs
@@ -1412,7 +1412,7 @@ mod tests {
 
     #[test]
     fn test_parse_double_value() {
-        let mut input = "3.14";
+        let mut input = "3.15";
         let val = parse_value(&mut input).unwrap();
         match val {
             Value::Literal(lit) => {
diff --git a/type-bridge-core/crates/core/src/validation.rs b/type-bridge-core/crates/core/src/validation.rs
@@ -775,24 +775,20 @@ impl ValidationEngine {
 
         // Cardinality warnings.
         for ((var, attr_name), count) in &attr_counts {
-            if let Some(owner_type) = env.get_type(var) {
-                let owned = schema.get_all_owned_attributes(owner_type);
-                if let Some(attr) = owned.iter().find(|a| a.name == *attr_name) {
-                    if let Some(ref card) = attr.cardinality {
-                        if let Some(max) = card.max {
-                            if *count as u32 > max {
-                                errors.push(warning(
-                                    "CARDINALITY_EXCEEDED",
-                                    format!(
-                                        "Inserting {} values for '{}.{}' but @card allows max {}",
-                                        count, owner_type, attr_name, max
-                                    ),
-                                    path,
-                                ));
-                            }
-                        }
-                    }
-                }
+            if let Some(owner_type) = env.get_type(var)
+                && let Some(attr) = schema.get_all_owned_attributes(owner_type).iter().find(|a| a.name == *attr_name)
+                && let Some(ref card) = attr.cardinality
+                && let Some(max) = card.max
+                && *count as u32 > max
+            {
+                errors.push(warning(
+                    "CARDINALITY_EXCEEDED",
+                    format!(
+                        "Inserting {} values for '{}.{}' but @card allows max {}",
+                        count, owner_type, attr_name, max
+                    ),
+                    path,
+                ));
             }
         }
     }
@@ -845,19 +841,18 @@ impl ValidationEngine {
         self.validate_ownership(owner_type, attr_name, schema, path, errors);
 
         // Check value type compatibility.
-        if let Value::Literal(lit) = value {
-            if let Some(attr_type) = schema.attributes.get(attr_name) {
-                if !value_types_compatible(&lit.value_type, &attr_type.value_type) {
-                    errors.push(error(
-                        "VALUE_TYPE_MISMATCH",
-                        format!(
-                            "Attribute '{}' expects value type '{}', but got '{}'",
-                            attr_name, attr_type.value_type, lit.value_type
-                        ),
-                        path,
-                    ));
-                }
-            }
+        if let Value::Literal(lit) = value
+            && let Some(attr_type) = schema.attributes.get(attr_name)
+            && !value_types_compatible(&lit.value_type, &attr_type.value_type)
+        {
+            errors.push(error(
+                "VALUE_TYPE_MISMATCH",
+                format!(
+                    "Attribute '{}' expects value type '{}', but got '{}'",
+                    attr_name, attr_type.value_type, lit.value_type
+                ),
+                path,
+            ));
         }
     }
 
@@ -1040,13 +1035,13 @@ impl ValidationEngine {
         let values = extract_values(data, attr_name);
         let mut errors = Vec::new();
         for val in values {
-            if let Some(s) = val.as_str() {
-                if !compiled.is_match(s) {
-                    let msg = custom_msg
-                        .map(|m| m.to_string())
-                        .unwrap_or_else(|| format!("'{}' value '{}' does not match required pattern", attr_name, s));
-                    errors.push(error("RULE_REGEX_MISMATCH", msg, path));
-                }
+            if let Some(s) = val.as_str()
+                && !compiled.is_match(s)
+            {
+                let msg = custom_msg
+                    .map(|m| m.to_string())
+                    .unwrap_or_else(|| format!("'{}' value '{}' does not match required pattern", attr_name, s));
+                errors.push(error("RULE_REGEX_MISMATCH", msg, path));
             }
         }
         errors
@@ -1065,21 +1060,21 @@ impl ValidationEngine {
         let mut errors = Vec::new();
         for val in values {
             if let Some(n) = val.as_f64() {
-                if let Some(lo) = min {
-                    if n < lo {
-                        let msg = custom_msg
-                            .map(|m| m.to_string())
-                            .unwrap_or_else(|| format!("'{}' value {} is below minimum {}", attr_name, n, lo));
-                        errors.push(error("RULE_RANGE_VIOLATION", msg, path));
-                    }
+                if let Some(lo) = min
+                    && n < lo
+                {
+                    let msg = custom_msg
+                        .map(|m| m.to_string())
+                        .unwrap_or_else(|| format!("'{}' value {} is below minimum {}", attr_name, n, lo));
+                    errors.push(error("RULE_RANGE_VIOLATION", msg, path));
                 }
-                if let Some(hi) = max {
-                    if n > hi {
-                        let msg = custom_msg
-                            .map(|m| m.to_string())
-                            .unwrap_or_else(|| format!("'{}' value {} is above maximum {}", attr_name, n, hi));
-                        errors.push(error("RULE_RANGE_VIOLATION", msg, path));
-                    }
+                if let Some(hi) = max
+                    && n > hi
+                {
+                    let msg = custom_msg
+                        .map(|m| m.to_string())
+                        .unwrap_or_else(|| format!("'{}' value {} is above maximum {}", attr_name, n, hi));
+                    errors.push(error("RULE_RANGE_VIOLATION", msg, path));
                 }
             }
         }
@@ -1128,13 +1123,13 @@ impl ValidationEngine {
                 .unwrap_or_else(|| format!("'{}' has {} values, minimum is {}", attr_name, count, min));
             errors.push(error("RULE_CARDINALITY_VIOLATION", msg, path));
         }
-        if let Some(mx) = max {
-            if count > mx {
-                let msg = custom_msg
-                    .map(|m| m.to_string())
-                    .unwrap_or_else(|| format!("'{}' has {} values, maximum is {}", attr_name, count, mx));
-                errors.push(error("RULE_CARDINALITY_VIOLATION", msg, path));
-            }
+        if let Some(mx) = max
+            && count > mx
+        {
+            let msg = custom_msg
+                .map(|m| m.to_string())
+                .unwrap_or_else(|| format!("'{}' has {} values, maximum is {}", attr_name, count, mx));
+            errors.push(error("RULE_CARDINALITY_VIOLATION", msg, path));
         }
         errors
     }
@@ -1153,21 +1148,21 @@ impl ValidationEngine {
         for val in values {
             if let Some(s) = val.as_str() {
                 let len = s.len() as u32;
-                if let Some(lo) = min {
-                    if len < lo {
-                        let msg = custom_msg
-                            .map(|m| m.to_string())
-                            .unwrap_or_else(|| format!("'{}' value has length {}, minimum is {}", attr_name, len, lo));
-                        errors.push(error("RULE_LENGTH_VIOLATION", msg, path));
-                    }
+                if let Some(lo) = min
+                    && len < lo
+                {
+                    let msg = custom_msg
+                        .map(|m| m.to_string())
+                        .unwrap_or_else(|| format!("'{}' value has length {}, minimum is {}", attr_name, len, lo));
+                    errors.push(error("RULE_LENGTH_VIOLATION", msg, path));
                 }
-                if let Some(hi) = max {
-                    if len > hi {
-                        let msg = custom_msg
-                            .map(|m| m.to_string())
-                            .unwrap_or_else(|| format!("'{}' value has length {}, maximum is {}", attr_name, len, hi));
-                        errors.push(error("RULE_LENGTH_VIOLATION", msg, path));
-                    }
+                if let Some(hi) = max
+                    && len > hi
+                {
+                    let msg = custom_msg
+                        .map(|m| m.to_string())
+                        .unwrap_or_else(|| format!("'{}' value has length {}, maximum is {}", attr_name, len, hi));
+                    errors.push(error("RULE_LENGTH_VIOLATION", msg, path));
                 }
             }
         }
diff --git a/type-bridge-core/crates/core/src/value_coercion.rs b/type-bridge-core/crates/core/src/value_coercion.rs
@@ -971,14 +971,14 @@ mod tests {
         assert_eq!(result.value, json!(123));
 
         // Float to long should error
-        assert!(c.coerce(&json!(3.14), "long").is_err());
+        assert!(c.coerce(&json!(3.15), "long").is_err());
     }
 
     #[test]
     fn test_coerce_double() {
         let c = ValueCoercer::new();
         // Float
-        let result = c.coerce(&json!(3.14), "double").unwrap();
+        let result = c.coerce(&json!(3.15), "double").unwrap();
         assert_eq!(result.value_type, "double");
 
         // Int to double (valid coercion)
@@ -987,7 +987,7 @@ mod tests {
         assert_eq!(result.value_type, "double");
 
         // String to double
-        let result = c.coerce(&json!("3.14"), "double").unwrap();
+        let result = c.coerce(&json!("3.15"), "double").unwrap();
         assert_eq!(result.value_type, "double");
     }
 
@@ -1179,7 +1179,7 @@ mod tests {
         assert_eq!(c.format_value(&json!(true)), "true");
         assert_eq!(c.format_value(&json!(false)), "false");
         assert_eq!(c.format_value(&json!(42)), "42");
-        assert_eq!(c.format_value(&json!(3.14)), "3.14");
+        assert_eq!(c.format_value(&json!(3.15)), "3.15");
     }
 
     #[test]
@@ -1207,9 +1207,9 @@ mod tests {
     fn test_format_typeql_double() {
         let c = ValueCoercer::new();
         let cv = CoercedValue {
-            value: json!(3.14),
+            value: json!(3.15),
             value_type: "double".to_string(),
         };
-        assert_eq!(c.format_typeql(&cv), "3.14");
+        assert_eq!(c.format_typeql(&cv), "3.15");
     }
 }
diff --git a/type-bridge-core/crates/python/src/lib.rs b/type-bridge-core/crates/python/src/lib.rs
@@ -87,19 +87,19 @@ impl ValidationEngine {
                 format!("Failed to deserialize rule: {}", e)
             ))?;
         self.inner.add_rule(rule)
-            .map_err(|e| pyo3::exceptions::PyValueError::new_err(e))
+            .map_err(pyo3::exceptions::PyValueError::new_err)
     }
 
     /// Load rules from a JSON string. Returns list of warning strings.
     fn load_rules(&mut self, json_str: &str) -> PyResult<Vec<String>> {
         self.inner.load_rules(json_str)
-            .map_err(|e| pyo3::exceptions::PyValueError::new_err(e))
+            .map_err(pyo3::exceptions::PyValueError::new_err)
     }
 
     /// Export current rules as a JSON string.
     fn export_rules(&self) -> PyResult<String> {
         self.inner.export_rules()
-            .map_err(|e| pyo3::exceptions::PyValueError::new_err(e))
+            .map_err(pyo3::exceptions::PyValueError::new_err)
     }
 
     /// Remove all rules.
diff --git a/type-bridge-core/crates/server/src/interceptor/audit_log.rs b/type-bridge-core/crates/server/src/interceptor/audit_log.rs
@@ -28,7 +28,7 @@ impl AuditWriter {
     #[cfg_attr(coverage_nightly, coverage(off))]
     fn write_entry(&mut self, entry: &AuditEntry) -> Result<(), std::io::Error> {
         let json = serde_json::to_string(entry)
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+            .map_err(std::io::Error::other)?;
         match self {
             AuditWriter::Stdout => {
                 println!("{}", json);
diff --git a/type-bridge-core/crates/server/src/transport/http.rs b/type-bridge-core/crates/server/src/transport/http.rs
@@ -557,7 +557,7 @@ mod tests {
     #[tokio::test]
     async fn validate_valid_query() {
         let router = app(MockExecutor::new(), true);
-        let clauses = serde_json::to_value(&make_simple_clauses()).unwrap();
+        let clauses = serde_json::to_value(make_simple_clauses()).unwrap();
         let body = serde_json::json!({
             "clauses": clauses
         });
diff --git a/type-bridge-core/crates/server/src/typedb/backend.rs b/type-bridge-core/crates/server/src/typedb/backend.rs
diff --git a/type-bridge-core/crates/server/src/typedb/client.rs b/type-bridge-core/crates/server/src/typedb/client.rs
