squawk-cli 2.48.0__tar.gz → 2.49.0__tar.gz

{squawk_cli-2.48.0 → squawk_cli-2.49.0}/Cargo.lock

@@ -1545,9 +1545,9 @@ checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "openssl"
-version = "0.10.73"
+version = "0.10.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8"
+checksum = "f38c4372413cdaaf3cc79dd92d29d7d9f5ab09b51b10dded508fb90bb70b9222"
 dependencies = [
  "bitflags 2.9.3",
  "cfg-if",
@@ -1586,9 +1586,9 @@ dependencies = [
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.109"
+version = "0.9.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90096e2e47630d78b7d1c20952dc621f957103f8bc2c8359ec81290d75238571"
+checksum = "13ce1245cd07fcc4cfdb438f7507b0c7e4f3849a69fd84d52374c66d83741bb6"
 dependencies = [
  "cc",
  "libc",
@@ -1816,9 +1816,9 @@ checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "rand"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
 dependencies = [
  "libc",
  "rand_chacha",
@@ -2385,7 +2385,7 @@ dependencies = [
 
 [[package]]
 name = "squawk"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",
@@ -2415,17 +2415,23 @@ dependencies = [
 
 [[package]]
 name = "squawk-fmt"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
+ "anyhow",
+ "camino",
+ "clap",
+ "dir-test",
  "insta",
  "itertools",
+ "rowan",
+ "squawk-lexer",
  "squawk-syntax",
  "tiny_pretty",
 ]
 
 [[package]]
 name = "squawk-github"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "jsonwebtoken",
  "log",
@@ -2436,7 +2442,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-ide"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "annotate-snippets",
  "etcetera",
@@ -2458,14 +2464,14 @@ dependencies = [
 
 [[package]]
 name = "squawk-lexer"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "insta",
 ]
 
 [[package]]
 name = "squawk-linter"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "annotate-snippets",
  "enum-iterator",
@@ -2480,7 +2486,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-parser"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -2493,7 +2499,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-server"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "anyhow",
  "crossbeam-channel",
@@ -2519,11 +2525,12 @@ dependencies = [
 
 [[package]]
 name = "squawk-syntax"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "annotate-snippets",
  "camino",
  "dir-test",
+ "either",
  "insta",
  "rowan",
  "smol_str",
@@ -2532,7 +2539,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-thread"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
@@ -2544,7 +2551,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-wasm"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3420,7 +3427,7 @@ checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
 
 [[package]]
 name = "xtask"
-version = "2.48.0"
+version = "2.49.0"
 dependencies = [
  "anyhow",
  "camino",

{squawk_cli-2.48.0 → squawk_cli-2.49.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "2.48.0"
+version = "2.49.0"
 edition = "2024"
 rust-version = "1.94"
 authors = ["Squawk Team & Contributors"]
@@ -22,7 +22,11 @@ glob = "0.3.1"
 insta = "1.39.0"
 jsonwebtoken = { version = "10.3.0", features = ["rust_crypto"] }
 log = "0.4.25"
-reqwest = { version = "0.11.27", features = ["native-tls-vendored", "blocking", "json"] }
+reqwest = { version = "0.11.27", features = [
+  "native-tls-vendored",
+  "blocking",
+  "json",
+] }
 la-arena = "0.3.1"
 serde = { version = "1.0.215", features = ["derive"] }
 serde_json = "1.0"
@@ -52,6 +56,7 @@ console_error_panic_hook = "0.1.7"
 console_log = "1.0.0"
 annotate-snippets = "0.12.4"
 anyhow = "1.0.94"
+either = "1.15.0"
 convert_case = "0.7.1"
 clap = { version = "4.5.8", features = ["derive", "env"] }
 ungrammar = "1.1.4"
@@ -72,14 +77,14 @@ rustc-hash = "2.1.1"
 
 # local
 # we have to make the versions explicit otherwise `cargo publish` won't work
-squawk-github = { path = "./crates/squawk_github", version = "2.48.0" }
-squawk-ide = { path = "./crates/squawk_ide", version = "2.48.0" }
-squawk-lexer = { path = "./crates/squawk_lexer", version = "2.48.0" }
-squawk-parser = { path = "./crates/squawk_parser", version = "2.48.0" }
-squawk-syntax = { path = "./crates/squawk_syntax", version = "2.48.0" }
-squawk-linter = { path = "./crates/squawk_linter", version = "2.48.0" }
-squawk-server = { path = "./crates/squawk_server", version = "2.48.0" }
-squawk-thread = { path = "./crates/squawk_thread", version = "2.48.0" }
+squawk-github = { path = "./crates/squawk_github", version = "2.49.0" }
+squawk-ide = { path = "./crates/squawk_ide", version = "2.49.0" }
+squawk-lexer = { path = "./crates/squawk_lexer", version = "2.49.0" }
+squawk-parser = { path = "./crates/squawk_parser", version = "2.49.0" }
+squawk-syntax = { path = "./crates/squawk_syntax", version = "2.49.0" }
+squawk-linter = { path = "./crates/squawk_linter", version = "2.49.0" }
+squawk-server = { path = "./crates/squawk_server", version = "2.49.0" }
+squawk-thread = { path = "./crates/squawk_thread", version = "2.49.0" }
 
 [workspace.lints.clippy]
 collapsible_else_if = "allow"

{squawk_cli-2.48.0 → squawk_cli-2.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squawk-cli
-Version: 2.48.0
+Version: 2.49.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS

{squawk_cli-2.48.0 → squawk_cli-2.49.0}/crates/squawk/README.md

@@ -265,7 +265,7 @@ to your project's `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/sbdchd/squawk
-    rev: 2.48.0
+    rev: 2.49.0
     hooks:
       - id: squawk
         files: path/to/postgres/migrations/written/in/sql

{squawk_cli-2.48.0 → squawk_cli-2.49.0}/crates/squawk_github/src/app.rs

@@ -11,7 +11,7 @@ use serde_json::Value;
 use std::time::Duration;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-pub(crate) const SQUAWK_USER_AGENT: &str = "squawk/2.48.0";
+pub(crate) const SQUAWK_USER_AGENT: &str = "squawk/2.49.0";
 
 #[derive(Debug, Serialize)]
 struct CommentBody {

squawk_cli-2.49.0/crates/squawk_ide/src/ast_nav.rs

@@ -0,0 +1,332 @@
+/// [`ast_nav`] operates on ast nodes. Functions should take in and return ast nodes.
+///
+/// There shouldn't be any dependency on Salsa.
+use squawk_syntax::{
+    SyntaxNode, SyntaxToken,
+    ast::{self, AstNode},
+};
+use std::iter;
+
+use crate::symbols::Name;
+
+pub(crate) fn find_cte_with_table(
+    name_ref: &ast::NameRef,
+    cte_name: &Name,
+) -> Option<ast::WithTable> {
+    let with_clause = name_ref
+        .syntax()
+        .ancestors()
+        .find_map(|query| ast::WithQuery::cast(query)?.with_clause())?;
+
+    let is_recursive = with_clause.recursive_token().is_some();
+    for with_table in with_clause.with_tables() {
+        if let Some(name) = with_table.name()
+            && Name::from_node(&name) == *cte_name
+        {
+            // Skip if we're inside this CTE's definition (CTE doesn't shadow itself)
+            if !is_recursive
+                && with_table
+                    .syntax()
+                    .text_range()
+                    .contains_range(name_ref.syntax().text_range())
+            {
+                continue;
+            }
+            return Some(with_table);
+        }
+    }
+    None
+}
+
+#[derive(Debug)]
+pub(crate) enum ParentQuery {
+    Select(ast::Select),
+    Update(ast::Update),
+    Delete(ast::Delete),
+    Insert(ast::Insert),
+    Merge(ast::Merge),
+}
+
+pub(crate) fn target_parent_query(target: ast::Target) -> Option<ParentQuery> {
+    node_parent_query(target.syntax())
+}
+
+pub(crate) fn node_parent_query(node: &SyntaxNode) -> Option<ParentQuery> {
+    use ParentQuery::*;
+
+    for ancestor in node.ancestors() {
+        let result = if let Some(select) = ast::Select::cast(ancestor.clone()) {
+            Select(select)
+        } else if let Some(update) = ast::Update::cast(ancestor.clone()) {
+            Update(update)
+        } else if let Some(insert) = ast::Insert::cast(ancestor.clone()) {
+            Insert(insert)
+        } else if let Some(delete) = ast::Delete::cast(ancestor.clone()) {
+            Delete(delete)
+        } else if let Some(merge) = ast::Merge::cast(ancestor) {
+            Merge(merge)
+        } else {
+            continue;
+        };
+
+        return Some(result);
+    }
+
+    None
+}
+
+#[derive(Debug)]
+pub(crate) enum SelectContext {
+    Compound(ast::CompoundSelect),
+    Single(ast::Select),
+}
+
+impl SelectContext {
+    pub(crate) fn iter(&self) -> Option<Box<dyn Iterator<Item = ast::Select>>> {
+        fn variant_iter(
+            variant: ast::SelectVariant,
+        ) -> Option<Box<dyn Iterator<Item = ast::Select>>> {
+            match variant {
+                ast::SelectVariant::Select(select) => Some(Box::new(iter::once(select))),
+                ast::SelectVariant::CompoundSelect(compound) => compound_iter(&compound),
+                ast::SelectVariant::ParenSelect(_)
+                | ast::SelectVariant::SelectInto(_)
+                | ast::SelectVariant::Table(_)
+                | ast::SelectVariant::Values(_) => None,
+            }
+        }
+
+        fn compound_iter(
+            node: &ast::CompoundSelect,
+        ) -> Option<Box<dyn Iterator<Item = ast::Select>>> {
+            let lhs_iter = node
+                .lhs()
+                .map(variant_iter)
+                .unwrap_or_else(|| Some(Box::new(iter::empty())))?;
+            let rhs_iter = node
+                .rhs()
+                .map(variant_iter)
+                .unwrap_or_else(|| Some(Box::new(iter::empty())))?;
+            Some(Box::new(lhs_iter.chain(rhs_iter)))
+        }
+
+        match self {
+            SelectContext::Compound(compound) => compound_iter(compound),
+            SelectContext::Single(select) => Some(Box::new(iter::once(select.clone()))),
+        }
+    }
+}
+
+pub(crate) fn find_select_parent(token: SyntaxToken) -> Option<SelectContext> {
+    let mut found_select = None;
+    let mut found_compound = None;
+
+    for ancestor in token.parent_ancestors() {
+        if let Some(compound_select) = ast::CompoundSelect::cast(ancestor.clone()) {
+            if compound_select.union_token().is_some() && compound_select.all_token().is_some() {
+                found_compound = Some(SelectContext::Compound(compound_select));
+            } else {
+                break;
+            }
+        }
+
+        if found_select.is_none()
+            && let Some(select) = ast::Select::cast(ancestor)
+        {
+            found_select = Some(SelectContext::Single(select));
+        }
+    }
+
+    found_compound.or(found_select)
+}
+
+///
+/// ```sql
+/// with t as (select 1)
+/// select * from t;
+/// -- becomes
+/// select 1
+/// ```
+pub(crate) fn select_from_with_query(query: ast::WithQuery) -> Option<ast::Select> {
+    let select_variant = match query {
+        ast::WithQuery::Select(select) => ast::SelectVariant::Select(select),
+        ast::WithQuery::ParenSelect(paren_select) => paren_select.select()?,
+        ast::WithQuery::CompoundSelect(compound_select) => {
+            ast::SelectVariant::CompoundSelect(compound_select)
+        }
+        _ => return None,
+    };
+
+    select_from_variant(select_variant)
+}
+
+/// Extract nested select ignoring, select into, table, values
+///
+/// ```sql
+/// ((select 1))
+/// -- or
+/// select 1 union select 2
+/// -- become
+/// select 1
+/// ```
+pub(crate) fn select_from_variant(select_variant: ast::SelectVariant) -> Option<ast::Select> {
+    match select_variant {
+        ast::SelectVariant::Select(select) => return Some(select),
+        ast::SelectVariant::CompoundSelect(compound) => {
+            return select_from_variant(compound.lhs()?);
+        }
+        ast::SelectVariant::ParenSelect(paren_select) => {
+            return select_from_variant(paren_select.select()?);
+        }
+        ast::SelectVariant::SelectInto(_)
+        | ast::SelectVariant::Table(_)
+        | ast::SelectVariant::Values(_) => {
+            return None;
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum ParentSouce {
+    Alias(ast::Alias),
+    CreateTable(ast::CreateTableLike),
+    CreateTableAs(ast::CreateTableAs),
+    CreateView(ast::CreateViewLike),
+    ParenSelect(ast::ParenSelect),
+    WithTable(ast::WithTable),
+}
+
+pub(crate) fn parent_source(node: &SyntaxNode) -> Option<ParentSouce> {
+    if let Some(paren_select) = ast::ParenSelect::cast(node.clone()) {
+        return Some(ParentSouce::ParenSelect(paren_select));
+    }
+
+    for ancestor in node.ancestors() {
+        if let Some(paren_select) = ast::ParenSelect::cast(ancestor.clone()) {
+            return Some(ParentSouce::ParenSelect(paren_select));
+        }
+
+        if let Some(alias) = ast::Alias::cast(ancestor.clone()) {
+            return Some(ParentSouce::Alias(alias));
+        }
+
+        if let Some(with_table) = ast::WithTable::cast(ancestor.clone()) {
+            return Some(ParentSouce::WithTable(with_table));
+        }
+
+        if let Some(create_view) = ast::CreateViewLike::cast(ancestor.clone()) {
+            return Some(ParentSouce::CreateView(create_view));
+        }
+
+        if let Some(create_table_as) = ast::CreateTableAs::cast(ancestor.clone()) {
+            return Some(ParentSouce::CreateTableAs(create_table_as));
+        }
+
+        if let Some(create_table) = ast::CreateTableLike::cast(ancestor.clone()) {
+            return Some(ParentSouce::CreateTable(create_table));
+        }
+    }
+
+    None
+}
+
+struct UnwrapParenExpr {
+    current: Option<ast::Expr>,
+}
+
+impl Iterator for UnwrapParenExpr {
+    type Item = ast::Expr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let expr = self.current.take()?;
+        if let ast::Expr::ParenExpr(paren_expr) = &expr {
+            self.current = paren_expr.expr();
+        }
+        Some(expr)
+    }
+}
+
+pub(crate) fn unwrap_paren_expr(expr: ast::Expr) -> impl Iterator<Item = ast::Expr> {
+    UnwrapParenExpr {
+        current: Some(expr),
+    }
+}
+
+pub(crate) fn iter_from_clause(
+    from_clause: &ast::FromClause,
+) -> impl Iterator<Item = ast::FromItem> {
+    from_clause.from_items().chain(
+        from_clause
+            .join_exprs()
+            .flat_map(|join_expr| JoinExprIter::new(&join_expr)),
+    )
+}
+
+pub(crate) fn iter_join_expr(join_expr: &ast::JoinExpr) -> impl Iterator<Item = ast::FromItem> {
+    JoinExprIter::new(join_expr)
+}
+
+struct JoinExprIter {
+    stack: Vec<JoinExprIterFrame>,
+}
+
+impl JoinExprIter {
+    fn new(join_expr: &ast::JoinExpr) -> Self {
+        Self {
+            stack: vec![JoinExprIterFrame {
+                join_expr: join_expr.clone(),
+                state: JoinExprIterState::JoinExpr,
+            }],
+        }
+    }
+}
+
+struct JoinExprIterFrame {
+    join_expr: ast::JoinExpr,
+    state: JoinExprIterState,
+}
+
+#[derive(Clone, Copy)]
+enum JoinExprIterState {
+    FromItem,
+    Join,
+    JoinExpr,
+}
+
+impl Iterator for JoinExprIter {
+    type Item = ast::FromItem;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(frame) = self.stack.last_mut() {
+            match frame.state {
+                JoinExprIterState::JoinExpr => {
+                    frame.state = JoinExprIterState::FromItem;
+
+                    if let Some(nested_join) = frame.join_expr.join_expr() {
+                        self.stack.push(JoinExprIterFrame {
+                            join_expr: nested_join,
+                            state: JoinExprIterState::JoinExpr,
+                        });
+                    }
+                }
+                JoinExprIterState::FromItem => {
+                    frame.state = JoinExprIterState::Join;
+
+                    if let Some(from_item) = frame.join_expr.from_item() {
+                        return Some(from_item);
+                    }
+                }
+                JoinExprIterState::Join => {
+                    let from_item = frame.join_expr.join().and_then(|join| join.from_item());
+                    self.stack.pop();
+
+                    if from_item.is_some() {
+                        return from_item;
+                    }
+                }
+            }
+        }
+
+        None
+    }
+}