squawk-cli 2.51.0__tar.gz → 2.52.1__tar.gz

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/Cargo.lock

@@ -2434,7 +2434,7 @@ dependencies = [
 
 [[package]]
 name = "squawk"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "annotate-snippets",
  "anyhow",
@@ -2465,7 +2465,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-fmt"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "anyhow",
  "camino",
@@ -2481,7 +2481,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-github"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "jsonwebtoken",
  "log",
@@ -2492,7 +2492,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-ide"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "annotate-snippets",
  "etcetera",
@@ -2514,14 +2514,14 @@ dependencies = [
 
 [[package]]
 name = "squawk-lexer"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "insta",
 ]
 
 [[package]]
 name = "squawk-linter"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "annotate-snippets",
  "enum-iterator",
@@ -2536,7 +2536,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-parser"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -2549,7 +2549,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-server"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "anyhow",
  "crossbeam-channel",
@@ -2575,7 +2575,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-syntax"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -2589,7 +2589,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-thread"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
@@ -2601,7 +2601,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-wasm"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3477,7 +3477,7 @@ checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
 
 [[package]]
 name = "xtask"
-version = "2.51.0"
+version = "2.52.1"
 dependencies = [
  "anyhow",
  "camino",

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "2.51.0"
+version = "2.52.1"
 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.51.0" }
-squawk-ide = { path = "./crates/squawk_ide", version = "2.51.0" }
-squawk-lexer = { path = "./crates/squawk_lexer", version = "2.51.0" }
-squawk-parser = { path = "./crates/squawk_parser", version = "2.51.0" }
-squawk-syntax = { path = "./crates/squawk_syntax", version = "2.51.0" }
-squawk-linter = { path = "./crates/squawk_linter", version = "2.51.0" }
-squawk-server = { path = "./crates/squawk_server", version = "2.51.0" }
-squawk-thread = { path = "./crates/squawk_thread", version = "2.51.0" }
+squawk-github = { path = "./crates/squawk_github", version = "2.52.1" }
+squawk-ide = { path = "./crates/squawk_ide", version = "2.52.1" }
+squawk-lexer = { path = "./crates/squawk_lexer", version = "2.52.1" }
+squawk-parser = { path = "./crates/squawk_parser", version = "2.52.1" }
+squawk-syntax = { path = "./crates/squawk_syntax", version = "2.52.1" }
+squawk-linter = { path = "./crates/squawk_linter", version = "2.52.1" }
+squawk-server = { path = "./crates/squawk_server", version = "2.52.1" }
+squawk-thread = { path = "./crates/squawk_thread", version = "2.52.1" }
 
 [workspace.lints.clippy]
 collapsible_else_if = "allow"

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/PKG-INFO

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

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/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.51.0
+    rev: 2.52.1
     hooks:
       - id: squawk
         files: path/to/postgres/migrations/written/in/sql

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

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/crates/squawk_ide/src/code_actions/rewrite_as_dollar_quoted_string.rs

@@ -117,7 +117,7 @@ mod test {
     fn rewrite_prefix_string_not_applicable() {
         assert!(code_action_not_applicable(
             rewrite_as_dollar_quoted_string,
-            "select b'foo$0';"
+            "select b'010$0';"
         ));
     }
 }

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/crates/squawk_parser/src/grammar.rs

@@ -35,15 +35,15 @@ fn literal(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         return None;
     }
     let m = p.start();
-    if p.eat(UNICODE_ESC_STRING) {
-        if p.eat(UESCAPE_KW) {
-            p.eat(STRING);
-        }
-    }
     // E021-03 string continuation syntax
     // If two string literals are next to each other, and don't have a comment
     // between them, then they are automatically combined.
-    else if p.eat(STRING) {
+    if p.eat(UNICODE_ESC_STRING) {
+        while !p.at(EOF) && p.eat(STRING) {}
+        if p.eat(UESCAPE_KW) {
+            p.expect(STRING);
+        }
+    } else if p.eat(STRING) || p.eat(ESC_STRING) || p.eat(BIT_STRING) || p.eat(BYTE_STRING) {
         while !p.at(EOF) && p.eat(STRING) {}
     } else {
         p.bump_any();
@@ -1678,7 +1678,9 @@ fn path_segment(p: &mut Parser<'_>, kind: SyntaxKind) {
         // skip
     } else if p.at_ts(COL_LABEL_FIRST) {
         let m = p.start();
-        p.bump_any();
+        if !opt_ident(p) {
+            p.bump_any();
+        }
         let kind = if p.at(DOT) { NAME_REF } else { kind };
         m.complete(p, kind);
     } else {
@@ -2250,7 +2252,9 @@ fn index_expr(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker {
 fn name_ref_or_index(p: &mut Parser<'_>) {
     assert!(p.at(IDENT) || p.at_ts(TYPE_KEYWORDS) || p.at_ts(ALL_KEYWORDS) || p.at(INT_NUMBER));
     let m = p.start();
-    p.bump_any();
+    if !opt_ident(p) {
+        p.bump_any();
+    }
     m.complete(p, NAME_REF);
 }
 
@@ -14267,6 +14271,8 @@ fn create_extension(p: &mut Parser<'_>) -> CompletedMarker {
 }
 
 fn opt_ident(p: &mut Parser<'_>) -> bool {
+    // handle cases like:
+    // U&"!0069!006E!0074!0038" UESCAPE '!'
     if p.eat(IDENT) {
         if p.eat(UESCAPE_KW) {
             p.expect(STRING);

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/crates/squawk_parser/src/lexed_str.rs

@@ -170,20 +170,10 @@ impl<'a> Converter<'a> {
 
                 squawk_lexer::TokenKind::Whitespace => SyntaxKind::WHITESPACE,
                 squawk_lexer::TokenKind::Ident => {
-                    // TODO: check for max identifier length
-                    //
-                    // see: https://www.postgresql.org/docs/16/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
-                    // The system uses no more than NAMEDATALEN-1 bytes of an
-                    // identifier; longer names can be written in commands, but
-                    // they will be truncated. By default, NAMEDATALEN is 64 so
-                    // the maximum identifier length is 63 bytes. If this limit
-                    // is problematic, it can be raised by changing the
-                    // NAMEDATALEN constant in src/include/pg_config_manual.h.
-                    // see: https://github.com/postgres/postgres/blob/e032e4c7ddd0e1f7865b246ec18944365d4f8614/src/include/pg_config_manual.h#L29
                     SyntaxKind::from_keyword(token_text).unwrap_or(SyntaxKind::IDENT)
                 }
                 squawk_lexer::TokenKind::Literal { kind, .. } => {
-                    self.extend_literal(token_text.len(), kind);
+                    self.extend_literal(token_text, kind);
                     return;
                 }
                 squawk_lexer::TokenKind::Semi => SyntaxKind::SEMICOLON,
@@ -233,13 +223,13 @@ impl<'a> Converter<'a> {
         self.push(syntax_kind, token_text.len(), err);
     }
 
-    fn extend_literal(&mut self, len: usize, kind: &squawk_lexer::LiteralKind) {
-        let mut err = "";
+    fn extend_literal(&mut self, token_text: &str, kind: &squawk_lexer::LiteralKind) {
+        let mut err: Option<String> = None;
 
         let syntax_kind = match *kind {
             squawk_lexer::LiteralKind::Int { empty_int, base: _ } => {
                 if empty_int {
-                    err = "Missing digits after the integer base prefix";
+                    err = Some("Missing digits after the integer base prefix".into());
                 }
                 SyntaxKind::INT_NUMBER
             }
@@ -248,56 +238,245 @@ impl<'a> Converter<'a> {
                 base: _,
             } => {
                 if empty_exponent {
-                    err = "Missing digits after the exponent symbol";
+                    err = Some("Missing digits after the exponent symbol".into());
                 }
                 SyntaxKind::FLOAT_NUMBER
             }
             squawk_lexer::LiteralKind::Str { terminated } => {
                 if !terminated {
-                    err = "Missing trailing `'` symbol to terminate the string literal";
+                    err =
+                        Some("Missing trailing `'` symbol to terminate the string literal".into());
                 }
-                // TODO: rust analzyer checks for un-escaped strings, we should too
                 SyntaxKind::STRING
             }
             squawk_lexer::LiteralKind::ByteStr { terminated } => {
                 if !terminated {
-                    err = "Missing trailing `'` symbol to terminate the hex bit string literal";
+                    err = Some(
+                        "Missing trailing `'` symbol to terminate the hex bit string literal"
+                            .into(),
+                    );
+                } else {
+                    let inside = &token_text[2..token_text.len() - 1];
+                    if let Some(c) = inside.chars().find(|c| !c.is_ascii_hexdigit()) {
+                        err = Some(format!("\"{c}\" is not a valid hexadecimal digit"));
+                    }
                 }
-                // TODO: rust analzyer checks for un-escaped strings, we should too
                 SyntaxKind::BYTE_STRING
             }
             squawk_lexer::LiteralKind::BitStr { terminated } => {
                 if !terminated {
-                    err = "Missing trailing `\'` symbol to terminate the bit string literal";
+                    err = Some(
+                        "Missing trailing `'` symbol to terminate the bit string literal".into(),
+                    );
+                } else {
+                    let inside = &token_text[2..token_text.len() - 1];
+                    if let Some(c) = inside.chars().find(|&c| c != '0' && c != '1') {
+                        err = Some(format!("\"{c}\" is not a valid binary digit"));
+                    }
                 }
-                // TODO: rust analzyer checks for un-escaped strings, we should too
                 SyntaxKind::BIT_STRING
             }
             squawk_lexer::LiteralKind::DollarQuotedString { terminated } => {
                 if !terminated {
                     // TODO: we could be fancier and say the ending string we're looking for
-                    err = "Unterminated dollar quoted string literal";
+                    err = Some("Unterminated dollar quoted string literal".into());
                 }
-                // TODO: rust analzyer checks for un-escaped strings, we should too
                 SyntaxKind::DOLLAR_QUOTED_STRING
             }
             squawk_lexer::LiteralKind::UnicodeEscStr { terminated } => {
                 if !terminated {
-                    err = "Missing trailing `'` symbol to terminate the unicode escape string literal";
+                    err = Some(
+                        "Missing trailing `'` symbol to terminate the unicode escape string literal"
+                            .into(),
+                    );
                 }
-                // TODO: rust analzyer checks for un-escaped strings, we should too
+                // validated in squawk_syntax
                 SyntaxKind::UNICODE_ESC_STRING
             }
             squawk_lexer::LiteralKind::EscStr { terminated } => {
                 if !terminated {
-                    err = "Missing trailing `\'` symbol to terminate the escape string literal";
+                    err = Some(
+                        "Missing trailing `'` symbol to terminate the escape string literal".into(),
+                    );
+                } else {
+                    err = validate_escape_string_unicode_escapes(token_text);
                 }
-                // TODO: rust analzyer checks for un-escaped strings, we should too
                 SyntaxKind::ESC_STRING
             }
         };
 
-        let err = if err.is_empty() { None } else { Some(err) };
-        self.push(syntax_kind, len, err);
+        self.push(syntax_kind, token_text.len(), err.as_deref());
+    }
+}
+
+fn validate_escape_string_unicode_escapes(token_text: &str) -> Option<String> {
+    let mut chars = token_text[2..token_text.len() - 1].chars();
+
+    while let Some(c) = chars.next() {
+        if c != '\\' {
+            continue;
+        }
+
+        let (required, example) = match chars.next() {
+            Some('u') => (4, r"\uXXXX"),
+            Some('U') => (8, r"\UXXXXXXXX"),
+            _ => continue,
+        };
+
+        for _ in 0..required {
+            if !chars.next().is_some_and(|c| c.is_ascii_hexdigit()) {
+                return Some(format!(
+                    "Unicode escape requires {required} hex digits: {example}"
+                ));
+            }
+        }
+    }
+
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use annotate_snippets::{AnnotationKind, Level, Renderer, Snippet, renderer::DecorStyle};
+    use insta::assert_snapshot;
+
+    use super::LexedStr;
+
+    fn lex(text: &str) -> String {
+        let lexed = LexedStr::new(text);
+        let renderer = Renderer::plain().decor_style(DecorStyle::Unicode);
+        let mut res = String::new();
+
+        for (token, msg) in lexed.errors() {
+            let group = Level::ERROR.primary_title(msg).element(
+                Snippet::source(text)
+                    .fold(true)
+                    .annotation(AnnotationKind::Primary.span(lexed.text_range(token))),
+            );
+            res.push_str(&renderer.render(&[group]).to_string());
+            res.push('\n');
+        }
+
+        res
+    }
+
+    #[test]
+    fn empty_int_error() {
+        assert_snapshot!(lex("select 0x;"), @"
+        error: Missing digits after the integer base prefix
+          ╭▸ 
+        1 │ select 0x;
+          ╰╴       ━━
+        ");
+    }
+
+    #[test]
+    fn empty_exponent_error() {
+        assert_snapshot!(lex("select 1e;"), @"
+        error: Missing digits after the exponent symbol
+          ╭▸ 
+        1 │ select 1e;
+          ╰╴       ━━
+        ");
+    }
+
+    #[test]
+    fn unterminated_string_error() {
+        assert_snapshot!(lex("select 'hello;"), @"
+        error: Missing trailing `'` symbol to terminate the string literal
+          ╭▸ 
+        1 │ select 'hello;
+          ╰╴       ━━━━━━━
+        ");
+    }
+
+    #[test]
+    fn hex_invalid_digit() {
+        assert_snapshot!(lex("select X'1FZ';"), @r#"
+        error: "Z" is not a valid hexadecimal digit
+          ╭▸ 
+        1 │ select X'1FZ';
+          ╰╴       ━━━━━━
+        "#);
+    }
+
+    #[test]
+    fn unterminated_hex_bit_string_error() {
+        assert_snapshot!(lex("select X'1F;"), @"
+        error: Missing trailing `'` symbol to terminate the hex bit string literal
+          ╭▸ 
+        1 │ select X'1F;
+          ╰╴       ━━━━━
+        ");
+    }
+
+    #[test]
+    fn unterminated_bit_string_error() {
+        assert_snapshot!(lex("select B'101;"), @"
+        error: Missing trailing `'` symbol to terminate the bit string literal
+          ╭▸ 
+        1 │ select B'101;
+          ╰╴       ━━━━━━
+        ");
+    }
+
+    #[test]
+    fn invalid_binary_digit_error() {
+        assert_snapshot!(lex("select b'0 ';"), @r#"
+        error: " " is not a valid binary digit
+          ╭▸ 
+        1 │ select b'0 ';
+          ╰╴       ━━━━━
+        "#);
+    }
+
+    #[test]
+    fn unterminated_dollar_quoted_string_error() {
+        assert_snapshot!(lex("select $tag$hello;"), @"
+        error: Unterminated dollar quoted string literal
+          ╭▸ 
+        1 │ select $tag$hello;
+          ╰╴       ━━━━━━━━━━━
+        ");
+    }
+
+    #[test]
+    fn unterminated_unicode_escape_string_error() {
+        assert_snapshot!(lex("select U&'hello;"), @"
+        error: Missing trailing `'` symbol to terminate the unicode escape string literal
+          ╭▸ 
+        1 │ select U&'hello;
+          ╰╴       ━━━━━━━━━
+        ");
+    }
+
+    #[test]
+    fn unterminated_escape_string_error() {
+        assert_snapshot!(lex("select E'hello;"), @"
+        error: Missing trailing `'` symbol to terminate the escape string literal
+          ╭▸ 
+        1 │ select E'hello;
+          ╰╴       ━━━━━━━━
+        ");
+    }
+
+    #[test]
+    fn invalid_unicode_escape_4_digits_error() {
+        assert_snapshot!(lex(r"select E'\u00';"), @r"
+        error: Unicode escape requires 4 hex digits: \uXXXX
+          ╭▸ 
+        1 │ select E'\u00';
+          ╰╴       ━━━━━━━
+        ");
+    }
+
+    #[test]
+    fn invalid_unicode_escape_8_digits_error() {
+        assert_snapshot!(lex(r"select E'\UFFFF';"), @r"
+        error: Unicode escape requires 8 hex digits: \UXXXXXXXX
+          ╭▸ 
+        1 │ select E'\UFFFF';
+          ╰╴       ━━━━━━━━━
+        ");
     }
 }

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/crates/squawk_parser/tests/data/ok/select.sql

@@ -509,6 +509,12 @@ ORDER BY sensor_id, day;
 select U&"d!0061t!+000061" UESCAPE '!';
 SELECT U&' \' UESCAPE '!';
 
+-- select with uescape cast
+select 2::U&"!0069!006E!0074!0038" UESCAPE '!' from t;
+
+-- select with uescape on qualified field
+select t.U&"!0061" UESCAPE '!' from t;
+
 -- select_from_user_table
 select * from user;
 

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/crates/squawk_parser/tests/snapshots/tests__select_ok.snap

@@ -6277,6 +6277,65 @@ SOURCE_FILE
             STRING "'!'"
   SEMICOLON ";"
   WHITESPACE "\n\n"
+  COMMENT "-- select with uescape cast"
+  WHITESPACE "\n"
+  SELECT
+    SELECT_CLAUSE
+      SELECT_KW "select"
+      WHITESPACE " "
+      TARGET_LIST
+        TARGET
+          CAST_EXPR
+            LITERAL
+              INT_NUMBER "2"
+            COLON_COLON
+              COLON ":"
+              COLON ":"
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    IDENT "U&\"!0069!006E!0074!0038\""
+                    WHITESPACE " "
+                    UESCAPE_KW "UESCAPE"
+                    WHITESPACE " "
+                    STRING "'!'"
+    WHITESPACE " "
+    FROM_CLAUSE
+      FROM_KW "from"
+      WHITESPACE " "
+      FROM_ITEM
+        NAME_REF
+          IDENT "t"
+  SEMICOLON ";"
+  WHITESPACE "\n\n"
+  COMMENT "-- select with uescape on qualified field"
+  WHITESPACE "\n"
+  SELECT
+    SELECT_CLAUSE
+      SELECT_KW "select"
+      WHITESPACE " "
+      TARGET_LIST
+        TARGET
+          FIELD_EXPR
+            NAME_REF
+              IDENT "t"
+            DOT "."
+            NAME_REF
+              IDENT "U&\"!0061\""
+              WHITESPACE " "
+              UESCAPE_KW "UESCAPE"
+              WHITESPACE " "
+              STRING "'!'"
+    WHITESPACE " "
+    FROM_CLAUSE
+      FROM_KW "from"
+      WHITESPACE " "
+      FROM_ITEM
+        NAME_REF
+          IDENT "t"
+  SEMICOLON ";"
+  WHITESPACE "\n\n"
   COMMENT "-- select_from_user_table"
   WHITESPACE "\n"
   SELECT

{squawk_cli-2.51.0 → squawk_cli-2.52.1}/crates/squawk_syntax/src/lib.rs

@@ -33,6 +33,7 @@ pub mod quote;
 pub mod syntax_error;
 mod syntax_node;
 mod token_text;
+mod unescape;
 mod validation;
 
 #[cfg(test)]
@@ -95,6 +96,7 @@ impl<T> Parse<T> {
             vec![]
         };
         validation::validate(&self.syntax_node(), &mut errors);
+        errors.sort_by_key(|error| error.range().start());
         errors
     }
 }