chore: format

Author: indietyp

Cargo.lock

@@ -46,6 +46,8 @@ insta                          = { workspace = true }
 libtest-mimic                  = { workspace = true }
 regex                          = { workspace = true }
 similar-asserts                = { workspace = true }
+sqruff-lib                     = "0.37.3"
+sqruff-lib-core                = "0.37.3"
 testcontainers                 = { workspace = true, features = ["reusable-containers"] }
 testcontainers-modules         = { workspace = true, features = ["postgres"] }
 

libs/@local/hashql/eval/Cargo.toml

@@ -19,6 +19,10 @@
     impl_trait_in_assoc_type,
     try_blocks
 )]
+#![cfg_attr(test, feature(
+    // Library Features
+    iter_intersperse
+))]
 
 extern crate alloc;
 pub mod context;

libs/@local/hashql/eval/src/lib.rs

@@ -448,8 +448,8 @@ impl<'ctx, 'heap, A: Allocator, S: Allocator> GraphReadFilterCompiler<'ctx, 'hea
         impl Operands {
             fn cast(self, r#type: PostgresType) -> Self {
                 Self {
-                    left: self.left.cast(r#type.clone()),
-                    right: self.right.cast(r#type),
+                    left: self.left.grouped().cast(r#type.clone()),
+                    right: self.right.grouped().cast(r#type),
                 }
             }
 
@@ -476,9 +476,9 @@ impl<'ctx, 'heap, A: Allocator, S: Allocator> GraphReadFilterCompiler<'ctx, 'hea
             }
         }
 
-        let mut left = self.compile_operand(db, span, left);
-        let mut right = self.compile_operand(db, span, right);
-        let mut operands = Operands { left, right };
+        let left = self.compile_operand(db, span, left);
+        let right = self.compile_operand(db, span, right);
+        let operands = Operands { left, right };
 
         // Operands coming from jsonb extraction are untyped from Postgres' perspective.
         // Arithmetic and bitwise operators need explicit casts; comparisons work on jsonb

libs/@local/hashql/eval/src/postgres/filter/mod.rs

@@ -34,6 +34,8 @@ use hashql_mir::{
     },
 };
 use insta::{Settings, assert_snapshot};
+use sqruff_lib::core::{config::FluffConfig, linter::core::Linter};
+use sqruff_lib_core::dialects::init::DialectKind;
 
 use crate::{
     context::EvalContext,
@@ -156,6 +158,13 @@ fn compile_filter_islands<'heap>(fixture: &Fixture<'heap>, heap: &'heap Heap) ->
 
     let mut island_reports = Vec::new();
 
+    let mut linter_config = FluffConfig::default();
+    linter_config
+        .override_dialect(DialectKind::Postgres)
+        .expect("dialect should be loaded");
+    let mut linter =
+        Linter::new(linter_config, None, None, false).expect("linter should be created");
+
     for (island_id, entry_block) in postgres_islands {
         let island = &residual.islands[island_id];
 
@@ -172,10 +181,21 @@ fn compile_filter_islands<'heap>(fixture: &Fixture<'heap>, heap: &'heap Heap) ->
 
         let sql = expression.transpile_to_string();
 
+        let linted = linter
+            .lint_string(&format!("SELECT {sql}"), None, true)
+            .expect("should be valid SQL");
+
+        let mut fixed = linted.fix_string();
+        let fixed: String = fixed[7..]
+            .lines()
+            .map(|line| &line[4..])
+            .intersperse("\n")
+            .collect();
+
         island_reports.push(FilterIslandReport {
             entry_block,
             target: island.target(),
-            sql,
+            sql: fixed,
         });
     }
 
@@ -266,10 +286,24 @@ fn compile_full_query_with_mask<'heap>(
         "unexpected diagnostics from full compilation",
     );
 
+    let mut linter_config = FluffConfig::default();
+    linter_config
+        .override_dialect(DialectKind::Postgres)
+        .expect("dialect should be loaded");
+    let mut linter =
+        Linter::new(linter_config, None, None, false).expect("linter should be created");
+
     let sql = prepared_query.transpile().to_string();
+    let linted = linter
+        .lint_string(&sql, None, true)
+        .expect("should be valid SQL");
+
     let parameters = format!("{}", prepared_query.parameters);
 
-    QueryReport { sql, parameters }
+    QueryReport {
+        sql: linted.fix_string(),
+        parameters,
+    }
 }
 
 fn snapshot_settings() -> Settings {
@@ -918,7 +952,7 @@ fn unary_not() {
 
         bb0() {
             x = input.load! "val";
-            result = un.! x;
+            result = un.~ x;
             return result;
         }
     });
@@ -1021,7 +1055,7 @@ fn temporal_decision_time_interval() {
     assert_snapshot!("temporal_decision_time_interval", report.to_string());
 }
 
-/// `BinOp::BitAnd` → `BinaryOperator::BitwiseAnd` with `::bigint` casts on both operands.
+/// `BinOp::BitAnd` on integers → `BinaryOperator::BitwiseAnd` with `::bigint` casts.
 #[test]
 fn binary_bitand_bigint_cast() {
     let heap = Heap::new();
@@ -1047,3 +1081,84 @@ fn binary_bitand_bigint_cast() {
     let _guard = settings.bind_to_scope();
     assert_snapshot!("binary_bitand_bigint_cast", report.to_string());
 }
+
+/// `BinOp::BitAnd` on booleans → `VariadicOperator::And` with `::boolean` casts.
+#[test]
+fn binary_bitand_boolean_and() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; [graph::read::filter]@0/2 -> Bool {
+        decl env: (), vertex: [Opaque sym::path::Entity; ?],
+             x: Bool, y: Bool, result: Bool;
+
+        bb0() {
+            x = input.load! "a";
+            y = input.load! "b";
+            result = bin.& x y;
+            return result;
+        }
+    });
+
+    let fixture = Fixture::new(&heap, env, body);
+    let report = compile_filter_islands(&fixture, &heap);
+
+    let settings = snapshot_settings();
+    let _guard = settings.bind_to_scope();
+    assert_snapshot!("binary_bitand_boolean_and", report.to_string());
+}
+
+/// `BinOp::BitOr` on integers → `BinaryOperator::BitwiseOr` with `::bigint` casts.
+#[test]
+fn binary_bitor_bigint_cast() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; [graph::read::filter]@0/2 -> Int {
+        decl env: (), vertex: [Opaque sym::path::Entity; ?],
+             x: Int, y: Int, result: Int;
+
+        bb0() {
+            x = input.load! "a";
+            y = input.load! "b";
+            result = bin.| x y;
+            return result;
+        }
+    });
+
+    let fixture = Fixture::new(&heap, env, body);
+    let report = compile_filter_islands(&fixture, &heap);
+
+    let settings = snapshot_settings();
+    let _guard = settings.bind_to_scope();
+    assert_snapshot!("binary_bitor_bigint_cast", report.to_string());
+}
+
+/// `BinOp::BitOr` on booleans → `VariadicOperator::Or` with `::boolean` casts.
+#[test]
+fn binary_bitor_boolean_or() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; [graph::read::filter]@0/2 -> Bool {
+        decl env: (), vertex: [Opaque sym::path::Entity; ?],
+             x: Bool, y: Bool, result: Bool;
+
+        bb0() {
+            x = input.load! "a";
+            y = input.load! "b";
+            result = bin.| x y;
+            return result;
+        }
+    });
+
+    let fixture = Fixture::new(&heap, env, body);
+    let report = compile_filter_islands(&fixture, &heap);
+
+    let settings = snapshot_settings();
+    let _guard = settings.bind_to_scope();
+    assert_snapshot!("binary_bitor_boolean_or", report.to_string());
+}