parser: split AliasColumnList into ColumnList & ColumnDefList

crates/squawk_ide/src/classify.rs

@@ -1106,10 +1106,12 @@ pub(crate) fn classify_def_node(def_node: &SyntaxNode) -> Option<LocationKind> {
         if let Some(class) = classify_object_definition(ancestor.kind()) {
             return Some(class);
         }
-        if ast::Column::can_cast(ancestor.kind()) || ast::AliasColumn::can_cast(ancestor.kind()) {
+        if ast::Column::can_cast(ancestor.kind()) || ast::ColumnDef::can_cast(ancestor.kind()) {
             in_column = true;
         }
-        if ast::ColumnList::can_cast(ancestor.kind()) {
+        if ast::ColumnList::can_cast(ancestor.kind())
+            || ast::ColumnDefList::can_cast(ancestor.kind())
+        {
             in_column_list = true;
         }
         if ast::Param::can_cast(ancestor.kind()) {
@@ -1149,7 +1151,7 @@ pub(crate) fn classify_def_node(def_node: &SyntaxNode) -> Option<LocationKind> {
             || ast::OptionalAsAlias::can_cast(ancestor.kind())
             || ast::RequiredAsAlias::can_cast(ancestor.kind())
         {
-            if in_column {
+            if in_column || in_column_list {
                 return Some(LocationKind::Column);
             }
             return Some(LocationKind::Table);

crates/squawk_ide/src/collect.rs

@@ -687,7 +687,7 @@ fn columns_for_star_from_from_item(
     from_item: &ast::FromItem,
 ) -> Vec<(Name, Option<Type>)> {
     if let Some(alias) = from_item.alias()
-        && alias.column_list().is_some()
+        && alias.columns().is_some()
     {
         return columns_for_star_from_alias(db, file, from_item, &alias);
     }
@@ -706,9 +706,9 @@ pub(crate) fn columns_for_star_from_alias(
     alias: &ast::FromAlias,
 ) -> Vec<(Name, Option<Type>)> {
     let alias_columns: Vec<Name> = alias
-        .column_list()
+        .columns()
         .into_iter()
-        .flat_map(|column_list| column_list.column_names())
+        .flat_map(|columns| columns.column_names())
         .map(|name| Name::from_node(&name))
         .collect();
 
@@ -833,9 +833,9 @@ pub(crate) fn star_column_names(db: &dyn Db, file: File, table_ptr: &SyntaxNodeP
 
     match ast_nav::parent_source(&table_name_node) {
         Some(ast_nav::ParentSouce::Alias(alias)) => alias
-            .column_list()
+            .columns()
             .into_iter()
-            .flat_map(|column_list| column_list.column_names())
+            .flat_map(|columns| columns.column_names())
             .map(|name| Name::from_node(&name))
             .collect(),
         Some(ast_nav::ParentSouce::WithTable(with_table)) => {

crates/squawk_ide/src/completion.rs

@@ -400,9 +400,9 @@ fn column_completions_from_clause(
             }
             Some(ast_nav::ParentSouce::Alias(alias)) => {
                 let alias_columns: Vec<Name> = alias
-                    .column_list()
+                    .columns()
                     .into_iter()
-                    .flat_map(|column_list| column_list.column_names())
+                    .flat_map(|columns| columns.column_names())
                     .map(|name| Name::from_node(&name))
                     .collect();
 

crates/squawk_ide/src/expand_selection.rs

@@ -38,12 +38,12 @@ use crate::tokens::is_string_or_comment;
 
 const DELIMITED_LIST_KINDS: &[SyntaxKind] = &[
     SyntaxKind::ALTER_OPTION_LIST,
-    SyntaxKind::ALIAS_COLUMN_LIST,
     SyntaxKind::ALTER_TYPE_ATTRIBUTE_ACTION_LIST,
     SyntaxKind::ARG_LIST,
     SyntaxKind::ATTRIBUTE_LIST,
     SyntaxKind::BEGIN_FUNC_OPTION_LIST,
     SyntaxKind::CHECKPOINT_OPTION_LIST,
+    SyntaxKind::COLUMN_DEF_LIST,
     SyntaxKind::COLUMN_LIST,
     SyntaxKind::COLUMN_REF_LIST,
     SyntaxKind::COLUMN_TARGET_LIST,

crates/squawk_ide/src/folding_ranges.rs

@@ -135,12 +135,12 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
         SyntaxKind::TUPLE_EXPR => Some(FoldKind::Tuple),
         SyntaxKind::WHERE_CLAUSE => Some(FoldKind::WhereClause),
         SyntaxKind::WHEN_CLAUSE_LIST
-        | SyntaxKind::ALIAS_COLUMN_LIST
         | SyntaxKind::ALTER_OPTION_LIST
         | SyntaxKind::ALTER_TYPE_ATTRIBUTE_ACTION_LIST
         | SyntaxKind::ATTRIBUTE_LIST
         | SyntaxKind::BEGIN_FUNC_OPTION_LIST
         | SyntaxKind::CHECKPOINT_OPTION_LIST
+        | SyntaxKind::COLUMN_DEF_LIST
         | SyntaxKind::COLUMN_LIST
         | SyntaxKind::COLUMN_REF_LIST
         | SyntaxKind::COLUMN_TARGET_LIST

crates/squawk_ide/src/hover.rs

@@ -631,7 +631,7 @@ fn format_hover_for_column_ptr(db: &dyn Db, def: Location) -> Option<Hover> {
         }
         ast_nav::ParentSouce::Alias(alias) => {
             let alias_name = alias.name()?;
-            alias.column_list()?;
+            alias.columns()?;
             let from_item = alias.syntax().ancestors().find_map(ast::FromItem::cast)?;
             let table_name = Name::from_node(&alias_name);
             let column_name = Name::from_string(def_node.text().to_string());
@@ -802,7 +802,7 @@ fn format_alias_with_column_list(db: &dyn Db, alias: InFile<ast::FromAlias>) ->
     let alias_name = alias.name()?;
     let name = Name::from_node(&alias_name);
 
-    let Some(column_list) = alias.column_list() else {
+    let Some(alias_columns) = alias.columns() else {
         let name = Name::from_node(&alias.name()?);
         let from_item = alias.syntax().ancestors().find_map(ast::FromItem::cast)?;
         let ast::FromItem::ParenFromItem(paren) = from_item else {
@@ -812,7 +812,7 @@ fn format_alias_with_column_list(db: &dyn Db, alias: InFile<ast::FromAlias>) ->
         return format_subquery_table(name, paren_select);
     };
 
-    let mut columns: Vec<Name> = column_list
+    let mut columns: Vec<Name> = alias_columns
         .column_names()
         .map(|column_name| Name::from_node(&column_name))
         .collect();
@@ -954,7 +954,7 @@ fn hover_qualified_star_columns_from_alias(
     let file = alias.file_id;
     let alias = alias.value;
     let alias_name = Name::from_node(&alias.name()?);
-    alias.column_list()?;
+    alias.columns()?;
     let from_item = alias.syntax().ancestors().find_map(ast::FromItem::cast)?;
     let columns = collect::columns_for_star_from_alias(db, file, &from_item, alias);
 
@@ -2034,7 +2034,7 @@ fn qualified_star_from_clause_table_ptr(
     let from_item = resolve::find_from_item_in_from_clause(&from_clause, table_name)?;
 
     if let Some(alias) = from_item.alias()
-        && alias.column_list().is_some()
+        && alias.columns().is_some()
     {
         return Some(SyntaxNodePtr::new(alias.syntax()));
     }

crates/squawk_ide/src/resolve.rs

@@ -2060,7 +2060,7 @@ fn resolve_select_qualified_column_ptr(
                     return Some(ptr);
                 }
 
-                if from_item.alias().and_then(|a| a.column_list()).is_none()
+                if from_item.alias().and_then(|a| a.columns()).is_none()
                     && column_name == Name::from_string("ordinality")
                     && let Some(ordinality_token) = from_item
                         .with_ordinality()
@@ -2101,8 +2101,8 @@ fn resolve_select_qualified_column_ptr(
                     }
 
                     // `from t as u(a, b, c)`
-                    if let Some(column_list) = alias.column_list() {
-                        for col_name in column_list.column_names() {
+                    if let Some(columns) = alias.columns() {
+                        for col_name in columns.column_names() {
                             if Name::from_node(&col_name) == column_name {
                                 return Some(smallvec![Location::new(
                                     file,
@@ -2447,13 +2447,10 @@ fn resolve_from_item_column_by_name_after_index(
     if let ast::FromItem::RowsFromItem(rows_from) = from_item {
         let mut remaining_skip = skip_column_count;
         for arg in rows_from.rows_from_args() {
-            if let Some(column_def_list) = arg
-                .column_def_list()
-                .filter(|alias| alias.column_list().is_some())
-            {
+            if let Some(column_def_list) = arg.column_def_list() {
                 let (column_count, column) = resolve_column_list_column(
                     file,
-                    alias_column_names(Some(column_def_list)),
+                    column_def_list.column_names(),
                     column_name,
                     remaining_skip,
                 );
@@ -2545,7 +2542,7 @@ fn resolve_from_item_column_by_name_after_index(
     }
 
     if original_skip == 0
-        && from_item.alias().and_then(|a| a.column_list()).is_none()
+        && from_item.alias().and_then(|a| a.columns()).is_none()
         && *column_name == Name::from_string("ordinality")
         && let Some(ordinality_token) = from_item
             .with_ordinality()
@@ -3371,9 +3368,9 @@ fn column_list_names(
 
 fn alias_column_names(alias: Option<ast::FromAlias>) -> impl Iterator<Item = ast::ColumnName> {
     alias
-        .and_then(|alias| alias.column_list())
+        .and_then(|alias| alias.columns())
         .into_iter()
-        .flat_map(|column_list| column_list.column_names())
+        .flat_map(|columns| columns.column_names())
 }
 
 fn resolve_column_list_column(
@@ -4489,7 +4486,7 @@ pub(crate) fn table_ptrs_from_clause(
 
     for from_item in ast_nav::iter_from_clause(from_clause) {
         if let Some(alias) = from_item.alias()
-            && alias.column_list().is_some()
+            && alias.columns().is_some()
         {
             results.push(SyntaxNodePtr::new(alias.syntax()));
             continue;

crates/squawk_parser/src/grammar.rs

@@ -3803,7 +3803,9 @@ fn opt_row_from_expr(p: &mut Parser<'_>) -> bool {
     }
     let m = p.start();
     call_expr(p);
-    opt_from_alias(p);
+    if p.eat(AS_KW) && !opt_column_list_with(p, ColumnDefKind::ColumnDef) {
+        p.error("expected column definition list");
+    }
     m.complete(p, ROWS_FROM_ARG);
     true
 }
@@ -4275,11 +4277,12 @@ fn opt_sequence_options(p: &mut Parser<'_>) -> Option<CompletedMarker> {
 
 #[derive(Clone, Copy, PartialEq)]
 enum ColumnDefKind {
-    Alias,
+    ColumnDef,
     ColumnTarget,
     CompositeFieldDef,
     ConstraintColumnRef,
     ForeignKeyColumnRef,
+    FromAliasColumn,
     Name,
     NameRef,
 }
@@ -4298,6 +4301,7 @@ fn opt_column_list_with(p: &mut Parser<'_>, kind: ColumnDefKind) -> bool {
     }
     let m = p.start();
     p.expect(L_PAREN);
+    let mut kind = kind;
     let mut seen_period = false;
     while !p.at(EOF) && !p.at(R_PAREN) {
         if p.at(COMMA) {
@@ -4311,7 +4315,7 @@ fn opt_column_list_with(p: &mut Parser<'_>, kind: ColumnDefKind) -> bool {
             p.error("PERIOD must be the last column in the list");
         }
         seen_period |= kind == ColumnDefKind::ForeignKeyColumnRef && at_period_column(p);
-        column(p, kind);
+        kind = column(p, kind);
         if p.at(COMMA) && p.nth_at(1, R_PAREN) {
             p.err_and_bump("unexpected trailing comma");
         }
@@ -4326,28 +4330,41 @@ fn opt_column_list_with(p: &mut Parser<'_>, kind: ColumnDefKind) -> bool {
     opt_without_overlaps(p, kind);
     p.expect(R_PAREN);
     let list_kind = match kind {
-        ColumnDefKind::Alias => ALIAS_COLUMN_LIST,
+        ColumnDefKind::ColumnDef => COLUMN_DEF_LIST,
         ColumnDefKind::ColumnTarget => COLUMN_TARGET_LIST,
         ColumnDefKind::CompositeFieldDef => COMPOSITE_FIELD_LIST,
         ColumnDefKind::ConstraintColumnRef => CONSTRAINT_COLUMN_REF_LIST,
         ColumnDefKind::ForeignKeyColumnRef => FOREIGN_KEY_COLUMN_LIST,
-        ColumnDefKind::Name => COLUMN_LIST,
+        ColumnDefKind::FromAliasColumn | ColumnDefKind::Name => COLUMN_LIST,
         ColumnDefKind::NameRef => COLUMN_REF_LIST,
     };
     m.complete(p, list_kind);
     return true;
 }
 
-fn column(p: &mut Parser<'_>, kind: ColumnDefKind) {
+fn column(p: &mut Parser<'_>, kind: ColumnDefKind) -> ColumnDefKind {
     assert!(p.at_ts(COLUMN_FIRST));
     match kind {
-        ColumnDefKind::Alias => {
+        ColumnDefKind::FromAliasColumn => {
             let m = p.start();
             column_name(p);
             if !p.at(COMMA) && !p.at(R_PAREN) && opt_type_name(p) {
                 opt_collate(p);
+                m.complete(p, COLUMN_DEF);
+                return ColumnDefKind::ColumnDef;
             }
-            m.complete(p, ALIAS_COLUMN);
+            m.abandon(p);
+            return ColumnDefKind::Name;
+        }
+        ColumnDefKind::ColumnDef => {
+            let m = p.start();
+            column_name(p);
+            if p.at(COMMA) || p.at(R_PAREN) || !opt_type_name(p) {
+                p.error("expected a type");
+            } else {
+                opt_collate(p);
+            }
+            m.complete(p, COLUMN_DEF);
         }
         ColumnDefKind::CompositeFieldDef => {
             let m = p.start();
@@ -4392,6 +4409,7 @@ fn column(p: &mut Parser<'_>, kind: ColumnDefKind) {
             }
         }
     }
+    kind
 }
 
 fn at_period_column(p: &Parser<'_>) -> bool {
@@ -5344,7 +5362,6 @@ fn like_clause(p: &mut Parser<'_>) -> CompletedMarker {
 // [ AS ] alias ( column_definition [, ...] )
 // AS ( column_definition [, ...] )
 fn opt_from_alias(p: &mut Parser<'_>) -> Option<CompletedMarker> {
-    // TODO: we should split this into opt_col_def and opt_col_alias
     if !(p.at(AS_KW) || p.at_ts(NAME_FIRST) || p.at(L_PAREN)) {
         return None;
     }
@@ -5354,10 +5371,8 @@ fn opt_from_alias(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     if p.at_ts(NAME_FIRST) {
         table_alias(p);
     }
-    if p.at(L_PAREN) {
-        if !opt_column_list_with(p, ColumnDefKind::Alias) {
-            p.error("expected column list");
-        }
+    if p.at(L_PAREN) && !opt_column_list_with(p, ColumnDefKind::FromAliasColumn) {
+        p.error("expected column list");
     }
     Some(m.complete(p, FROM_ALIAS))
 }

crates/squawk_parser/tests/data/err/select.sql

@@ -147,5 +147,12 @@ select 1 union with x as (select 2) select * from x;
 select f(1, all 2);
 select f(1, distinct 2);
 
+-- only column def list list allowed, not alias
+select * from rows from (f() t);
+select * from rows from (f() as t(a int));
+
+-- column def columns a type
+select * from rows from (f() as (a));
+
 -- trailing comma at EOF
 select 1,

crates/squawk_parser/tests/snapshots/tests__misc_ok.snap

@@ -760,9 +760,9 @@ SOURCE_FILE
           WHITESPACE " "
           TABLE_ALIAS
             IDENT "x"
-          ALIAS_COLUMN_LIST
+          COLUMN_DEF_LIST
             L_PAREN "("
-            ALIAS_COLUMN
+            COLUMN_DEF
               COLUMN_NAME
                 IDENT "\"index\""
               WHITESPACE " "
@@ -772,7 +772,7 @@ SOURCE_FILE
                     INT_KW "int"
             COMMA ","
             WHITESPACE " "
-            ALIAS_COLUMN
+            COLUMN_DEF
               COLUMN_NAME
                 IDENT "\"document\""
               WHITESPACE " "
@@ -782,7 +782,7 @@ SOURCE_FILE
                     IDENT "jsonb"
             COMMA ","
             WHITESPACE " "
-            ALIAS_COLUMN
+            COLUMN_DEF
               COLUMN_NAME
                 IDENT "relevance_score"
               WHITESPACE " "