squawk-cli 2.1.0__tar.gz → 2.3.0__tar.gz

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/Cargo.lock

@@ -2543,7 +2543,7 @@ checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
 
 [[package]]
 name = "squawk"
-version = "2.1.0"
+version = "2.3.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",
@@ -2558,7 +2558,7 @@ dependencies = [
  "serde",
  "serde_json",
  "simplelog",
- "squawk-github",
+ "squawk_github",
  "squawk_lexer",
  "squawk_linter",
  "squawk_syntax",
@@ -2568,7 +2568,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "squawk-github"
+name = "squawk_github"
 version = "0.0.0"
 dependencies = [
  "jsonwebtoken",

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/Cargo.toml

@@ -47,7 +47,7 @@ convert_case = "0.7.1"
 clap = { version = "4.5.8", features = ["derive"] }
 
 # local
-squawk-github = { version = "0.0.0", path = "./crates/github" }
+squawk_github = { version = "0.0.0", path = "./crates/squawk_github" }
 squawk_lexer = { version = "0.0.0", path = "./crates/squawk_lexer" }
 squawk_parser = { version = "0.0.0", path = "./crates/squawk_parser" }
 squawk_syntax = { version = "0.0.0", path = "./crates/squawk_syntax" }

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squawk-cli
-Version: 2.1.0
+Version: 2.3.0
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
@@ -310,7 +310,7 @@ cargo xtask new-rule 'prefer big serial'
 2. Run `s/update-version`
 
    ```bash
-   # update version in cli/Cargo.toml, package.json, flake.nix to 4.5.3
+   # update version in squawk/Cargo.toml, package.json, flake.nix to 4.5.3
    s/update-version 4.5.3
    ```
 

{squawk_cli-2.1.0/crates/cli → squawk_cli-2.3.0/crates/squawk}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "squawk"
-version = "2.1.0"
+version = "2.3.0"
 default-run = "squawk"
 
 authors.workspace = true
@@ -29,7 +29,7 @@ enum-iterator.workspace = true
 squawk_syntax.workspace = true
 squawk_linter.workspace = true
 squawk_lexer.workspace = true
-squawk-github.workspace = true
+squawk_github.workspace = true
 toml.workspace = true
 glob.workspace = true
 anyhow.workspace = true

{squawk_cli-2.1.0/crates/cli → squawk_cli-2.3.0/crates/squawk}/README.md

@@ -291,7 +291,7 @@ cargo xtask new-rule 'prefer big serial'
 2. Run `s/update-version`
 
    ```bash
-   # update version in cli/Cargo.toml, package.json, flake.nix to 4.5.3
+   # update version in squawk/Cargo.toml, package.json, flake.nix to 4.5.3
    s/update-version 4.5.3
    ```
 

{squawk_cli-2.1.0/crates/cli → squawk_cli-2.3.0/crates/squawk}/src/main.rs

@@ -16,6 +16,7 @@ use config::Config;
 use log::info;
 use simplelog::CombinedLogger;
 use std::io;
+use std::panic;
 use std::path::PathBuf;
 use std::process::{self, ExitCode};
 use structopt::StructOpt;
@@ -140,6 +141,22 @@ struct Opt {
 
 #[allow(clippy::too_many_lines)]
 fn main() -> Result<ExitCode> {
+    let version = env!("CARGO_PKG_VERSION");
+
+    // via: https://github.com/astral-sh/ruff/blob/40fd52dde0ddf0b95a3433163f51560b4827ab75/crates/ruff_server/src/server.rs#L140
+    panic::set_hook(Box::new(move |panic_info| {
+        use std::io::Write;
+        let backtrace = std::backtrace::Backtrace::force_capture();
+        // Don't use `eprintln` because `eprintln` itself may panic if the pipe is broken.
+        let mut stderr = std::io::stderr().lock();
+        let open_an_issue = format!(
+            r#"An internal error has occured with Squawk v{version}!
+Please open an issue at https://github.com/sbdchd/squawk/issues/new with the logs above!
+"#
+        );
+        writeln!(stderr, "{panic_info}\n{backtrace}\n{open_an_issue}").ok();
+    }));
+
     let opts = Opt::from_args();
 
     if opts.verbose {

{squawk_cli-2.1.0/crates/github → squawk_cli-2.3.0/crates/squawk_github}/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "squawk-github"
+name = "squawk_github"
 version = "0.0.0"
 authors = ["Steve Dignam <steve@dignam.xyz>"]
 edition = "2018"

{squawk_cli-2.1.0/crates/github → squawk_cli-2.3.0/crates/squawk_github}/README.md

@@ -1,3 +1,3 @@
-# squawk-github
+# squawk_github
 
 A small wrapper around the GitHub API to allow [`squawk`](https://github.com/sbdchd/squawk) to comment on PRs.

squawk_cli-2.3.0/crates/squawk_linter/README.md

@@ -0,0 +1,38 @@
+# linter
+
+## Error message style guide
+
+### Lock messages
+
+Each lock name should be:
+
+- accompanied by an explanation of its meaning in simple terms
+- tables that are affected
+
+Instead of:
+
+```
+Changing the size of a `varchar` field requires an `ACCESS EXCLUSIVE` lock.
+```
+
+include a lock description & table name:
+
+```
+Changing the size of a `varchar` field requires an `ACCESS EXCLUSIVE` lock, which prevents reads and writes to `users`.
+```
+
+### Help
+
+A help message should be short an actionable.
+
+Instead of:
+
+```
+You can remove the `CASCADE` keyword and then specify exactly which tables you want to truncate directly.
+```
+
+tell the user what to change (add, update, remove):
+
+```
+Remove the `CASCADE` and specify exactly which tables you want to truncate.
+```

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/crates/squawk_linter/src/rules/prefer_robust_stmts.rs

@@ -30,6 +30,12 @@ pub(crate) fn prefer_robust_stmts(ctx: &mut Linter, parse: &Parse<SourceFile>) {
         return;
     }
 
+    enum ActionErrorMessage {
+        IfExists,
+        IfNotExists,
+        None,
+    }
+
     for item in file.items() {
         match item {
             ast::Item::Begin(_) => {
@@ -40,7 +46,7 @@ pub(crate) fn prefer_robust_stmts(ctx: &mut Linter, parse: &Parse<SourceFile>) {
             }
             ast::Item::AlterTable(alter_table) => {
                 for action in alter_table.actions() {
-                    match &action {
+                    let message_type = match &action {
                         ast::AlterTableAction::DropConstraint(drop_constraint) => {
                             if let Some(constraint_name) = drop_constraint.name_ref() {
                                 constraint_names.insert(
@@ -51,11 +57,13 @@ pub(crate) fn prefer_robust_stmts(ctx: &mut Linter, parse: &Parse<SourceFile>) {
                             if drop_constraint.if_exists().is_some() {
                                 continue;
                             }
+                            ActionErrorMessage::IfExists
                         }
                         ast::AlterTableAction::AddColumn(add_column) => {
                             if add_column.if_not_exists().is_some() {
                                 continue;
                             }
+                            ActionErrorMessage::IfNotExists
                         }
                         ast::AlterTableAction::ValidateConstraint(validate_constraint) => {
                             if let Some(constraint_name) = validate_constraint.name_ref() {
@@ -65,6 +73,7 @@ pub(crate) fn prefer_robust_stmts(ctx: &mut Linter, parse: &Parse<SourceFile>) {
                                     continue;
                                 }
                             }
+                            ActionErrorMessage::None
                         }
                         ast::AlterTableAction::AddConstraint(add_constraint) => {
                             let constraint = add_constraint.constraint();
@@ -78,22 +87,36 @@ pub(crate) fn prefer_robust_stmts(ctx: &mut Linter, parse: &Parse<SourceFile>) {
                                     }
                                 }
                             }
+                            ActionErrorMessage::None
                         }
                         ast::AlterTableAction::DropColumn(drop_column) => {
                             if drop_column.if_exists().is_some() {
                                 continue;
                             }
+                            ActionErrorMessage::IfExists
                         }
-                        _ => (),
-                    }
+                        _ => ActionErrorMessage::None,
+                    };
 
                     if inside_transaction {
                         continue;
                     }
 
+                    let message =  match message_type {
+                        ActionErrorMessage::IfExists => {
+                            "Missing `IF EXISTS`, the migration can't be rerun if it fails part way through.".to_string()
+                        },
+                        ActionErrorMessage::IfNotExists => {
+                            "Missing `IF NOT EXISTS`, the migration can't be rerun if it fails part way through.".to_string()
+                        },
+                        ActionErrorMessage::None => {
+                            "Missing transaction, the migration can't be rerun if it fails part way through.".to_string()
+                        },
+                    };
+
                     ctx.report(Violation::new(
                         Rule::PreferRobustStmts,
-                    "Missing `IF NOT EXISTS`, the migration can't be rerun if it fails part way through.".into(),
+                        message,
                         action.syntax().text_range(),
                         None,
                     ));
@@ -547,7 +570,20 @@ ALTER TABLE IF EXISTS test DISABLE ROW LEVEL SECURITY;
 ALTER TABLE "app_email" DROP CONSTRAINT IF EXISTS "email_uniq";
 ALTER TABLE "app_email" ADD CONSTRAINT "email_uniq" UNIQUE USING INDEX "email_idx";
 -- this second add constraint should error because it's not robust
-ALTER TABLE "app_email" ADD CONSTRAINT "email_uniq" UNIQUE USING INDEX "email_idx";
+ALTER TABLE "app_email" ADD CONSTRAIN "email_uniq" UNIQUE USING INDEX "email_idx";
+        "#;
+        let file = squawk_syntax::SourceFile::parse(sql);
+        let mut linter = Linter::from([Rule::PreferRobustStmts]);
+        let errors = linter.lint(file, sql);
+        assert_ne!(errors.len(), 0);
+        assert_debug_snapshot!(errors);
+    }
+
+    #[test]
+    fn alter_column_set_not_null() {
+        let sql = r#"
+select 1; -- so we don't skip checking
+alter table t alter column c set not null;
         "#;
         let file = squawk_syntax::SourceFile::parse(sql);
         let mut linter = Linter::from([Rule::PreferRobustStmts]);

squawk_cli-2.3.0/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__prefer_robust_stmts__test__alter_column_set_not_null.snap

@@ -0,0 +1,12 @@
+---
+source: crates/squawk_linter/src/rules/prefer_robust_stmts.rs
+expression: errors
+---
+[
+    Violation {
+        code: PreferRobustStmts,
+        message: "Missing transaction, the migration can't be rerun if it fails part way through.",
+        text_range: 54..81,
+        help: None,
+    },
+]

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__prefer_robust_stmts__test__alter_table_drop_column_err.snap

@@ -5,7 +5,7 @@ expression: errors
 [
     Violation {
         code: PreferRobustStmts,
-        message: "Missing `IF NOT EXISTS`, the migration can't be rerun if it fails part way through.",
+        message: "Missing `IF EXISTS`, the migration can't be rerun if it fails part way through.",
         text_range: 54..75,
         help: None,
     },

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__prefer_robust_stmts__test__alter_table_drop_constraint_err.snap

@@ -5,7 +5,7 @@ expression: errors
 [
     Violation {
         code: PreferRobustStmts,
-        message: "Missing `IF NOT EXISTS`, the migration can't be rerun if it fails part way through.",
+        message: "Missing `IF EXISTS`, the migration can't be rerun if it fails part way through.",
         text_range: 63..93,
         help: None,
     },

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__prefer_robust_stmts__test__disable_row_level_security_err.snap

@@ -5,7 +5,7 @@ expression: errors
 [
     Violation {
         code: PreferRobustStmts,
-        message: "Missing `IF NOT EXISTS`, the migration can't be rerun if it fails part way through.",
+        message: "Missing transaction, the migration can't be rerun if it fails part way through.",
         text_range: 63..89,
         help: None,
     },

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__prefer_robust_stmts__test__double_add_after_drop_err.snap

@@ -6,7 +6,7 @@ expression: errors
     Violation {
         code: PreferRobustStmts,
         message: "Missing `IF NOT EXISTS`, the migration can't be rerun if it fails part way through.",
-        text_range: 240..298,
+        text_range: 240..297,
         help: None,
     },
 ]

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__prefer_robust_stmts__test__enable_row_level_security_err.snap

@@ -5,7 +5,7 @@ expression: errors
 [
     Violation {
         code: PreferRobustStmts,
-        message: "Missing `IF NOT EXISTS`, the migration can't be rerun if it fails part way through.",
+        message: "Missing transaction, the migration can't be rerun if it fails part way through.",
         text_range: 63..88,
         help: None,
     },

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/crates/squawk_linter/src/rules/snapshots/squawk_linter__rules__prefer_robust_stmts__test__enable_row_level_security_without_exists_check_err.snap

@@ -5,7 +5,7 @@ expression: errors
 [
     Violation {
         code: PreferRobustStmts,
-        message: "Missing `IF NOT EXISTS`, the migration can't be rerun if it fails part way through.",
+        message: "Missing transaction, the migration can't be rerun if it fails part way through.",
         text_range: 53..78,
         help: None,
     },

{squawk_cli-2.1.0 → squawk_cli-2.3.0}/crates/squawk_parser/src/grammar.rs

@@ -2332,7 +2332,15 @@ fn compound_select(p: &mut Parser<'_>, cm: CompletedMarker) -> CompletedMarker {
     if !p.eat(ALL_KW) {
         p.eat(DISTINCT_KW);
     }
-    select_stmt(p, None);
+    if p.at(L_PAREN) {
+        tuple_expr(p);
+    } else {
+        if p.at_ts(SELECT_FIRST) {
+            select_stmt(p, None);
+        } else {
+            p.error("expected start of a select statement")
+        }
+    }
     m.complete(p, COMPOUND_SELECT)
 }
 
@@ -6552,7 +6560,7 @@ fn alter_default_privileges_stmt(p: &mut Parser<'_>) -> CompletedMarker {
             p.bump(GRANT_KW);
             privileges(p);
             p.expect(ON_KW);
-            privilege_target(p);
+            privilege_target_type(p);
             p.expect(TO_KW);
             role(p);
             while !p.at(EOF) && p.eat(COMMA) {
@@ -6571,7 +6579,7 @@ fn alter_default_privileges_stmt(p: &mut Parser<'_>) -> CompletedMarker {
             }
             privileges(p);
             p.expect(ON_KW);
-            privilege_target(p);
+            privilege_target_type(p);
             p.expect(FROM_KW);
             role(p);
             while !p.at(EOF) && p.eat(COMMA) {
@@ -6586,7 +6594,7 @@ fn alter_default_privileges_stmt(p: &mut Parser<'_>) -> CompletedMarker {
     m.complete(p, ALTER_DEFAULT_PRIVILEGES_STMT)
 }
 
-fn privilege_target(p: &mut Parser<'_>) {
+fn privilege_target_type(p: &mut Parser<'_>) {
     match p.current() {
         TABLES_KW | FUNCTIONS_KW | ROUTINES_KW | SEQUENCES_KW | TYPES_KW | SCHEMAS_KW => {
             p.bump_any();
@@ -10044,90 +10052,7 @@ fn grant_stmt(p: &mut Parser<'_>) -> CompletedMarker {
     //       | ALL { FUNCTIONS | PROCEDURES | ROUTINES } IN SCHEMA schema_name [, ...] }
     // ON PARAMETER configuration_parameter [, ...]
     if p.eat(ON_KW) {
-        if p.eat(ALL_KW) {
-            match p.current() {
-                TABLES_KW | SEQUENCES_KW | FUNCTIONS_KW | PROCEDURES_KW | ROUTINES_KW => {
-                    p.bump_any();
-                    p.expect(IN_KW);
-                    p.expect(SCHEMA_KW);
-                    // schema_name [, ...]
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                _ => p.error("expected TABLE"),
-            }
-        } else {
-            match p.current() {
-                PARAMETER_KW => {
-                    p.bump(PARAMETER_KW);
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                FUNCTION_KW | PROCEDURE_KW | ROUTINE_KW => {
-                    p.bump_any();
-                    // function_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
-                    path_name_ref(p);
-                    opt_param_list(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        // function_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
-                        path_name_ref(p);
-                        opt_param_list(p);
-                    }
-                }
-                // TYPE type_name [, ...]
-                TYPE_KW => {
-                    p.bump(TYPE_KW);
-                    type_name(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        type_name(p);
-                    }
-                }
-                TABLE_KW | SEQUENCE_KW | DATABASE_KW | TABLESPACE_KW | SCHEMA_KW | LANGUAGE_KW
-                | DOMAIN_KW => {
-                    p.bump_any();
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                FOREIGN_KW => {
-                    p.bump(FOREIGN_KW);
-                    if p.eat(DATA_KW) {
-                        p.expect(WRAPPER_KW);
-                    } else {
-                        p.expect(SERVER_KW);
-                    }
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                LARGE_KW => {
-                    p.bump(LARGE_KW);
-                    p.expect(OBJECT_KW);
-                    if opt_numeric_literal(p).is_none() {
-                        p.error("expected large_object_oid")
-                    }
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        if opt_numeric_literal(p).is_none() {
-                            p.error("expected large_object_oid")
-                        }
-                    }
-                }
-                // table_name [, ...]
-                _ if p.at_ts(COL_LABEL_FIRST) => {
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                _ => (),
-            }
-        }
+        privilege_target(p);
     }
     // TO role_specification [, ...]
     p.expect(TO_KW);
@@ -10157,6 +10082,101 @@ fn grant_stmt(p: &mut Parser<'_>) -> CompletedMarker {
     m.complete(p, GRANT_STMT)
 }
 
+fn privilege_target(p: &mut Parser<'_>) {
+    if p.eat(ALL_KW) {
+        match p.current() {
+            TABLES_KW | SEQUENCES_KW | FUNCTIONS_KW | PROCEDURES_KW | ROUTINES_KW => {
+                p.bump_any();
+                p.expect(IN_KW);
+                p.expect(SCHEMA_KW);
+                // schema_name [, ...]
+                name_ref(p);
+                while !p.at(EOF) && p.eat(COMMA) {
+                    name_ref(p);
+                }
+            }
+            _ => p.error("expected TABLE"),
+        }
+    } else {
+        match p.current() {
+            PARAMETER_KW => {
+                p.bump(PARAMETER_KW);
+                path_name_ref(p);
+                while !p.at(EOF) && p.eat(COMMA) {
+                    path_name_ref(p);
+                }
+            }
+            FUNCTION_KW | PROCEDURE_KW | ROUTINE_KW => {
+                p.bump_any();
+                // function_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
+                path_name_ref(p);
+                opt_param_list(p);
+                while !p.at(EOF) && p.eat(COMMA) {
+                    // function_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
+                    path_name_ref(p);
+                    opt_param_list(p);
+                }
+            }
+            // TYPE type_name [, ...]
+            TYPE_KW => {
+                p.bump(TYPE_KW);
+                type_name(p);
+                while !p.at(EOF) && p.eat(COMMA) {
+                    type_name(p);
+                }
+            }
+            // no schema allowed for the name
+            DATABASE_KW | TABLESPACE_KW | SCHEMA_KW | LANGUAGE_KW => {
+                p.bump_any();
+                name_ref(p);
+                while !p.at(EOF) && p.eat(COMMA) {
+                    name_ref(p);
+                }
+            }
+            // these allow schema
+            TABLE_KW | SEQUENCE_KW | DOMAIN_KW => {
+                p.bump_any();
+                path_name_ref(p);
+                while !p.at(EOF) && p.eat(COMMA) {
+                    path_name_ref(p);
+                }
+            }
+            FOREIGN_KW => {
+                p.bump(FOREIGN_KW);
+                if p.eat(DATA_KW) {
+                    p.expect(WRAPPER_KW);
+                } else {
+                    p.expect(SERVER_KW);
+                }
+                name_ref(p);
+                while !p.at(EOF) && p.eat(COMMA) {
+                    name_ref(p);
+                }
+            }
+            LARGE_KW => {
+                p.bump(LARGE_KW);
+                p.expect(OBJECT_KW);
+                if opt_numeric_literal(p).is_none() {
+                    p.error("expected large_object_oid")
+                }
+                while !p.at(EOF) && p.eat(COMMA) {
+                    if opt_numeric_literal(p).is_none() {
+                        p.error("expected large_object_oid")
+                    }
+                }
+            }
+            // table_name [, ...]
+            _ if p.at_ts(COL_LABEL_FIRST) => {
+                path_name_ref(p);
+                while !p.at(EOF) && p.eat(COMMA) {
+                    path_name_ref(p);
+                }
+            }
+            _ => (),
+        }
+    }
+}
+
 // [ GRANTED BY role_specification ]
 fn opt_granted_by(p: &mut Parser<'_>) {
     if p.eat(GRANTED_KW) {
@@ -10206,88 +10226,7 @@ fn revoke_stmt(p: &mut Parser<'_>) -> CompletedMarker {
     //       | ALL { FUNCTIONS | PROCEDURES | ROUTINES } IN SCHEMA schema_name [, ...] }
     // ON PARAMETER configuration_parameter [, ...]
     if p.eat(ON_KW) {
-        if p.eat(ALL_KW) {
-            match p.current() {
-                TABLES_KW | SEQUENCES_KW | FUNCTIONS_KW | PROCEDURES_KW | ROUTINES_KW => {
-                    p.bump_any();
-                    p.expect(IN_KW);
-                    p.expect(SCHEMA_KW);
-                    // schema_name [, ...]
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                _ => p.error("expected TABLE"),
-            }
-        } else {
-            match p.current() {
-                PARAMETER_KW => {
-                    p.bump(PARAMETER_KW);
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                FUNCTION_KW | PROCEDURE_KW | ROUTINE_KW => {
-                    p.bump_any();
-                    path_name_ref(p);
-                    opt_param_list(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        path_name_ref(p);
-                        opt_param_list(p);
-                    }
-                }
-                // TYPE type_name [, ...]
-                TYPE_KW => {
-                    p.bump(TYPE_KW);
-                    type_name(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        type_name(p);
-                    }
-                }
-                TABLE_KW | SEQUENCE_KW | DATABASE_KW | TABLESPACE_KW | SCHEMA_KW | LANGUAGE_KW
-                | DOMAIN_KW => {
-                    p.bump_any();
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                FOREIGN_KW => {
-                    p.bump(FOREIGN_KW);
-                    if p.eat(DATA_KW) {
-                        p.expect(WRAPPER_KW);
-                    } else {
-                        p.expect(SERVER_KW);
-                    }
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                LARGE_KW => {
-                    p.bump(LARGE_KW);
-                    p.expect(OBJECT_KW);
-                    if opt_numeric_literal(p).is_none() {
-                        p.error("expected large_object_oid")
-                    }
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        if opt_numeric_literal(p).is_none() {
-                            p.error("expected large_object_oid")
-                        }
-                    }
-                }
-                // table_name [, ...]
-                _ if p.at_ts(COL_LABEL_FIRST) => {
-                    name_ref(p);
-                    while !p.at(EOF) && p.eat(COMMA) {
-                        name_ref(p);
-                    }
-                }
-                _ => (),
-            }
-        }
+        privilege_target(p);
     }
     // FROM role_specification [, ...]
     p.expect(FROM_KW);