squawk-cli 2.55.0__tar.gz → 2.56.0__tar.gz

{squawk_cli-2.55.0 → squawk_cli-2.56.0}/Cargo.lock

@@ -2435,7 +2435,7 @@ dependencies = [
 
 [[package]]
 name = "squawk"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",
@@ -2466,7 +2466,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-fmt"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "anyhow",
  "camino",
@@ -2482,7 +2482,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-github"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "jsonwebtoken",
  "log",
@@ -2493,7 +2493,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-ide"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "annotate-snippets",
  "etcetera",
@@ -2515,14 +2515,14 @@ dependencies = [
 
 [[package]]
 name = "squawk-lexer"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "insta",
 ]
 
 [[package]]
 name = "squawk-linter"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "annotate-snippets",
  "enum-iterator",
@@ -2537,7 +2537,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-parser"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -2550,7 +2550,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-server"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "anyhow",
  "crossbeam-channel",
@@ -2576,7 +2576,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-syntax"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -2590,7 +2590,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-thread"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
@@ -2602,7 +2602,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-wasm"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3478,7 +3478,7 @@ checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
 
 [[package]]
 name = "xtask"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "anyhow",
  "camino",

{squawk_cli-2.55.0 → squawk_cli-2.56.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "2.55.0"
+version = "2.56.0"
 edition = "2024"
 rust-version = "1.94"
 authors = ["Squawk Team & Contributors"]
@@ -79,14 +79,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.55.0" }
-squawk-ide = { path = "./crates/squawk_ide", version = "2.55.0" }
-squawk-lexer = { path = "./crates/squawk_lexer", version = "2.55.0" }
-squawk-parser = { path = "./crates/squawk_parser", version = "2.55.0" }
-squawk-syntax = { path = "./crates/squawk_syntax", version = "2.55.0" }
-squawk-linter = { path = "./crates/squawk_linter", version = "2.55.0" }
-squawk-server = { path = "./crates/squawk_server", version = "2.55.0" }
-squawk-thread = { path = "./crates/squawk_thread", version = "2.55.0" }
+squawk-github = { path = "./crates/squawk_github", version = "2.56.0" }
+squawk-ide = { path = "./crates/squawk_ide", version = "2.56.0" }
+squawk-lexer = { path = "./crates/squawk_lexer", version = "2.56.0" }
+squawk-parser = { path = "./crates/squawk_parser", version = "2.56.0" }
+squawk-syntax = { path = "./crates/squawk_syntax", version = "2.56.0" }
+squawk-linter = { path = "./crates/squawk_linter", version = "2.56.0" }
+squawk-server = { path = "./crates/squawk_server", version = "2.56.0" }
+squawk-thread = { path = "./crates/squawk_thread", version = "2.56.0" }
 
 [workspace.lints.clippy]
 collapsible_else_if = "allow"

{squawk_cli-2.55.0 → squawk_cli-2.56.0}/PKG-INFO

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

{squawk_cli-2.55.0 → squawk_cli-2.56.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.55.0
+    rev: v2.56.0
     hooks:
       - id: squawk
         files: path/to/postgres/migrations/written/in/sql

{squawk_cli-2.55.0 → squawk_cli-2.56.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.55.0";
+pub(crate) const SQUAWK_USER_AGENT: &str = "squawk/2.56.0";
 
 #[derive(Debug, Serialize)]
 struct CommentBody {

{squawk_cli-2.55.0 → squawk_cli-2.56.0}/crates/squawk_ide/src/ast_nav.rs

@@ -13,28 +13,30 @@ pub(crate) fn find_cte_with_table(
     name_ref: &ast::NameRef,
     cte_name: &Name,
 ) -> Option<ast::WithTable> {
-    let with_clause = name_ref
+    let ref_start = name_ref.syntax().text_range().start();
+
+    for with_clause in 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
+        .filter_map(|query| ast::WithQuery::cast(query)?.with_clause())
+    {
+        let is_recursive = with_clause.recursive_token().is_some();
+        if let Some(with_table) = with_clause
+            .with_tables()
+            // Without RECURSIVE, only CTEs before the reference are visible.
+            .filter(|with_table| {
+                is_recursive || with_table.syntax().text_range().end() <= ref_start
+            })
+            .find(|with_table| {
+                with_table
+                    .name()
+                    .is_some_and(|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
 }
 
@@ -205,6 +207,7 @@ pub(crate) enum ParentSouce {
     CreateTableAs(ast::CreateTableAs),
     CreateView(ast::CreateViewLike),
     ParenSelect(ast::ParenSelect),
+    SelectInto(ast::SelectInto),
     WithTable(ast::WithTable),
 }
 
@@ -237,6 +240,10 @@ pub(crate) fn parent_source(node: &SyntaxNode) -> Option<ParentSouce> {
         if let Some(create_table) = ast::CreateTableLike::cast(ancestor.clone()) {
             return Some(ParentSouce::CreateTable(create_table));
         }
+
+        if let Some(select_into) = ast::SelectInto::cast(ancestor.clone()) {
+            return Some(ParentSouce::SelectInto(select_into));
+        }
     }
 
     None

{squawk_cli-2.55.0 → squawk_cli-2.56.0}/crates/squawk_ide/src/classify.rs

@@ -724,6 +724,13 @@ pub(crate) fn classify_name_ref(node: &SyntaxNode) -> Option<NameRefClass> {
             // (anything in SELECT except FROM clause)
             return Some(NameRefClass::SelectColumn);
         }
+        if ast::CompoundSelect::can_cast(ancestor.kind())
+            && in_order_by_clause
+            && let Some(parent) = node.parent()
+            && ast::SortBy::can_cast(parent.kind())
+        {
+            return Some(NameRefClass::SelectOrderByAliasOrColumn);
+        }
         if ast::ColumnList::can_cast(ancestor.kind()) {
             in_column_list = true;
         }
@@ -848,6 +855,9 @@ pub(crate) fn classify_def_node(def_node: &SyntaxNode) -> Option<LocationKind> {
         if ast::CreateTableAs::can_cast(ancestor.kind()) {
             return Some(LocationKind::Table);
         }
+        if ast::SelectInto::can_cast(ancestor.kind()) {
+            return Some(LocationKind::Table);
+        }
         if ast::CreateIndex::can_cast(ancestor.kind()) {
             return Some(LocationKind::Index);
         }

{squawk_cli-2.55.0 → squawk_cli-2.56.0}/crates/squawk_ide/src/collect.rs

@@ -102,14 +102,12 @@ fn resolved_to_column_ptrs(
                 .map(|(name, _ty)| (name, None))
                 .collect()
         }
-        ResolvedTableName::SelectInto(select_into) => select_into
-            .select_clause()
-            .and_then(|c| c.target_list())
-            .map(|t| target_list_columns_with_types(&t))
-            .unwrap_or_default()
-            .into_iter()
-            .map(|(name, _ty)| (name, None))
-            .collect(),
+        ResolvedTableName::SelectInto(select_into) => {
+            select_into_columns_with_types(db, file, &select_into)
+                .into_iter()
+                .map(|(name, _ty)| (name, None))
+                .collect()
+        }
         ResolvedTableName::View(create_view_like) => {
             view_like_columns_with_types(db, file, &create_view_like)
                 .into_iter()
@@ -199,11 +197,9 @@ fn resolved_to_columns_with_types(
         ResolvedTableName::TableAs(create_table_as) => {
             select_columns_with_types(db, file, &create_table_as.query())
         }
-        ResolvedTableName::SelectInto(select_into) => select_into
-            .select_clause()
-            .and_then(|c| c.target_list())
-            .map(|t| target_list_columns_with_types(&t))
-            .unwrap_or_default(),
+        ResolvedTableName::SelectInto(select_into) => {
+            select_into_columns_with_types(db, file, &select_into)
+        }
         ResolvedTableName::View(create_view_like) => {
             view_like_columns_with_types(db, file, &create_view_like)
         }
@@ -225,6 +221,27 @@ pub(crate) fn create_table_as_columns_with_types(
     vec![]
 }
 
+pub(crate) fn select_into_columns_with_types(
+    db: &dyn Db,
+    file: File,
+    select_into: &ast::SelectInto,
+) -> Vec<(Name, Option<Type>)> {
+    let Some(target_list) = select_into.select_clause().and_then(|c| c.target_list()) else {
+        return vec![];
+    };
+    let from_clause = select_into.from_clause();
+
+    for file in list_files(db, file) {
+        let columns =
+            target_list_columns_with_types_in_file(db, file, &target_list, from_clause.as_ref());
+        if !columns.is_empty() {
+            return columns;
+        }
+    }
+
+    vec![]
+}
+
 fn target_list_columns_with_types_in_file(
     db: &dyn Db,
     file: File,
@@ -280,45 +297,7 @@ fn select_columns_with_types(
             target_list_columns_with_types_in_file(db, file, &target_list, from_clause.as_ref())
         }
         ast::SelectVariant::Values(values) => columns_from_values(values),
-        ast::SelectVariant::Table(table) => {
-            let Some(path) = table.relation_name().and_then(|r| r.path()) else {
-                return vec![];
-            };
-            let Some((schema, table_name)) = name::schema_and_name_path(&path) else {
-                return vec![];
-            };
-            let name_ref = path.segment().and_then(|s| s.name_ref());
-            let position = table.syntax().text_range().start();
-            let schemas = bind(db, file).resolved_schemas(position, schema.as_ref());
-            // Try CTE resolution first since resolve_table_name doesn't handle CTEs
-            if let Some((ptr, kind)) =
-                resolve_table_like(db, name_ref.as_ref(), &table_name, &schemas, file)
-            {
-                let tree = parse(db, file).tree();
-                let node = ptr.to_node(tree.syntax());
-                match kind {
-                    LocationKind::Table => {
-                        if let Some(with_table) = node.ancestors().find_map(ast::WithTable::cast) {
-                            return with_table_columns_with_types(db, file, with_table);
-                        }
-                        if let Some(t) = node.ancestors().find_map(ast::CreateTableLike::cast) {
-                            return table_columns(db, file, &t);
-                        }
-                    }
-                    LocationKind::View => {
-                        if let Some(v) = node.ancestors().find_map(ast::CreateViewLike::cast) {
-                            return view_like_columns_with_types(db, file, &v);
-                        }
-                    }
-                    _ => (),
-                }
-            }
-            // Fall back to builtins for schema-qualified names
-            if let Some(resolved) = resolve_table_name(db, &table_name, &schemas, file) {
-                return resolved_to_columns_with_types(db, resolved.file_id, resolved.value, 0);
-            }
-            vec![]
-        }
+        ast::SelectVariant::Table(table) => table_query_columns_with_types(db, file, table),
         ast::SelectVariant::SelectInto(select_into) => {
             let Some(target_list) = select_into.select_clause().and_then(|c| c.target_list())
             else {
@@ -336,6 +315,51 @@ fn select_columns_with_types(
     }
 }
 
+fn table_query_columns_with_types(
+    db: &dyn Db,
+    file: File,
+    table: &ast::Table,
+) -> Vec<(Name, Option<Type>)> {
+    let Some(path) = table.relation_name().and_then(|r| r.path()) else {
+        return vec![];
+    };
+    let Some((schema, table_name)) = name::schema_and_name_path(&path) else {
+        return vec![];
+    };
+    let Some(name_ref) = path.segment().and_then(|s| s.name_ref()) else {
+        return vec![];
+    };
+    let position = name_ref.syntax().text_range().start();
+    let schemas = bind(db, file).resolved_schemas(position, schema.as_ref());
+    // Try CTE resolution first since resolve_table_name doesn't handle CTEs
+    if let Some((ptr, kind)) = resolve_table_like(db, Some(&name_ref), &table_name, &schemas, file)
+    {
+        let tree = parse(db, file).tree();
+        let node = ptr.to_node(tree.syntax());
+        match kind {
+            LocationKind::Table => {
+                if let Some(with_table) = node.ancestors().find_map(ast::WithTable::cast) {
+                    return with_table_columns_with_types(db, file, with_table);
+                }
+                if let Some(t) = node.ancestors().find_map(ast::CreateTableLike::cast) {
+                    return table_columns(db, file, &t);
+                }
+            }
+            LocationKind::View => {
+                if let Some(v) = node.ancestors().find_map(ast::CreateViewLike::cast) {
+                    return view_like_columns_with_types(db, file, &v);
+                }
+            }
+            _ => (),
+        }
+    }
+    // Fall back to builtins for schema-qualified names
+    if let Some(resolved) = resolve_table_name(db, &table_name, &schemas, file) {
+        return resolved_to_columns_with_types(db, resolved.file_id, resolved.value, 0);
+    }
+    vec![]
+}
+
 fn columns_from_returning_clause_with_types(
     db: &dyn Db,
     file: File,
@@ -497,6 +521,10 @@ fn with_table_query_columns_with_types(
         return columns_from_values(&values);
     }
 
+    if let ast::WithQuery::Table(table) = query {
+        return table_query_columns_with_types(db, file, &table);
+    }
+
     if let Some(columns) = columns_from_returning_clause_with_types(db, file, &query) {
         return columns;
     }
@@ -567,6 +595,12 @@ fn column_type_at_location(db: &dyn Db, def: Location) -> Option<Type> {
                 .find(|(n, _)| *n == column_name)
                 .and_then(|(_, t)| t)
         }
+        ast_nav::ParentSouce::SelectInto(select_into) => {
+            select_into_columns_with_types(db, def.file, &select_into)
+                .into_iter()
+                .find(|(n, _)| *n == column_name)
+                .and_then(|(_, t)| t)
+        }
         ast_nav::ParentSouce::Alias(alias) => {
             let from_item = alias.syntax().ancestors().find_map(ast::FromItem::cast)?;
             columns_for_star_from_alias(db, def.file, &from_item, &alias)
@@ -701,21 +735,11 @@ fn columns_for_star_from_table_ptr(
         Some(ast_nav::ParentSouce::ParenSelect(paren_select)) => {
             paren_select_columns_with_types(db, file, &paren_select)
         }
-        None => vec![],
-    }
-}
-
-fn target_list_columns_with_types(target_list: &ast::TargetList) -> Vec<(Name, Option<Type>)> {
-    let mut columns = vec![];
-    for target in target_list.targets() {
-        if let Some((col_name, _node)) = ColumnName::from_target(target.clone())
-            && let Some(col_name_str) = col_name.to_string()
-        {
-            let ty = target.expr().and_then(|e| infer_type_from_expr(&e));
-            columns.push((Name::from_string(col_name_str), ty));
+        Some(ast_nav::ParentSouce::SelectInto(select_into)) => {
+            select_into_columns_with_types(db, file, &select_into)
         }
+        None => vec![],
     }
-    columns
 }
 
 pub(crate) fn paren_select_columns_with_types(
@@ -734,8 +758,6 @@ fn select_variant_columns_with_types(
     file: File,
     select_variant: &ast::SelectVariant,
 ) -> Vec<(Name, Option<Type>)> {
-    let tree = parse(db, file).tree();
-    let root = tree.syntax();
     match select_variant {
         ast::SelectVariant::Values(values) => columns_from_values(values),
         ast::SelectVariant::Select(select) => {
@@ -767,40 +789,7 @@ fn select_variant_columns_with_types(
             };
             select_variant_columns_with_types(db, file, &lhs)
         }
-        ast::SelectVariant::Table(table) => {
-            let Some(path) = table.relation_name().and_then(|r| r.path()) else {
-                return vec![];
-            };
-            let Some((schema, table_name)) = name::schema_and_name_path(&path) else {
-                return vec![];
-            };
-            let name_ref = path.segment().and_then(|segment| segment.name_ref());
-            let position = table.syntax().text_range().start();
-            let schemas = bind(db, file).resolved_schemas(position, schema.as_ref());
-            let Some((ptr, kind)) =
-                resolve_table_like(db, name_ref.as_ref(), &table_name, &schemas, file)
-            else {
-                return vec![];
-            };
-            let node = ptr.to_node(root);
-            match kind {
-                LocationKind::View => node
-                    .ancestors()
-                    .find_map(ast::CreateViewLike::cast)
-                    .map(|v| view_like_columns_with_types(db, file, &v))
-                    .unwrap_or_default(),
-                LocationKind::Table => {
-                    if let Some(with_table) = node.ancestors().find_map(ast::WithTable::cast) {
-                        return with_table_columns_with_types(db, file, with_table);
-                    }
-                    node.ancestors()
-                        .find_map(ast::CreateTableLike::cast)
-                        .map(|t| table_columns(db, file, &t))
-                        .unwrap_or_default()
-                }
-                _ => vec![],
-            }
-        }
+        ast::SelectVariant::Table(table) => table_query_columns_with_types(db, file, table),
     }
 }
 
@@ -856,6 +845,12 @@ pub(crate) fn star_column_names(db: &dyn Db, file: File, table_ptr: &SyntaxNodeP
             }
             return star_column_names_from_paren_select(db, file, &paren_select);
         }
+        Some(ast_nav::ParentSouce::SelectInto(select_into)) => {
+            select_into_columns_with_types(db, file, &select_into)
+                .into_iter()
+                .map(|(name, _ty)| name)
+                .collect()
+        }
         None => vec![],
     }
 }

{squawk_cli-2.55.0 → squawk_cli-2.56.0}/crates/squawk_ide/src/completion.rs

@@ -448,6 +448,18 @@ fn column_completions_from_clause(
                     sort_text: None,
                 }));
             }
+            Some(ast_nav::ParentSouce::SelectInto(select_into)) => {
+                let columns = collect::select_into_columns_with_types(db, file, &select_into);
+                completions.extend(columns.into_iter().map(|(name, ty)| CompletionItem {
+                    label: name.to_string(),
+                    kind: CompletionItemKind::Column,
+                    detail: ty.map(|t| t.to_string()),
+                    insert_text: None,
+                    insert_text_format: None,
+                    trigger_completion_after_insert: false,
+                    sort_text: None,
+                }));
+            }
             None => {}
         }
     }
@@ -501,6 +513,12 @@ fn alias_base_columns_with_types(
                 .map(|(name, ty)| (name, ty.map(|t| t.to_string())))
                 .collect()
         }
+        Some(ast_nav::ParentSouce::SelectInto(select_into)) => {
+            collect::select_into_columns_with_types(db, file, &select_into)
+                .into_iter()
+                .map(|(name, ty)| (name, ty.map(|t| t.to_string())))
+                .collect()
+        }
         Some(ast_nav::ParentSouce::Alias(_)) | None => vec![],
     }
 }
@@ -1207,6 +1225,26 @@ select $0 from child;
         ");
     }
 
+    #[test]
+    fn completion_after_select_select_into() {
+        assert_snapshot!(completions("
+select 1 a, 'x'::text b into t;
+select $0 from t;
+"), @"
+         label              | kind     | detail  
+        --------------------+----------+---------
+         a                  | Column   | integer 
+         b                  | Column   | text    
+         t                  | Table    |         
+         *                  | Operator |         
+         public             | Schema   |         
+         pg_catalog         | Schema   |         
+         pg_temp            | Schema   |         
+         pg_toast           | Schema   |         
+         information_schema | Schema   |
+        ");
+    }
+
     #[test]
     fn completion_select_table_qualified() {
         assert_snapshot!(completions("