fix(pretty_print): print an unexpected AST instead of panicking

crates/pgls_pretty_print/src/nodes/a_const.rs

@@ -10,8 +10,6 @@ pub(super) fn emit_a_const(e: &mut EventEmitter, n: &AConst) {
         e.token(TokenKind::NULL_KW);
     } else if let Some(ref val) = n.val {
         emit_val(e, val);
-    } else {
-        unreachable!("AConst must have either isnull=true or a val");
     }
 
     e.group_end();

crates/pgls_pretty_print/src/nodes/alter_fdw_stmt.rs

@@ -23,7 +23,10 @@ pub(super) fn emit_alter_fdw_stmt(e: &mut EventEmitter, n: &AlterFdwStmt) {
         e.indent_start();
         for opt in n.func_options.iter() {
             e.line(LineType::SoftOrSpace);
-            let def_elem = assert_node_variant!(DefElem, opt);
+            let Some(NodeEnum::DefElem(def_elem)) = opt.node.as_ref() else {
+                emit_node(e, opt);
+                continue;
+            };
 
             match def_elem.defname.as_str() {
                 "handler" => {

crates/pgls_pretty_print/src/nodes/alter_function_stmt.rs

@@ -22,7 +22,10 @@ pub(super) fn emit_alter_function_stmt(e: &mut EventEmitter, n: &AlterFunctionSt
     if !n.actions.is_empty() {
         e.indent_start();
         for action in sort_function_options(&n.actions) {
-            let def_elem = assert_node_variant!(DefElem, &action);
+            let Some(NodeEnum::DefElem(def_elem)) = action.node.as_ref() else {
+                emit_node(e, &action);
+                continue;
+            };
             e.line(LineType::SoftOrSpace);
             format_function_option(e, def_elem);
         }

crates/pgls_pretty_print/src/nodes/alter_table_cmd.rs

@@ -74,7 +74,11 @@ pub(super) fn emit_alter_table_cmd_of(
             e.token(TokenKind::TYPE_KW);
             if let Some(ref def) = cmd.def {
                 // Extract ColumnDef from Node to emit only type-related attributes
-                let column_def = assert_node_variant!(ColumnDef, def);
+                let Some(NodeEnum::ColumnDef(column_def)) = def.node.as_ref() else {
+                    e.space();
+                    emit_node(e, def);
+                    return;
+                };
 
                 // Emit type name (no space before - TYPE keyword already emitted)
                 if let Some(ref typename) = column_def.type_name {

crates/pgls_pretty_print/src/nodes/alter_table_move_all_stmt.rs

@@ -28,7 +28,10 @@ pub(super) fn emit_alter_table_move_all_stmt(e: &mut EventEmitter, n: &AlterTabl
         e.token(TokenKind::BY_KW);
         e.space();
         emit_comma_separated_list(e, &n.roles, |e, node| {
-            let role_spec = assert_node_variant!(RoleSpec, node);
+            let Some(NodeEnum::RoleSpec(role_spec)) = node.node.as_ref() else {
+                emit_node(e, node);
+                return;
+            };
             super::emit_role_spec(e, role_spec);
         });
     }

crates/pgls_pretty_print/src/nodes/alter_table_stmt.rs

@@ -39,7 +39,10 @@ pub(super) fn emit_alter_table_stmt(e: &mut EventEmitter, n: &AlterTableStmt) {
             }
 
             // Extract AlterTableCmd from Node
-            let cmd = assert_node_variant!(AlterTableCmd, cmd_node);
+            let Some(NodeEnum::AlterTableCmd(cmd)) = cmd_node.node.as_ref() else {
+                emit_node(e, cmd_node);
+                continue;
+            };
             super::emit_alter_table_cmd_of(e, cmd, n.objtype());
         }
 

crates/pgls_pretty_print/src/nodes/bool_expr.rs

@@ -33,7 +33,7 @@ pub(super) fn emit_bool_expr_as(e: &mut EventEmitter, n: &BoolExpr, group: Opera
                 BoolExprType::AndExpr => emit_variadic_bool_expr(e, n, TokenKind::AND_KW),
                 BoolExprType::OrExpr => emit_variadic_bool_expr(e, n, TokenKind::OR_KW),
                 BoolExprType::NotExpr => emit_not_expr(e, n),
-                BoolExprType::Undefined => unreachable!("Undefined BoolExprType"),
+                BoolExprType::Undefined => {}
             }
 
             e.expression_group_end();
@@ -108,13 +108,6 @@ fn emit_variadic_operands(
 fn emit_not_expr(e: &mut EventEmitter, n: &BoolExpr) {
     e.token(TokenKind::NOT_KW);
 
-    if n.args.len() != 1 {
-        panic!(
-            "NOT expressions should have exactly one argument, got {}",
-            n.args.len()
-        );
-    }
-
     if let Some(arg) = n.args.first() {
         e.space();
         emit_bool_operand(e, arg, BoolExprType::NotExpr);

crates/pgls_pretty_print/src/nodes/clauses/options.rs

@@ -17,7 +17,10 @@ pub(crate) fn emit_options_clause(e: &mut EventEmitter, options: &[Node]) {
     e.token(TokenKind::OPTIONS_KW);
     e.space();
     emit_parenthesized_list(e, options, |e, n| {
-        let def_elem = assert_node_variant!(DefElem, n);
+        let Some(NodeEnum::DefElem(def_elem)) = n.node.as_ref() else {
+            emit_node(e, n);
+            return;
+        };
         emit_options_def_elem(e, def_elem);
     });
 }

crates/pgls_pretty_print/src/nodes/clauses/set_clause.rs

@@ -36,12 +36,22 @@ pub(crate) fn emit_set_clause_list(e: &mut EventEmitter, nodes: &[pgls_query::No
         }
 
         let node = &nodes[index];
-        let target = assert_node_variant!(ResTarget, node);
+        let Some(NodeEnum::ResTarget(target)) = node.node.as_ref() else {
+            emit_node(e, node);
+            index += 1;
+            continue;
+        };
 
         let consumed = if let Some(ref val) = target.val {
             match val.node.as_ref() {
                 Some(NodeEnum::MultiAssignRef(multi)) if multi.colno == 1 => {
-                    emit_multi_assign_clause(e, nodes, index, multi)
+                    match multi.source.as_deref() {
+                        Some(source) => emit_multi_assign_clause(e, nodes, index, multi, source),
+                        None => {
+                            emit_set_clause(e, target);
+                            1
+                        }
+                    }
                 }
                 _ => {
                     emit_set_clause(e, target);
@@ -62,20 +72,14 @@ fn emit_multi_assign_clause(
     nodes: &[pgls_query::Node],
     start: usize,
     multi: &MultiAssignRef,
+    source_node: &Node,
 ) -> usize {
     let total = multi.ncolumns.max(1) as usize;
     debug_assert_eq!(multi.colno, 1, "MultiAssignRef should start at colno 1");
 
-    let end = start + total;
-    debug_assert!(
-        end <= nodes.len(),
-        "MultiAssignRef spans beyond target list"
-    );
-
-    let source_node = multi
-        .source
-        .as_ref()
-        .expect("MultiAssignRef source missing row expression");
+    // The columns of `(a, b) = ...` are the next `ncolumns` targets. A source spanning past the
+    // list writes the targets there are, and the AST check refuses the output.
+    let end = (start + total).min(nodes.len());
 
     // Check if source is a RowExpr - if so, we may expand it; otherwise emit as-is
     let maybe_row_expr = if let Some(pgls_query::NodeEnum::RowExpr(r)) = source_node.node.as_ref() {
@@ -104,8 +108,10 @@ fn emit_multi_assign_clause(
             e.line(LineType::SoftOrSpace);
         }
 
-        let target = assert_node_variant!(ResTarget, node);
-        emit_column_name_with_indirection(e, target);
+        match node.node.as_ref() {
+            Some(NodeEnum::ResTarget(target)) => emit_column_name_with_indirection(e, target),
+            _ => emit_node(e, node),
+        }
     }
     e.indent_end();
     e.line(LineType::Soft);

crates/pgls_pretty_print/src/nodes/clauses/window_frame.rs

@@ -117,16 +117,16 @@ fn emit_frame_bound(
                 e.space();
                 e.token(TokenKind::ROW_KW);
             } else if options & FRAMEOPTION_START_OFFSET_PRECEDING != 0 {
-                let offset_node =
-                    offset.expect("FRAMEOPTION_START_OFFSET_PRECEDING requires start_offset");
-                emit_node(e, offset_node);
-                e.space();
+                if let Some(offset) = offset {
+                    emit_node(e, offset);
+                    e.space();
+                }
                 emit_keyword(e, "PRECEDING");
             } else if options & FRAMEOPTION_START_OFFSET_FOLLOWING != 0 {
-                let offset_node =
-                    offset.expect("FRAMEOPTION_START_OFFSET_FOLLOWING requires start_offset");
-                emit_node(e, offset_node);
-                e.space();
+                if let Some(offset) = offset {
+                    emit_node(e, offset);
+                    e.space();
+                }
                 emit_keyword(e, "FOLLOWING");
             } else {
                 debug_assert!(false, "unhandled window frame start options: {options:#x}");
@@ -150,16 +150,16 @@ fn emit_frame_bound(
                 e.space();
                 e.token(TokenKind::ROW_KW);
             } else if options & FRAMEOPTION_END_OFFSET_PRECEDING != 0 {
-                let offset_node =
-                    offset.expect("FRAMEOPTION_END_OFFSET_PRECEDING requires end_offset");
-                emit_node(e, offset_node);
-                e.space();
+                if let Some(offset) = offset {
+                    emit_node(e, offset);
+                    e.space();
+                }
                 emit_keyword(e, "PRECEDING");
             } else if options & FRAMEOPTION_END_OFFSET_FOLLOWING != 0 {
-                let offset_node =
-                    offset.expect("FRAMEOPTION_END_OFFSET_FOLLOWING requires end_offset");
-                emit_node(e, offset_node);
-                e.space();
+                if let Some(offset) = offset {
+                    emit_node(e, offset);
+                    e.space();
+                }
                 emit_keyword(e, "FOLLOWING");
             } else {
                 debug_assert!(false, "unhandled window frame end options: {options:#x}");

crates/pgls_pretty_print/src/nodes/column_def.rs

@@ -68,7 +68,10 @@ pub(super) fn emit_column_def(e: &mut EventEmitter, n: &ColumnDef) {
             &n.fdwoptions,
             ListSeparatorSpacing::Space,
             |e, opt| {
-                let def_elem = assert_node_variant!(DefElem, opt);
+                let Some(NodeEnum::DefElem(def_elem)) = opt.node.as_ref() else {
+                    emit_node(e, opt);
+                    return;
+                };
                 emit_options_def_elem(e, def_elem);
             },
         );

crates/pgls_pretty_print/src/nodes/constraint.rs

@@ -484,7 +484,10 @@ fn emit_deferrable(e: &mut EventEmitter, n: &Constraint, continued: &mut bool) {
 
 /// Emits one element of an exclusion constraint: `column WITH operator`.
 fn emit_exclusion(e: &mut EventEmitter, exclusion: &pgls_query::Node) {
-    let exclusion_list = assert_node_variant!(List, exclusion);
+    let Some(NodeEnum::List(exclusion_list)) = exclusion.node.as_ref() else {
+        emit_node(e, exclusion);
+        return;
+    };
     debug_assert!(exclusion_list.items.len() >= 2);
 
     if let Some(index_elem) = exclusion_list.items.first() {

crates/pgls_pretty_print/src/nodes/copy_stmt.rs

@@ -62,7 +62,10 @@ pub(super) fn emit_copy_stmt(e: &mut EventEmitter, n: &CopyStmt) {
         e.line(LineType::Soft);
         e.indent_start();
         emit_comma_separated_list(e, &n.options, |e, n| {
-            let def_elem = assert_node_variant!(DefElem, n);
+            let Some(NodeEnum::DefElem(def_elem)) = n.node.as_ref() else {
+                emit_node(e, n);
+                return;
+            };
             emit_copy_option(e, def_elem);
         });
         e.indent_end();

crates/pgls_pretty_print/src/nodes/create_enum_stmt.rs

@@ -24,7 +24,10 @@ pub(super) fn emit_create_enum_stmt(e: &mut EventEmitter, n: &CreateEnumStmt) {
     if !n.vals.is_empty() {
         e.space();
         emit_parenthesized_list(e, &n.vals, |e, n| {
-            let s = assert_node_variant!(String, n);
+            let Some(NodeEnum::String(s)) = n.node.as_ref() else {
+                emit_node(e, n);
+                return;
+            };
             emit_string_literal(e, s);
         });
     }

crates/pgls_pretty_print/src/nodes/create_extension_stmt.rs

@@ -22,7 +22,10 @@ pub(super) fn emit_create_extension_stmt(e: &mut EventEmitter, n: &CreateExtensi
         e.token(TokenKind::WITH_KW);
 
         for opt in &n.options {
-            let def = assert_node_variant!(DefElem, opt);
+            let Some(NodeEnum::DefElem(def)) = opt.node.as_ref() else {
+                emit_node(e, opt);
+                continue;
+            };
             e.space();
             emit_extension_option(e, def);
         }

crates/pgls_pretty_print/src/nodes/create_fdw_stmt.rs

@@ -20,7 +20,10 @@ pub(super) fn emit_create_fdw_stmt(e: &mut EventEmitter, n: &CreateFdwStmt) {
         e.line(LineType::SoftOrSpace);
         e.indent_start();
         for opt in &n.func_options {
-            let def_elem = assert_node_variant!(DefElem, opt);
+            let Some(NodeEnum::DefElem(def_elem)) = opt.node.as_ref() else {
+                emit_node(e, opt);
+                continue;
+            };
 
             match def_elem.defname.as_str() {
                 "handler" => {

crates/pgls_pretty_print/src/nodes/create_table_as_stmt.rs

@@ -49,7 +49,10 @@ pub(super) fn emit_create_table_as_stmt(e: &mut EventEmitter, n: &CreateTableAsS
             if !into.col_names.is_empty() {
                 e.space();
                 emit_parenthesized_list(e, &into.col_names, |e, node| {
-                    let string = assert_node_variant!(String, node);
+                    let Some(NodeEnum::String(string)) = node.node.as_ref() else {
+                        emit_node(e, node);
+                        return;
+                    };
                     emit_string(e, string);
                 });
             }

crates/pgls_pretty_print/src/nodes/create_trig_stmt.rs

@@ -156,7 +156,10 @@ pub(super) fn emit_create_trig_stmt(e: &mut EventEmitter, n: &CreateTrigStmt) {
 
 fn emit_trigger_transitions(e: &mut EventEmitter, rels: &[pgls_query::Node]) {
     emit_space_separated_list(e, rels, |e, rel| {
-        let transition = assert_node_variant!(TriggerTransition, rel);
+        let Some(NodeEnum::TriggerTransition(transition)) = rel.node.as_ref() else {
+            emit_node(e, rel);
+            return;
+        };
 
         if transition.is_new {
             e.token(TokenKind::NEW_KW);

crates/pgls_pretty_print/src/nodes/func_call.rs

@@ -168,25 +168,27 @@ fn emit_standard_function(e: &mut EventEmitter, n: &FuncCall) {
             e.token(TokenKind::IDENT("*".to_string()));
         } else if !n.args.is_empty() {
             // Handle VARIADIC - if func_variadic is true, prepend VARIADIC to the last argument
-            if n.func_variadic && !n.args.is_empty() {
+            if n.func_variadic
+                && let Some((variadic, leading)) = n.args.split_last()
+            {
                 // Emit non-variadic args first
-                for (idx, arg) in n.args.iter().take(n.args.len() - 1).enumerate() {
+                for (idx, arg) in leading.iter().enumerate() {
                     if idx > 0 {
                         e.token(TokenKind::COMMA);
                         e.line(LineType::SoftOrSpace);
                     }
                     emit_node(e, arg);
                 }
 
-                if n.args.len() > 1 {
+                if !leading.is_empty() {
                     e.token(TokenKind::COMMA);
                     e.line(LineType::SoftOrSpace);
                 }
 
                 // Emit VARIADIC with the last argument
                 e.token(TokenKind::VARIADIC_KW);
                 e.space();
-                emit_node(e, n.args.last().unwrap());
+                emit_node(e, variadic);
             } else if let Some(group_size) = configured_argument_group_size(e, n) {
                 emit_grouped_arguments(e, &n.args, group_size);
             } else {

crates/pgls_pretty_print/src/nodes/into_clause.rs

@@ -37,7 +37,10 @@ pub(super) fn emit_into_clause(e: &mut EventEmitter, n: &IntoClause) {
                 e.line(LineType::SoftOrSpace);
             }
             emit_comma_separated_list(e, &n.col_names, |e, node| {
-                let ident = assert_node_variant!(String, node);
+                let Some(NodeEnum::String(ident)) = node.node.as_ref() else {
+                    emit_node(e, node);
+                    return;
+                };
                 emit_string(e, ident);
             });
             if n.col_names.len() > 1 {

crates/pgls_pretty_print/src/nodes/json_table.rs

@@ -30,7 +30,10 @@ pub(super) fn emit_json_table(e: &mut EventEmitter, n: &JsonTable) {
         e.token(TokenKind::PASSING_KW);
         e.space();
         emit_comma_separated_list(e, &n.passing, |e, node| {
-            let argument = assert_node_variant!(JsonArgument, node);
+            let Some(NodeEnum::JsonArgument(argument)) = node.node.as_ref() else {
+                emit_node(e, node);
+                return;
+            };
             super::emit_json_argument(e, argument);
         });
     }

crates/pgls_pretty_print/src/nodes/merge_stmt.rs

@@ -39,7 +39,10 @@ pub(super) fn emit_merge_stmt(e: &mut EventEmitter, n: &MergeStmt) {
 
     // WHEN clauses
     for when_clause_node in &n.merge_when_clauses {
-        let when_clause = assert_node_variant!(MergeWhenClause, when_clause_node);
+        let Some(NodeEnum::MergeWhenClause(when_clause)) = when_clause_node.node.as_ref() else {
+            emit_node(e, when_clause_node);
+            continue;
+        };
         e.line(LineType::SoftOrSpace);
         emit_merge_when_clause(e, when_clause);
     }

crates/pgls_pretty_print/src/nodes/merge_when_clause.rs

@@ -64,7 +64,10 @@ pub(super) fn emit_merge_when_clause(e: &mut EventEmitter, clause: &MergeWhenCla
                 e.line(LineType::Soft);
                 e.indent_start();
                 emit_comma_separated_list(e, &clause.target_list, |emitter, node| {
-                    let target = assert_node_variant!(ResTarget, node);
+                    let Some(NodeEnum::ResTarget(target)) = node.node.as_ref() else {
+                        emit_node(emitter, node);
+                        return;
+                    };
                     if !target.name.is_empty() {
                         emit_identifier_maybe_quoted(emitter, &target.name);
                     }