diff --git a/package-gale/TODO.md b/package-gale/TODO.md index 56ea2178b..757a81d6a 100644 --- a/package-gale/TODO.md +++ b/package-gale/TODO.md @@ -1,40 +1,5 @@ # Gale TODO -## Remove `store` parameter from `gen_element` - -`gen_element` has a `store: bool` parameter that controls generated variable naming: - -- `store=true`: `let field_name = parse_xxx(p)?;` (meaningful name for struct field assignment) -- `store=false`: `let tok = parse_xxx(p)?;` (throwaway name) - -`store=false` is a workaround for a naming collision problem in `dedup_name`. The underlying issue is that `dedup_name` assumes sequential variable creation, but branching code (optionals, groups, prediction trees) creates variables in different scopes: - -``` -// gen_optional_with_lookahead generates: -if condition { - let k_limit = p.expect(...)?; - let expr = parse_expr(p)?; // dedup count 0 - if grp_kind == TK_K_OFFSET { ... } - let expr = parse_expr(p)?; // dedup count 0 again → collision! -} -``` - -With `store=false`, both become `let tok = ...` / `let tok_2 = ...` (separate namespace), avoiding the collision. But this is a hack — all generated variables should use meaningful names. - -### Root cause - -`dedup_name` tracks a flat counter per name. Optional/group paths increment this counter even though their variables are scoped to if-blocks. When mandatory elements follow, `gen_field_assignments` expects names at count N but the parsing code produced count N+K (shifted by optional paths). - -### Fix approach - -1. **Scope-aware naming**: Track which variables are in which scope. Variables inside if/else blocks don't affect the parent scope's counter. -2. **Or**: Make `gen_field_assignments` use the same `name_counts` instance that the parsing code used, instead of replaying from scratch. -3. **Or**: Wrap all non-field parsing (groups, optionals, prediction branches) in labeled scope blocks (`__scope: { ... }`) and use fresh `name_counts` inside. This isolates variable names to their scope. - -Approach 3 was partially implemented but incomplete — optional paths that share elements with the enclosing alt (e.g., `LIMIT expr ((OFFSET|',') expr)?` where `expr` appears both in the alt and inside the optional) need the parent's dedup counter to produce `expr_2` for the second occurrence. - -A complete fix likely requires combining approaches: scope blocks for isolation + parent counter awareness for shared element types. - ## Incomplete CST walker coverage The XML unparse output is missing tokens/nodes for several patterns due to `store=false` and non-simple groups: diff --git a/package-gale/src/parser_gen.wado b/package-gale/src/parser_gen.wado index 3346472d8..1c9a76025 100644 --- a/package-gale/src/parser_gen.wado +++ b/package-gale/src/parser_gen.wado @@ -1265,7 +1265,7 @@ fn gen_alt_body_skip(w: &mut CodeWriter, type_name: &String, variant_case: Optio gen_repeat(w, &rep, all_rules, lit_tokens, &mut name_counts); } } else { - gen_element(w, elem, all_rules, lit_tokens, true, &mut name_counts); + gen_element(w, elem, all_rules, lit_tokens, &mut name_counts); } } @@ -1349,7 +1349,7 @@ fn gen_alt_elements(w: &mut CodeWriter, elements: &Array, all_rules: &A gen_repeat(w, &rep, all_rules, lit_tokens, &mut name_counts); } } else { - gen_element(w, elem, all_rules, lit_tokens, true, &mut name_counts); + gen_element(w, elem, all_rules, lit_tokens, &mut name_counts); } } } @@ -1363,10 +1363,10 @@ fn gen_elements_with_non_greedy(w: &mut CodeWriter, elements: &Array, a let follow_second = compute_follow_second(elements, i + 1, all_rules, lit_tokens); gen_repeat_non_greedy(w, &rep, all_rules, lit_tokens, &follow, &follow_second, name_counts); } else { - gen_element(w, elem, all_rules, lit_tokens, false, name_counts); + gen_element(w, elem, all_rules, lit_tokens, name_counts); } } else { - gen_element(w, elem, all_rules, lit_tokens, false, name_counts); + gen_element(w, elem, all_rules, lit_tokens, name_counts); } } } @@ -1381,39 +1381,24 @@ fn is_ruleref_optional(elem: &Element) -> bool { return false; } -fn gen_element(w: &mut CodeWriter, elem: &Element, all_rules: &Array, lit_tokens: &Array, store: bool, name_counts: &mut Array<[String, i32]>) { +fn gen_element(w: &mut CodeWriter, elem: &Element, all_rules: &Array, lit_tokens: &Array, name_counts: &mut Array<[String, i32]>) { if let TokenRef(name) = *elem { let const_name = `TK_{name}`; - if store { - let field_name = dedup_name(&to_lower(&name), name_counts); - w.line(`let {field_name} = p.expect({const_name}, {escape_string(&name)})?;`); - } else { - let discard = dedup_name(&"tok", name_counts); - w.line(`let {discard} = p.expect({const_name}, {escape_string(&name)})?;`); - } + let field_name = dedup_name(&to_lower(&name), name_counts); + w.line(`let {field_name} = p.expect({const_name}, {escape_string(&name)})?;`); return; } if let Literal(text) = *elem { let const_name = literal_const_name(&text); let display = `'{text}'`; - if store { - let field_name = dedup_name(&literal_field_name(&text), name_counts); - w.line(`let {field_name} = p.expect({const_name}, {escape_string(&display)})?;`); - } else { - let discard = dedup_name(&"tok", name_counts); - w.line(`let {discard} = p.expect({const_name}, {escape_string(&display)})?;`); - } + let field_name = dedup_name(&literal_field_name(&text), name_counts); + w.line(`let {field_name} = p.expect({const_name}, {escape_string(&display)})?;`); return; } if let RuleRef(name) = *elem { let fn_name = `parse_{to_snake_case(&name)}`; - if store { - let field_name = dedup_name(&to_snake_case(&name), name_counts); - w.line(`let {field_name} = {fn_name}(p)?;`); - } else { - let discard = dedup_name(&"tok", name_counts); - w.line(`let {discard} = {fn_name}(p)?;`); - } + let field_name = dedup_name(&to_snake_case(&name), name_counts); + w.line(`let {field_name} = {fn_name}(p)?;`); return; } if let Repeat(rep) = *elem { @@ -1421,7 +1406,7 @@ fn gen_element(w: &mut CodeWriter, elem: &Element, all_rules: &Array return; } if let Group(alts) = *elem { - if store && is_simple_cst_group(&alts) { + if is_simple_cst_group(&alts) { gen_consume_group_store_optional(w, &alts, all_rules, lit_tokens, name_counts); } else { gen_consume_group(w, &alts, all_rules, lit_tokens, name_counts); @@ -1429,7 +1414,7 @@ fn gen_element(w: &mut CodeWriter, elem: &Element, all_rules: &Array return; } if let Label(lab) = *elem { - gen_element(w, &lab.element, all_rules, lit_tokens, store, name_counts); + gen_element(w, &lab.element, all_rules, lit_tokens, name_counts); return; } } @@ -1450,7 +1435,7 @@ fn gen_repeat(w: &mut CodeWriter, rep: &RepeatElement, all_rules: &Array = [{field_info.0}];`); @@ -1469,7 +1454,7 @@ fn gen_repeat(w: &mut CodeWriter, rep: &RepeatElement, all_rules: &Array::Some({field_info.0})`); w.else_begin("else"); @@ -1493,14 +1478,14 @@ fn gen_repeat(w: &mut CodeWriter, rep: &RepeatElement, all_rules: &Array = []; - gen_element(w, inner, all_rules, lit_tokens, false, &mut nc); + gen_element(w, inner, all_rules, lit_tokens, &mut nc); w.end(); } if let Plus = rep.kind { - gen_element(w, inner, all_rules, lit_tokens, false, name_counts); + gen_element(w, inner, all_rules, lit_tokens, name_counts); w.begin(`while {first_check_str(&first)}`); let mut nc: Array<[String, i32]> = []; - gen_element(w, inner, all_rules, lit_tokens, false, &mut nc); + gen_element(w, inner, all_rules, lit_tokens, &mut nc); w.end(); } if let Optional = rep.kind { @@ -1578,13 +1563,13 @@ fn gen_repeat_non_greedy(w: &mut CodeWriter, rep: &RepeatElement, all_rules: &Ar let field_info = element_field_info(inner); if is_plus { let mut nc: Array<[String, i32]> = []; - gen_element(w, inner, all_rules, lit_tokens, true, &mut nc); + gen_element(w, inner, all_rules, lit_tokens, &mut nc); let list_name = dedup_name(&`{field_info.0}_list`, name_counts); w.line(`let mut {list_name}: Array<{field_info.1}> = [{field_info.0}];`); if while_cond != "false" { w.begin(`while {while_cond}`); let mut nc2: Array<[String, i32]> = []; - gen_element(w, inner, all_rules, lit_tokens, true, &mut nc2); + gen_element(w, inner, all_rules, lit_tokens, &mut nc2); w.line(`{list_name}.append({field_info.0});`); w.end(); } @@ -1594,19 +1579,19 @@ fn gen_repeat_non_greedy(w: &mut CodeWriter, rep: &RepeatElement, all_rules: &Ar if while_cond != "false" { w.begin(`while {while_cond}`); let mut nc: Array<[String, i32]> = []; - gen_element(w, inner, all_rules, lit_tokens, true, &mut nc); + gen_element(w, inner, all_rules, lit_tokens, &mut nc); w.line(`{list_name}.append({field_info.0});`); w.end(); } } } else { if is_plus { - gen_element(w, inner, all_rules, lit_tokens, false, name_counts); + gen_element(w, inner, all_rules, lit_tokens, name_counts); } if while_cond != "false" { w.begin(`while {while_cond}`); let mut nc: Array<[String, i32]> = []; - gen_element(w, inner, all_rules, lit_tokens, false, &mut nc); + gen_element(w, inner, all_rules, lit_tokens, &mut nc); w.end(); } } @@ -1658,7 +1643,7 @@ fn gen_repeat_with_follow(w: &mut CodeWriter, rep: &RepeatElement, all_rules: &A let opt_name = dedup_name(&field_info.0, name_counts); w.begin(`let {opt_name}: Option<{type_str}> = if {first_check_str(&first)}`); let mut nc: Array<[String, i32]> = []; - gen_element(w, inner, all_rules, lit_tokens, true, &mut nc); + gen_element(w, inner, all_rules, lit_tokens, &mut nc); w.line(`Option::<{type_str}>::Some({field_info.0})`); w.else_begin("else"); w.line("null"); @@ -1804,6 +1789,7 @@ fn gen_optional_with_lookahead(w: &mut CodeWriter, group_elements: &Array = []; for let mut k = 0; k < shape.len(); k += 1 { let idx = shape[k]; let elem = &group_elements[idx]; @@ -1811,13 +1797,13 @@ fn gen_optional_with_lookahead(w: &mut CodeWriter, group_elements: &Array = []; if let Group(alts) = *inner { for let mut i = 0; i < alts[0].elements.len(); i += 1 { - gen_element(w, &alts[0].elements[i], all_rules, lit_tokens, false, name_counts); + gen_element(w, &alts[0].elements[i], all_rules, lit_tokens, &mut nc); } } else { - gen_element(w, inner, all_rules, lit_tokens, false, name_counts); + gen_element(w, inner, all_rules, lit_tokens, &mut nc); } w.end(); return; @@ -1933,17 +1920,17 @@ fn gen_optional_with_backtrack(w: &mut CodeWriter, inner: &Element, all_rules: & w.line(`let {saved} = p.pos;`); w.begin(`{label}:`); + let mut bt_nc: Array<[String, i32]> = []; if let Group(alts) = *inner { if alts.len() == 1 { for let elem of alts[0].elements { - gen_element_failable(w, &elem, all_rules, lit_tokens, &saved, &label, name_counts); + gen_element_failable(w, &elem, all_rules, lit_tokens, &saved, &label, &mut bt_nc); } } else { - let mut nc: Array<[String, i32]> = []; - gen_element(w, inner, all_rules, lit_tokens, false, &mut nc); + gen_element(w, inner, all_rules, lit_tokens, &mut bt_nc); } } else { - gen_element_failable(w, inner, all_rules, lit_tokens, &saved, &label, name_counts); + gen_element_failable(w, inner, all_rules, lit_tokens, &saved, &label, &mut bt_nc); } w.end(); // label @@ -2169,11 +2156,13 @@ fn gen_consume_group(w: &mut CodeWriter, alts: &Array, all_rules: & if group.len() == 1 { let alt_idx = group[0]; - gen_elements_with_non_greedy(w, &alts[alt_idx].elements, all_rules, lit_tokens, name_counts); + let mut nc: Array<[String, i32]> = []; + gen_elements_with_non_greedy(w, &alts[alt_idx].elements, all_rules, lit_tokens, &mut nc); } else { let mut sorted_group = group.sorted(); sort_group_by_element_count(&mut sorted_group, alts); - gen_backtracking_body(w, &sorted_group, alts, all_rules, lit_tokens, name_counts); + let mut nc: Array<[String, i32]> = []; + gen_backtracking_body(w, &sorted_group, alts, all_rules, lit_tokens, &mut nc); } } w.end(); @@ -2422,12 +2411,12 @@ fn gen_group_prediction_code_skip(w: &mut CodeWriter, node: &PredictionNode, alt continue; } } - gen_element(w, &elem, all_rules, lit_tokens, false, name_counts); + gen_element(w, &elem, all_rules, lit_tokens, name_counts); } return; } if let Consume(c) = *node { - gen_element(w, &c.element, all_rules, lit_tokens, false, name_counts); + gen_element(w, &c.element, all_rules, lit_tokens, name_counts); gen_group_prediction_code_skip(w, &c.child, alts, all_rules, lit_tokens, name_counts, skip + 1); return; } @@ -2446,7 +2435,7 @@ fn gen_group_prediction_code_skip(w: &mut CodeWriter, node: &PredictionNode, alt w.begin(`if !{done_var}`); let mut nc: Array<[String, i32]> = []; for let mut i = skip; i < alt.elements.len(); i += 1 { - gen_element(w, &alt.elements[i], all_rules, lit_tokens, false, &mut nc); + gen_element(w, &alt.elements[i], all_rules, lit_tokens, &mut nc); } w.end(); } else { @@ -2580,12 +2569,12 @@ fn gen_lr_suffix_helpers(w: &mut CodeWriter, rule: &ParserRule, type_name: &Stri let discard = dedup_name(&"op_tok", &mut name_counts); w.line(`let {discard} = p.advance();`); } else { - gen_element(w, elem, all_rules, lit_tokens, false, &mut name_counts); + gen_element(w, elem, all_rules, lit_tokens, &mut name_counts); } } else if let Repeat(rep) = *elem { gen_repeat(w, &rep, all_rules, lit_tokens, &mut name_counts); } else { - gen_element(w, elem, all_rules, lit_tokens, true, &mut name_counts); + gen_element(w, elem, all_rules, lit_tokens, &mut name_counts); } } @@ -2889,7 +2878,7 @@ fn gen_prediction_code_inner(w: &mut CodeWriter, node: &PredictionNode, fn_name: return; } if let Consume(c) = *node { - gen_element(w, &c.element, all_rules, lit_tokens, true, name_counts); + gen_element(w, &c.element, all_rules, lit_tokens, name_counts); gen_prediction_code_inner(w, &c.child, fn_name, alts, type_name, all_rules, lit_tokens, skip + 1, name_counts); return; } diff --git a/package-gale/tests/golden/calculator.wado b/package-gale/tests/golden/calculator.wado index edaf433c0..c68bea375 100644 --- a/package-gale/tests/golden/calculator.wado +++ b/package-gale/tests/golden/calculator.wado @@ -1046,11 +1046,11 @@ fn parse_expression(p: &mut Parser) -> Result { while p.peek_kind() == TK_PLUS || p.peek_kind() == TK_MINUS { let grp_kind = p.peek_kind(); if grp_kind == TK_PLUS { - let tok = p.expect(TK_PLUS, "PLUS")?; + let plus = p.expect(TK_PLUS, "PLUS")?; } else if grp_kind == TK_MINUS { - let tok_2 = p.expect(TK_MINUS, "MINUS")?; + let minus = p.expect(TK_MINUS, "MINUS")?; } - let tok_3 = parse_multiplying_expression(p)?; + let multiplying_expression = parse_multiplying_expression(p)?; } return Result::::Ok(ExpressionNode { span: Span::new(start, p.last_end()), @@ -1064,11 +1064,11 @@ fn parse_multiplying_expression(p: &mut Parser) -> Result::Ok(MultiplyingExpressionNode { span: Span::new(start, p.last_end()), @@ -1080,8 +1080,8 @@ fn parse_pow_expression(p: &mut Parser) -> Result let start = p.peek().span.start; let signed_atom = parse_signed_atom(p)?; while p.peek_kind() == TK_POW { - let tok = p.expect(TK_POW, "POW")?; - let tok_2 = parse_signed_atom(p)?; + let pow = p.expect(TK_POW, "POW")?; + let signed_atom = parse_signed_atom(p)?; } return Result::::Ok(PowExpressionNode { span: Span::new(start, p.last_end()), @@ -1228,8 +1228,8 @@ fn parse_func_(p: &mut Parser) -> Result { let lparen = p.expect(TK_LPAREN, "LPAREN")?; let expression = parse_expression(p)?; while p.peek_kind() == TK_COMMA { - let tok = p.expect(TK_COMMA, "COMMA")?; - let tok_2 = parse_expression(p)?; + let comma = p.expect(TK_COMMA, "COMMA")?; + let expression = parse_expression(p)?; } let rparen = p.expect(TK_RPAREN, "RPAREN")?; return Result::::Ok(FuncNode { diff --git a/package-gale/tests/golden/json.wado b/package-gale/tests/golden/json.wado index 5f861ca5d..4a59dd256 100644 --- a/package-gale/tests/golden/json.wado +++ b/package-gale/tests/golden/json.wado @@ -673,8 +673,8 @@ fn parse_obj_bt_0(p: &mut Parser) -> Result { let lbrace = p.expect(TK_LIT_LBRACE, "'{'")?; let pair = parse_pair(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_pair(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let pair = parse_pair(p)?; } let rbrace = p.expect(TK_LIT_RBRACE, "'}'")?; return Result::::Ok(ObjNode::Alt0(ObjAlt0 { @@ -704,8 +704,8 @@ fn parse_obj(p: &mut Parser) -> Result { if p.peek_kind() == TK_STRING { let pair = parse_pair(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_pair(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let pair = parse_pair(p)?; } let rbrace = p.expect(TK_LIT_RBRACE, "'}'")?; return Result::::Ok(ObjNode::Alt0(ObjAlt0 { @@ -748,8 +748,8 @@ fn parse_arr_bt_0(p: &mut Parser) -> Result { let lbracket = p.expect(TK_LIT_LBRACKET, "'['")?; let value = parse_value(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_value(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let value = parse_value(p)?; } let rbracket = p.expect(TK_LIT_RBRACKET, "']'")?; return Result::::Ok(ArrNode::Alt0(ArrAlt0 { @@ -779,8 +779,8 @@ fn parse_arr(p: &mut Parser) -> Result { if p.peek_kind() == TK_STRING || p.peek_kind() == TK_NUMBER || p.peek_kind() == TK_LIT_LBRACE || p.peek_kind() == TK_LIT_LBRACKET || p.peek_kind() == TK_LIT_TRUE || p.peek_kind() == TK_LIT_FALSE || p.peek_kind() == TK_LIT_NULL { let value = parse_value(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_value(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let value = parse_value(p)?; } let rbracket = p.expect(TK_LIT_RBRACKET, "']'")?; return Result::::Ok(ArrNode::Alt0(ArrAlt0 { diff --git a/package-gale/tests/golden/sqlite.wado b/package-gale/tests/golden/sqlite.wado index f5876b020..ded8ab1cc 100644 --- a/package-gale/tests/golden/sqlite.wado +++ b/package-gale/tests/golden/sqlite.wado @@ -6419,7 +6419,7 @@ fn parse_sql_stmt_list(p: &mut Parser) -> Result { let semicolon = p.expect(TK_LIT_SEMI, "';'")?; semicolon_list.append(semicolon); } - let tok = parse_sql_stmt(p)?; + let sql_stmt = parse_sql_stmt(p)?; } let mut semicolon_list_2: Array = []; while p.peek_kind() == TK_LIT_SEMI { @@ -6437,11 +6437,11 @@ fn parse_sql_stmt_list(p: &mut Parser) -> Result { fn parse_sql_stmt(p: &mut Parser) -> Result { let start = p.peek().span.start; if p.peek_kind() == TK_K_EXPLAIN && p.peek_at(1) == TK_K_QUERY && p.peek_at(2) == TK_K_PLAN { - let tok = p.expect(TK_K_EXPLAIN, "K_EXPLAIN")?; - let tok_2 = p.expect(TK_K_QUERY, "K_QUERY")?; - let tok_3 = p.expect(TK_K_PLAN, "K_PLAN")?; + let k_explain = p.expect(TK_K_EXPLAIN, "K_EXPLAIN")?; + let k_query = p.expect(TK_K_QUERY, "K_QUERY")?; + let k_plan = p.expect(TK_K_PLAN, "K_PLAN")?; } else if p.peek_kind() == TK_K_EXPLAIN { - let tok_4 = p.expect(TK_K_EXPLAIN, "K_EXPLAIN")?; + let k_explain = p.expect(TK_K_EXPLAIN, "K_EXPLAIN")?; } let mut alter_table_stmt_or_analyze_stmt_or_attach_stmt_or_begin_stmt_or_commit_stmt_or_compound_select_stmt_or_create_index_stmt_or_create_table_stmt_or_create_trigger_stmt_or_create_view_stmt_or_create_virtual_table_stmt_or_delete_stmt_or_delete_stmt_limited_or_detach_stmt_or_drop_index_stmt_or_drop_table_stmt_or_drop_trigger_stmt_or_drop_view_stmt_or_factored_select_stmt_or_insert_stmt_or_pragma_stmt_or_reindex_stmt_or_release_stmt_or_rollback_stmt_or_savepoint_stmt_or_simple_select_stmt_or_select_stmt_or_update_stmt_or_update_stmt_limited_or_vacuum_stmt_inner: Option = null; let grp_kind = p.peek_kind(); @@ -6646,18 +6646,18 @@ fn parse_alter_table_stmt(p: &mut Parser) -> Result = if p.peek_kind() == TK_K_COLUMN { let k_column = p.expect(TK_K_COLUMN, "K_COLUMN")?; Option::::Some(k_column) } else { null }; - let tok_5 = parse_column_def(p)?; + let column_def = parse_column_def(p)?; } return Result::::Ok(AlterTableStmtNode { span: Span::new(start, p.last_end()), @@ -6693,9 +6693,9 @@ fn parse_analyze_stmt(p: &mut Parser) -> Result { } } if !bt_done { - let tok = parse_database_name(p)?; - let tok_2 = p.expect(TK_LIT_DOT, "'.'")?; - let tok_3 = parse_table_or_index_name(p)?; + let database_name = parse_database_name(p)?; + let dot = p.expect(TK_LIT_DOT, "'.'")?; + let table_or_index_name = parse_table_or_index_name(p)?; } } } @@ -6737,19 +6737,19 @@ fn parse_begin_stmt(p: &mut Parser) -> Result { opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_K_DEFERRED { - let tok = p.expect(TK_K_DEFERRED, "K_DEFERRED")?; + let k_deferred = p.expect(TK_K_DEFERRED, "K_DEFERRED")?; } else if grp_kind == TK_K_IMMEDIATE { - let tok_2 = p.expect(TK_K_IMMEDIATE, "K_IMMEDIATE")?; + let k_immediate = p.expect(TK_K_IMMEDIATE, "K_IMMEDIATE")?; } else if grp_kind == TK_K_EXCLUSIVE { - let tok_3 = p.expect(TK_K_EXCLUSIVE, "K_EXCLUSIVE")?; + let k_exclusive = p.expect(TK_K_EXCLUSIVE, "K_EXCLUSIVE")?; } } } if p.peek_kind() == TK_K_TRANSACTION && (p.peek_at(1) == TK_IDENTIFIER || p.peek_at(1) == TK_K_ABORT || p.peek_at(1) == TK_K_ACTION || p.peek_at(1) == TK_K_ADD || p.peek_at(1) == TK_K_AFTER || p.peek_at(1) == TK_K_ALL || p.peek_at(1) == TK_K_ALTER || p.peek_at(1) == TK_K_ANALYZE || p.peek_at(1) == TK_K_AND || p.peek_at(1) == TK_K_AS || p.peek_at(1) == TK_K_ASC || p.peek_at(1) == TK_K_ATTACH || p.peek_at(1) == TK_K_AUTOINCREMENT || p.peek_at(1) == TK_K_BEFORE || p.peek_at(1) == TK_K_BEGIN || p.peek_at(1) == TK_K_BETWEEN || p.peek_at(1) == TK_K_BY || p.peek_at(1) == TK_K_CASCADE || p.peek_at(1) == TK_K_CASE || p.peek_at(1) == TK_K_CAST || p.peek_at(1) == TK_K_CHECK || p.peek_at(1) == TK_K_COLLATE || p.peek_at(1) == TK_K_COLUMN || p.peek_at(1) == TK_K_COMMIT || p.peek_at(1) == TK_K_CONFLICT || p.peek_at(1) == TK_K_CONSTRAINT || p.peek_at(1) == TK_K_CREATE || p.peek_at(1) == TK_K_CROSS || p.peek_at(1) == TK_K_CURRENT_DATE || p.peek_at(1) == TK_K_CURRENT_TIME || p.peek_at(1) == TK_K_CURRENT_TIMESTAMP || p.peek_at(1) == TK_K_DATABASE || p.peek_at(1) == TK_K_DEFAULT || p.peek_at(1) == TK_K_DEFERRABLE || p.peek_at(1) == TK_K_DEFERRED || p.peek_at(1) == TK_K_DELETE || p.peek_at(1) == TK_K_DESC || p.peek_at(1) == TK_K_DETACH || p.peek_at(1) == TK_K_DISTINCT || p.peek_at(1) == TK_K_DROP || p.peek_at(1) == TK_K_EACH || p.peek_at(1) == TK_K_ELSE || p.peek_at(1) == TK_K_END || p.peek_at(1) == TK_K_ESCAPE || p.peek_at(1) == TK_K_EXCEPT || p.peek_at(1) == TK_K_EXCLUSIVE || p.peek_at(1) == TK_K_EXISTS || p.peek_at(1) == TK_K_EXPLAIN || p.peek_at(1) == TK_K_FAIL || p.peek_at(1) == TK_K_FOR || p.peek_at(1) == TK_K_FOREIGN || p.peek_at(1) == TK_K_FROM || p.peek_at(1) == TK_K_FULL || p.peek_at(1) == TK_K_GLOB || p.peek_at(1) == TK_K_GROUP || p.peek_at(1) == TK_K_HAVING || p.peek_at(1) == TK_K_IF || p.peek_at(1) == TK_K_IGNORE || p.peek_at(1) == TK_K_IMMEDIATE || p.peek_at(1) == TK_K_IN || p.peek_at(1) == TK_K_INDEX || p.peek_at(1) == TK_K_INDEXED || p.peek_at(1) == TK_K_INITIALLY || p.peek_at(1) == TK_K_INNER || p.peek_at(1) == TK_K_INSERT || p.peek_at(1) == TK_K_INSTEAD || p.peek_at(1) == TK_K_INTERSECT || p.peek_at(1) == TK_K_INTO || p.peek_at(1) == TK_K_IS || p.peek_at(1) == TK_K_ISNULL || p.peek_at(1) == TK_K_JOIN || p.peek_at(1) == TK_K_KEY || p.peek_at(1) == TK_K_LEFT || p.peek_at(1) == TK_K_LIKE || p.peek_at(1) == TK_K_LIMIT || p.peek_at(1) == TK_K_MATCH || p.peek_at(1) == TK_K_NATURAL || p.peek_at(1) == TK_K_NO || p.peek_at(1) == TK_K_NOT || p.peek_at(1) == TK_K_NOTNULL || p.peek_at(1) == TK_K_NULL || p.peek_at(1) == TK_K_OF || p.peek_at(1) == TK_K_OFFSET || p.peek_at(1) == TK_K_ON || p.peek_at(1) == TK_K_OR || p.peek_at(1) == TK_K_ORDER || p.peek_at(1) == TK_K_OUTER || p.peek_at(1) == TK_K_PLAN || p.peek_at(1) == TK_K_PRAGMA || p.peek_at(1) == TK_K_PRIMARY || p.peek_at(1) == TK_K_QUERY || p.peek_at(1) == TK_K_RAISE || p.peek_at(1) == TK_K_RECURSIVE || p.peek_at(1) == TK_K_REFERENCES || p.peek_at(1) == TK_K_REGEXP || p.peek_at(1) == TK_K_REINDEX || p.peek_at(1) == TK_K_RELEASE || p.peek_at(1) == TK_K_RENAME || p.peek_at(1) == TK_K_REPLACE || p.peek_at(1) == TK_K_RESTRICT || p.peek_at(1) == TK_K_RIGHT || p.peek_at(1) == TK_K_ROLLBACK || p.peek_at(1) == TK_K_ROW || p.peek_at(1) == TK_K_SAVEPOINT || p.peek_at(1) == TK_K_SELECT || p.peek_at(1) == TK_K_SET || p.peek_at(1) == TK_K_TABLE || p.peek_at(1) == TK_K_TEMP || p.peek_at(1) == TK_K_TEMPORARY || p.peek_at(1) == TK_K_THEN || p.peek_at(1) == TK_K_TO || p.peek_at(1) == TK_K_TRANSACTION || p.peek_at(1) == TK_K_TRIGGER || p.peek_at(1) == TK_K_UNION || p.peek_at(1) == TK_K_UNIQUE || p.peek_at(1) == TK_K_UPDATE || p.peek_at(1) == TK_K_USING || p.peek_at(1) == TK_K_VACUUM || p.peek_at(1) == TK_K_VALUES || p.peek_at(1) == TK_K_VIEW || p.peek_at(1) == TK_K_VIRTUAL || p.peek_at(1) == TK_K_WHEN || p.peek_at(1) == TK_K_WHERE || p.peek_at(1) == TK_K_WITH || p.peek_at(1) == TK_K_WITHOUT || p.peek_at(1) == TK_STRING_LITERAL || p.peek_at(1) == TK_LIT_LPAREN) { - let tok = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; - let tok_2 = parse_transaction_name(p)?; + let k_transaction = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; + let transaction_name = parse_transaction_name(p)?; } else if p.peek_kind() == TK_K_TRANSACTION { - let tok_3 = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; + let k_transaction = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; } return Result::::Ok(BeginStmtNode { span: Span::new(start, p.last_end()), @@ -6761,15 +6761,15 @@ fn parse_commit_stmt(p: &mut Parser) -> Result { let start = p.peek().span.start; let grp_kind = p.peek_kind(); if grp_kind == TK_K_COMMIT { - let tok = p.expect(TK_K_COMMIT, "K_COMMIT")?; + let k_commit = p.expect(TK_K_COMMIT, "K_COMMIT")?; } else if grp_kind == TK_K_END { - let tok_2 = p.expect(TK_K_END, "K_END")?; + let k_end = p.expect(TK_K_END, "K_END")?; } if p.peek_kind() == TK_K_TRANSACTION && (p.peek_at(1) == TK_IDENTIFIER || p.peek_at(1) == TK_K_ABORT || p.peek_at(1) == TK_K_ACTION || p.peek_at(1) == TK_K_ADD || p.peek_at(1) == TK_K_AFTER || p.peek_at(1) == TK_K_ALL || p.peek_at(1) == TK_K_ALTER || p.peek_at(1) == TK_K_ANALYZE || p.peek_at(1) == TK_K_AND || p.peek_at(1) == TK_K_AS || p.peek_at(1) == TK_K_ASC || p.peek_at(1) == TK_K_ATTACH || p.peek_at(1) == TK_K_AUTOINCREMENT || p.peek_at(1) == TK_K_BEFORE || p.peek_at(1) == TK_K_BEGIN || p.peek_at(1) == TK_K_BETWEEN || p.peek_at(1) == TK_K_BY || p.peek_at(1) == TK_K_CASCADE || p.peek_at(1) == TK_K_CASE || p.peek_at(1) == TK_K_CAST || p.peek_at(1) == TK_K_CHECK || p.peek_at(1) == TK_K_COLLATE || p.peek_at(1) == TK_K_COLUMN || p.peek_at(1) == TK_K_COMMIT || p.peek_at(1) == TK_K_CONFLICT || p.peek_at(1) == TK_K_CONSTRAINT || p.peek_at(1) == TK_K_CREATE || p.peek_at(1) == TK_K_CROSS || p.peek_at(1) == TK_K_CURRENT_DATE || p.peek_at(1) == TK_K_CURRENT_TIME || p.peek_at(1) == TK_K_CURRENT_TIMESTAMP || p.peek_at(1) == TK_K_DATABASE || p.peek_at(1) == TK_K_DEFAULT || p.peek_at(1) == TK_K_DEFERRABLE || p.peek_at(1) == TK_K_DEFERRED || p.peek_at(1) == TK_K_DELETE || p.peek_at(1) == TK_K_DESC || p.peek_at(1) == TK_K_DETACH || p.peek_at(1) == TK_K_DISTINCT || p.peek_at(1) == TK_K_DROP || p.peek_at(1) == TK_K_EACH || p.peek_at(1) == TK_K_ELSE || p.peek_at(1) == TK_K_END || p.peek_at(1) == TK_K_ESCAPE || p.peek_at(1) == TK_K_EXCEPT || p.peek_at(1) == TK_K_EXCLUSIVE || p.peek_at(1) == TK_K_EXISTS || p.peek_at(1) == TK_K_EXPLAIN || p.peek_at(1) == TK_K_FAIL || p.peek_at(1) == TK_K_FOR || p.peek_at(1) == TK_K_FOREIGN || p.peek_at(1) == TK_K_FROM || p.peek_at(1) == TK_K_FULL || p.peek_at(1) == TK_K_GLOB || p.peek_at(1) == TK_K_GROUP || p.peek_at(1) == TK_K_HAVING || p.peek_at(1) == TK_K_IF || p.peek_at(1) == TK_K_IGNORE || p.peek_at(1) == TK_K_IMMEDIATE || p.peek_at(1) == TK_K_IN || p.peek_at(1) == TK_K_INDEX || p.peek_at(1) == TK_K_INDEXED || p.peek_at(1) == TK_K_INITIALLY || p.peek_at(1) == TK_K_INNER || p.peek_at(1) == TK_K_INSERT || p.peek_at(1) == TK_K_INSTEAD || p.peek_at(1) == TK_K_INTERSECT || p.peek_at(1) == TK_K_INTO || p.peek_at(1) == TK_K_IS || p.peek_at(1) == TK_K_ISNULL || p.peek_at(1) == TK_K_JOIN || p.peek_at(1) == TK_K_KEY || p.peek_at(1) == TK_K_LEFT || p.peek_at(1) == TK_K_LIKE || p.peek_at(1) == TK_K_LIMIT || p.peek_at(1) == TK_K_MATCH || p.peek_at(1) == TK_K_NATURAL || p.peek_at(1) == TK_K_NO || p.peek_at(1) == TK_K_NOT || p.peek_at(1) == TK_K_NOTNULL || p.peek_at(1) == TK_K_NULL || p.peek_at(1) == TK_K_OF || p.peek_at(1) == TK_K_OFFSET || p.peek_at(1) == TK_K_ON || p.peek_at(1) == TK_K_OR || p.peek_at(1) == TK_K_ORDER || p.peek_at(1) == TK_K_OUTER || p.peek_at(1) == TK_K_PLAN || p.peek_at(1) == TK_K_PRAGMA || p.peek_at(1) == TK_K_PRIMARY || p.peek_at(1) == TK_K_QUERY || p.peek_at(1) == TK_K_RAISE || p.peek_at(1) == TK_K_RECURSIVE || p.peek_at(1) == TK_K_REFERENCES || p.peek_at(1) == TK_K_REGEXP || p.peek_at(1) == TK_K_REINDEX || p.peek_at(1) == TK_K_RELEASE || p.peek_at(1) == TK_K_RENAME || p.peek_at(1) == TK_K_REPLACE || p.peek_at(1) == TK_K_RESTRICT || p.peek_at(1) == TK_K_RIGHT || p.peek_at(1) == TK_K_ROLLBACK || p.peek_at(1) == TK_K_ROW || p.peek_at(1) == TK_K_SAVEPOINT || p.peek_at(1) == TK_K_SELECT || p.peek_at(1) == TK_K_SET || p.peek_at(1) == TK_K_TABLE || p.peek_at(1) == TK_K_TEMP || p.peek_at(1) == TK_K_TEMPORARY || p.peek_at(1) == TK_K_THEN || p.peek_at(1) == TK_K_TO || p.peek_at(1) == TK_K_TRANSACTION || p.peek_at(1) == TK_K_TRIGGER || p.peek_at(1) == TK_K_UNION || p.peek_at(1) == TK_K_UNIQUE || p.peek_at(1) == TK_K_UPDATE || p.peek_at(1) == TK_K_USING || p.peek_at(1) == TK_K_VACUUM || p.peek_at(1) == TK_K_VALUES || p.peek_at(1) == TK_K_VIEW || p.peek_at(1) == TK_K_VIRTUAL || p.peek_at(1) == TK_K_WHEN || p.peek_at(1) == TK_K_WHERE || p.peek_at(1) == TK_K_WITH || p.peek_at(1) == TK_K_WITHOUT || p.peek_at(1) == TK_STRING_LITERAL || p.peek_at(1) == TK_LIT_LPAREN) { - let tok_3 = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; - let tok_4 = parse_transaction_name(p)?; + let k_transaction = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; + let transaction_name = parse_transaction_name(p)?; } else if p.peek_kind() == TK_K_TRANSACTION { - let tok_5 = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; + let k_transaction = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; } return Result::::Ok(CommitStmtNode { span: Span::new(start, p.last_end()), @@ -6787,7 +6787,7 @@ fn parse_compound_select_stmt(p: &mut Parser) -> Result = if p.peek_kind() == TK_K_ALL { let k_all = p.expect(TK_K_ALL, "K_ALL")?; Option::::Some(k_all) @@ -6795,15 +6795,15 @@ fn parse_compound_select_stmt(p: &mut Parser) -> Result = if p.peek_kind() == TK_K_ALL { let k_all = p.expect(TK_K_ALL, "K_ALL")?; Option::::Some(k_all) @@ -6811,34 +6811,34 @@ fn parse_compound_select_stmt(p: &mut Parser) -> Result::Ok(CompoundSelectStmtNode { span: Span::new(start, p.last_end()), @@ -6858,9 +6858,9 @@ fn parse_create_index_stmt(p: &mut Parser) -> Result Result::Ok(CreateIndexStmtNode { span: Span::new(start, p.last_end()), @@ -6907,17 +6907,17 @@ fn parse_create_table_stmt(p: &mut Parser) -> Result Result::Ok(CreateTableStmtNode { span: Span::new(start, p.last_end()), @@ -6966,17 +6966,17 @@ fn parse_create_trigger_stmt(p: &mut Parser) -> Result Result Result = null; let grp_kind_2 = p.peek_kind(); if grp_kind_2 == TK_K_WITH || grp_kind_2 == TK_K_UPDATE || grp_kind_2 == TK_K_INSERT || grp_kind_2 == TK_K_REPLACE || grp_kind_2 == TK_K_DELETE || grp_kind_2 == TK_K_SELECT || grp_kind_2 == TK_K_VALUES { - if p.peek_kind() == TK_K_WITH { - if p.peek_at(1) == TK_K_UPDATE { - let tok_14 = parse_update_stmt(p)?; - } else if p.peek_at(1) == TK_K_INSERT || p.peek_at(1) == TK_K_REPLACE { - let tok_15 = parse_insert_stmt(p)?; - } else if p.peek_at(1) == TK_K_DELETE { - let tok_16 = parse_delete_stmt(p)?; - } else if p.peek_at(1) == TK_K_SELECT || p.peek_at(1) == TK_K_VALUES { - let tok_17 = parse_select_stmt(p)?; - } - } else if p.peek_kind() == TK_K_UPDATE { - let tok_18 = parse_update_stmt(p)?; - } else if p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_REPLACE { - let tok_19 = parse_insert_stmt(p)?; - } else if p.peek_kind() == TK_K_DELETE { - let tok_20 = parse_delete_stmt(p)?; - } else if p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_VALUES { - let tok_21 = parse_select_stmt(p)?; - } - } - let tok_22 = p.expect(TK_LIT_SEMI, "';'")?; + let saved_pos = p.pos; + let mut bt_done = false; + if !bt_done { + bt_try: { + let opt_r = parse_update_stmt(p); + if let Err(_) = opt_r { p.pos = saved_pos; break bt_try; } + update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner = Option::::Some(UpdateStmtOrInsertStmtOrDeleteStmtOrSelectStmtGroup::UpdateStmt(opt_r.unwrap())); + bt_done = true; + } + } + if !bt_done { + bt_try_2: { + let opt_r_2 = parse_insert_stmt(p); + if let Err(_) = opt_r_2 { p.pos = saved_pos; break bt_try_2; } + update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner = Option::::Some(UpdateStmtOrInsertStmtOrDeleteStmtOrSelectStmtGroup::InsertStmt(opt_r_2.unwrap())); + bt_done = true; + } + } + if !bt_done { + bt_try_3: { + let opt_r_3 = parse_delete_stmt(p); + if let Err(_) = opt_r_3 { p.pos = saved_pos; break bt_try_3; } + update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner = Option::::Some(UpdateStmtOrInsertStmtOrDeleteStmtOrSelectStmtGroup::DeleteStmt(opt_r_3.unwrap())); + bt_done = true; + } + } + if !bt_done { + let select_stmt = parse_select_stmt(p)?; + update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner = Option::::Some(UpdateStmtOrInsertStmtOrDeleteStmtOrSelectStmtGroup::SelectStmt(select_stmt)); + } + } + let update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt = update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner; + let semicolon = p.expect(TK_LIT_SEMI, "';'")?; while p.peek_kind() == TK_K_WITH || p.peek_kind() == TK_K_UPDATE || p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_REPLACE || p.peek_kind() == TK_K_DELETE || p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_VALUES { + let mut update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner: Option = null; let grp_kind = p.peek_kind(); if grp_kind == TK_K_WITH || grp_kind == TK_K_UPDATE || grp_kind == TK_K_INSERT || grp_kind == TK_K_REPLACE || grp_kind == TK_K_DELETE || grp_kind == TK_K_SELECT || grp_kind == TK_K_VALUES { - if p.peek_kind() == TK_K_WITH { - if p.peek_at(1) == TK_K_UPDATE { - let tok = parse_update_stmt(p)?; - } else if p.peek_at(1) == TK_K_INSERT || p.peek_at(1) == TK_K_REPLACE { - let tok_2 = parse_insert_stmt(p)?; - } else if p.peek_at(1) == TK_K_DELETE { - let tok_3 = parse_delete_stmt(p)?; - } else if p.peek_at(1) == TK_K_SELECT || p.peek_at(1) == TK_K_VALUES { - let tok_4 = parse_select_stmt(p)?; + let saved_pos = p.pos; + let mut bt_done = false; + if !bt_done { + bt_try: { + let opt_r = parse_update_stmt(p); + if let Err(_) = opt_r { p.pos = saved_pos; break bt_try; } + update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner = Option::::Some(UpdateStmtOrInsertStmtOrDeleteStmtOrSelectStmtGroup::UpdateStmt(opt_r.unwrap())); + bt_done = true; } - } else if p.peek_kind() == TK_K_UPDATE { - let tok_5 = parse_update_stmt(p)?; - } else if p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_REPLACE { - let tok_6 = parse_insert_stmt(p)?; - } else if p.peek_kind() == TK_K_DELETE { - let tok_7 = parse_delete_stmt(p)?; - } else if p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_VALUES { - let tok_8 = parse_select_stmt(p)?; + } + if !bt_done { + bt_try_2: { + let opt_r_2 = parse_insert_stmt(p); + if let Err(_) = opt_r_2 { p.pos = saved_pos; break bt_try_2; } + update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner = Option::::Some(UpdateStmtOrInsertStmtOrDeleteStmtOrSelectStmtGroup::InsertStmt(opt_r_2.unwrap())); + bt_done = true; + } + } + if !bt_done { + bt_try_3: { + let opt_r_3 = parse_delete_stmt(p); + if let Err(_) = opt_r_3 { p.pos = saved_pos; break bt_try_3; } + update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner = Option::::Some(UpdateStmtOrInsertStmtOrDeleteStmtOrSelectStmtGroup::DeleteStmt(opt_r_3.unwrap())); + bt_done = true; + } + } + if !bt_done { + let select_stmt = parse_select_stmt(p)?; + update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner = Option::::Some(UpdateStmtOrInsertStmtOrDeleteStmtOrSelectStmtGroup::SelectStmt(select_stmt)); } } - let tok_9 = p.expect(TK_LIT_SEMI, "';'")?; + let update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt = update_stmt_or_insert_stmt_or_delete_stmt_or_select_stmt_inner; + let semicolon = p.expect(TK_LIT_SEMI, "';'")?; } let k_end = p.expect(TK_K_END, "K_END")?; return Result::::Ok(CreateTriggerStmtNode { @@ -7108,17 +7134,17 @@ fn parse_create_view_stmt(p: &mut Parser) -> Result Result Result::Ok(CreateVirtualTableStmtNode { span: Span::new(start, p.last_end()), @@ -7196,8 +7222,8 @@ fn parse_delete_stmt(p: &mut Parser) -> Result { let k_from = p.expect(TK_K_FROM, "K_FROM")?; let qualified_table_name = parse_qualified_table_name(p)?; if p.peek_kind() == TK_K_WHERE { - let tok = p.expect(TK_K_WHERE, "K_WHERE")?; - let tok_2 = parse_expr(p)?; + let k_where = p.expect(TK_K_WHERE, "K_WHERE")?; + let expr = parse_expr(p)?; } return Result::::Ok(DeleteStmtNode { span: Span::new(start, p.last_end()), @@ -7220,49 +7246,49 @@ fn parse_delete_stmt_limited(p: &mut Parser) -> Result::Ok(DeleteStmtLimitedNode { span: Span::new(start, p.last_end()), @@ -7296,8 +7322,8 @@ fn parse_drop_index_stmt(p: &mut Parser) -> Result Result Result Result let k_drop = p.expect(TK_K_DROP, "K_DROP")?; let k_view = p.expect(TK_K_VIEW, "K_VIEW")?; if p.peek_kind() == TK_K_IF && p.peek_at(1) == TK_K_EXISTS { - let tok = p.expect(TK_K_IF, "K_IF")?; - let tok_2 = p.expect(TK_K_EXISTS, "K_EXISTS")?; + let k_if = p.expect(TK_K_IF, "K_IF")?; + let k_exists = p.expect(TK_K_EXISTS, "K_EXISTS")?; } if p.peek_kind() == TK_IDENTIFIER || p.peek_kind() == TK_K_ABORT || p.peek_kind() == TK_K_ACTION || p.peek_kind() == TK_K_ADD || p.peek_kind() == TK_K_AFTER || p.peek_kind() == TK_K_ALL || p.peek_kind() == TK_K_ALTER || p.peek_kind() == TK_K_ANALYZE || p.peek_kind() == TK_K_AND || p.peek_kind() == TK_K_AS || p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_ATTACH || p.peek_kind() == TK_K_AUTOINCREMENT || p.peek_kind() == TK_K_BEFORE || p.peek_kind() == TK_K_BEGIN || p.peek_kind() == TK_K_BETWEEN || p.peek_kind() == TK_K_BY || p.peek_kind() == TK_K_CASCADE || p.peek_kind() == TK_K_CASE || p.peek_kind() == TK_K_CAST || p.peek_kind() == TK_K_CHECK || p.peek_kind() == TK_K_COLLATE || p.peek_kind() == TK_K_COLUMN || p.peek_kind() == TK_K_COMMIT || p.peek_kind() == TK_K_CONFLICT || p.peek_kind() == TK_K_CONSTRAINT || p.peek_kind() == TK_K_CREATE || p.peek_kind() == TK_K_CROSS || p.peek_kind() == TK_K_CURRENT_DATE || p.peek_kind() == TK_K_CURRENT_TIME || p.peek_kind() == TK_K_CURRENT_TIMESTAMP || p.peek_kind() == TK_K_DATABASE || p.peek_kind() == TK_K_DEFAULT || p.peek_kind() == TK_K_DEFERRABLE || p.peek_kind() == TK_K_DEFERRED || p.peek_kind() == TK_K_DELETE || p.peek_kind() == TK_K_DESC || p.peek_kind() == TK_K_DETACH || p.peek_kind() == TK_K_DISTINCT || p.peek_kind() == TK_K_DROP || p.peek_kind() == TK_K_EACH || p.peek_kind() == TK_K_ELSE || p.peek_kind() == TK_K_END || p.peek_kind() == TK_K_ESCAPE || p.peek_kind() == TK_K_EXCEPT || p.peek_kind() == TK_K_EXCLUSIVE || p.peek_kind() == TK_K_EXISTS || p.peek_kind() == TK_K_EXPLAIN || p.peek_kind() == TK_K_FAIL || p.peek_kind() == TK_K_FOR || p.peek_kind() == TK_K_FOREIGN || p.peek_kind() == TK_K_FROM || p.peek_kind() == TK_K_FULL || p.peek_kind() == TK_K_GLOB || p.peek_kind() == TK_K_GROUP || p.peek_kind() == TK_K_HAVING || p.peek_kind() == TK_K_IF || p.peek_kind() == TK_K_IGNORE || p.peek_kind() == TK_K_IMMEDIATE || p.peek_kind() == TK_K_IN || p.peek_kind() == TK_K_INDEX || p.peek_kind() == TK_K_INDEXED || p.peek_kind() == TK_K_INITIALLY || p.peek_kind() == TK_K_INNER || p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_INSTEAD || p.peek_kind() == TK_K_INTERSECT || p.peek_kind() == TK_K_INTO || p.peek_kind() == TK_K_IS || p.peek_kind() == TK_K_ISNULL || p.peek_kind() == TK_K_JOIN || p.peek_kind() == TK_K_KEY || p.peek_kind() == TK_K_LEFT || p.peek_kind() == TK_K_LIKE || p.peek_kind() == TK_K_LIMIT || p.peek_kind() == TK_K_MATCH || p.peek_kind() == TK_K_NATURAL || p.peek_kind() == TK_K_NO || p.peek_kind() == TK_K_NOT || p.peek_kind() == TK_K_NOTNULL || p.peek_kind() == TK_K_NULL || p.peek_kind() == TK_K_OF || p.peek_kind() == TK_K_OFFSET || p.peek_kind() == TK_K_ON || p.peek_kind() == TK_K_OR || p.peek_kind() == TK_K_ORDER || p.peek_kind() == TK_K_OUTER || p.peek_kind() == TK_K_PLAN || p.peek_kind() == TK_K_PRAGMA || p.peek_kind() == TK_K_PRIMARY || p.peek_kind() == TK_K_QUERY || p.peek_kind() == TK_K_RAISE || p.peek_kind() == TK_K_RECURSIVE || p.peek_kind() == TK_K_REFERENCES || p.peek_kind() == TK_K_REGEXP || p.peek_kind() == TK_K_REINDEX || p.peek_kind() == TK_K_RELEASE || p.peek_kind() == TK_K_RENAME || p.peek_kind() == TK_K_REPLACE || p.peek_kind() == TK_K_RESTRICT || p.peek_kind() == TK_K_RIGHT || p.peek_kind() == TK_K_ROLLBACK || p.peek_kind() == TK_K_ROW || p.peek_kind() == TK_K_SAVEPOINT || p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_SET || p.peek_kind() == TK_K_TABLE || p.peek_kind() == TK_K_TEMP || p.peek_kind() == TK_K_TEMPORARY || p.peek_kind() == TK_K_THEN || p.peek_kind() == TK_K_TO || p.peek_kind() == TK_K_TRANSACTION || p.peek_kind() == TK_K_TRIGGER || p.peek_kind() == TK_K_UNION || p.peek_kind() == TK_K_UNIQUE || p.peek_kind() == TK_K_UPDATE || p.peek_kind() == TK_K_USING || p.peek_kind() == TK_K_VACUUM || p.peek_kind() == TK_K_VALUES || p.peek_kind() == TK_K_VIEW || p.peek_kind() == TK_K_VIRTUAL || p.peek_kind() == TK_K_WHEN || p.peek_kind() == TK_K_WHERE || p.peek_kind() == TK_K_WITH || p.peek_kind() == TK_K_WITHOUT || p.peek_kind() == TK_STRING_LITERAL || p.peek_kind() == TK_LIT_LPAREN { let opt_saved = p.pos; @@ -7405,31 +7431,31 @@ fn parse_factored_select_stmt(p: &mut Parser) -> Result::Ok(FactoredSelectStmtNode { span: Span::new(start, p.last_end()), @@ -7448,27 +7474,27 @@ fn parse_insert_stmt(p: &mut Parser) -> Result { }; let grp_kind = p.peek_kind(); if grp_kind == TK_K_INSERT { - let tok = p.expect(TK_K_INSERT, "K_INSERT")?; + let k_insert = p.expect(TK_K_INSERT, "K_INSERT")?; if p.peek_kind() == TK_K_OR { if p.peek_at(1) == TK_K_REPLACE { - let tok_2 = p.expect(TK_K_OR, "K_OR")?; - let tok_3 = p.expect(TK_K_REPLACE, "K_REPLACE")?; + let k_or = p.expect(TK_K_OR, "K_OR")?; + let k_replace = p.expect(TK_K_REPLACE, "K_REPLACE")?; } else if p.peek_at(1) == TK_K_ROLLBACK { - let tok_4 = p.expect(TK_K_OR, "K_OR")?; - let tok_5 = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; + let k_or_2 = p.expect(TK_K_OR, "K_OR")?; + let k_rollback = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; } else if p.peek_at(1) == TK_K_ABORT { - let tok_6 = p.expect(TK_K_OR, "K_OR")?; - let tok_7 = p.expect(TK_K_ABORT, "K_ABORT")?; + let k_or_3 = p.expect(TK_K_OR, "K_OR")?; + let k_abort = p.expect(TK_K_ABORT, "K_ABORT")?; } else if p.peek_at(1) == TK_K_FAIL { - let tok_8 = p.expect(TK_K_OR, "K_OR")?; - let tok_9 = p.expect(TK_K_FAIL, "K_FAIL")?; + let k_or_4 = p.expect(TK_K_OR, "K_OR")?; + let k_fail = p.expect(TK_K_FAIL, "K_FAIL")?; } else if p.peek_at(1) == TK_K_IGNORE { - let tok_10 = p.expect(TK_K_OR, "K_OR")?; - let tok_11 = p.expect(TK_K_IGNORE, "K_IGNORE")?; + let k_or_5 = p.expect(TK_K_OR, "K_OR")?; + let k_ignore = p.expect(TK_K_IGNORE, "K_IGNORE")?; } } } else if grp_kind == TK_K_REPLACE { - let tok_12 = p.expect(TK_K_REPLACE, "K_REPLACE")?; + let k_replace = p.expect(TK_K_REPLACE, "K_REPLACE")?; } let k_into = p.expect(TK_K_INTO, "K_INTO")?; if p.peek_kind() == TK_IDENTIFIER || p.peek_kind() == TK_K_ABORT || p.peek_kind() == TK_K_ACTION || p.peek_kind() == TK_K_ADD || p.peek_kind() == TK_K_AFTER || p.peek_kind() == TK_K_ALL || p.peek_kind() == TK_K_ALTER || p.peek_kind() == TK_K_ANALYZE || p.peek_kind() == TK_K_AND || p.peek_kind() == TK_K_AS || p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_ATTACH || p.peek_kind() == TK_K_AUTOINCREMENT || p.peek_kind() == TK_K_BEFORE || p.peek_kind() == TK_K_BEGIN || p.peek_kind() == TK_K_BETWEEN || p.peek_kind() == TK_K_BY || p.peek_kind() == TK_K_CASCADE || p.peek_kind() == TK_K_CASE || p.peek_kind() == TK_K_CAST || p.peek_kind() == TK_K_CHECK || p.peek_kind() == TK_K_COLLATE || p.peek_kind() == TK_K_COLUMN || p.peek_kind() == TK_K_COMMIT || p.peek_kind() == TK_K_CONFLICT || p.peek_kind() == TK_K_CONSTRAINT || p.peek_kind() == TK_K_CREATE || p.peek_kind() == TK_K_CROSS || p.peek_kind() == TK_K_CURRENT_DATE || p.peek_kind() == TK_K_CURRENT_TIME || p.peek_kind() == TK_K_CURRENT_TIMESTAMP || p.peek_kind() == TK_K_DATABASE || p.peek_kind() == TK_K_DEFAULT || p.peek_kind() == TK_K_DEFERRABLE || p.peek_kind() == TK_K_DEFERRED || p.peek_kind() == TK_K_DELETE || p.peek_kind() == TK_K_DESC || p.peek_kind() == TK_K_DETACH || p.peek_kind() == TK_K_DISTINCT || p.peek_kind() == TK_K_DROP || p.peek_kind() == TK_K_EACH || p.peek_kind() == TK_K_ELSE || p.peek_kind() == TK_K_END || p.peek_kind() == TK_K_ESCAPE || p.peek_kind() == TK_K_EXCEPT || p.peek_kind() == TK_K_EXCLUSIVE || p.peek_kind() == TK_K_EXISTS || p.peek_kind() == TK_K_EXPLAIN || p.peek_kind() == TK_K_FAIL || p.peek_kind() == TK_K_FOR || p.peek_kind() == TK_K_FOREIGN || p.peek_kind() == TK_K_FROM || p.peek_kind() == TK_K_FULL || p.peek_kind() == TK_K_GLOB || p.peek_kind() == TK_K_GROUP || p.peek_kind() == TK_K_HAVING || p.peek_kind() == TK_K_IF || p.peek_kind() == TK_K_IGNORE || p.peek_kind() == TK_K_IMMEDIATE || p.peek_kind() == TK_K_IN || p.peek_kind() == TK_K_INDEX || p.peek_kind() == TK_K_INDEXED || p.peek_kind() == TK_K_INITIALLY || p.peek_kind() == TK_K_INNER || p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_INSTEAD || p.peek_kind() == TK_K_INTERSECT || p.peek_kind() == TK_K_INTO || p.peek_kind() == TK_K_IS || p.peek_kind() == TK_K_ISNULL || p.peek_kind() == TK_K_JOIN || p.peek_kind() == TK_K_KEY || p.peek_kind() == TK_K_LEFT || p.peek_kind() == TK_K_LIKE || p.peek_kind() == TK_K_LIMIT || p.peek_kind() == TK_K_MATCH || p.peek_kind() == TK_K_NATURAL || p.peek_kind() == TK_K_NO || p.peek_kind() == TK_K_NOT || p.peek_kind() == TK_K_NOTNULL || p.peek_kind() == TK_K_NULL || p.peek_kind() == TK_K_OF || p.peek_kind() == TK_K_OFFSET || p.peek_kind() == TK_K_ON || p.peek_kind() == TK_K_OR || p.peek_kind() == TK_K_ORDER || p.peek_kind() == TK_K_OUTER || p.peek_kind() == TK_K_PLAN || p.peek_kind() == TK_K_PRAGMA || p.peek_kind() == TK_K_PRIMARY || p.peek_kind() == TK_K_QUERY || p.peek_kind() == TK_K_RAISE || p.peek_kind() == TK_K_RECURSIVE || p.peek_kind() == TK_K_REFERENCES || p.peek_kind() == TK_K_REGEXP || p.peek_kind() == TK_K_REINDEX || p.peek_kind() == TK_K_RELEASE || p.peek_kind() == TK_K_RENAME || p.peek_kind() == TK_K_REPLACE || p.peek_kind() == TK_K_RESTRICT || p.peek_kind() == TK_K_RIGHT || p.peek_kind() == TK_K_ROLLBACK || p.peek_kind() == TK_K_ROW || p.peek_kind() == TK_K_SAVEPOINT || p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_SET || p.peek_kind() == TK_K_TABLE || p.peek_kind() == TK_K_TEMP || p.peek_kind() == TK_K_TEMPORARY || p.peek_kind() == TK_K_THEN || p.peek_kind() == TK_K_TO || p.peek_kind() == TK_K_TRANSACTION || p.peek_kind() == TK_K_TRIGGER || p.peek_kind() == TK_K_UNION || p.peek_kind() == TK_K_UNIQUE || p.peek_kind() == TK_K_UPDATE || p.peek_kind() == TK_K_USING || p.peek_kind() == TK_K_VACUUM || p.peek_kind() == TK_K_VALUES || p.peek_kind() == TK_K_VIEW || p.peek_kind() == TK_K_VIRTUAL || p.peek_kind() == TK_K_WHEN || p.peek_kind() == TK_K_WHERE || p.peek_kind() == TK_K_WITH || p.peek_kind() == TK_K_WITHOUT || p.peek_kind() == TK_STRING_LITERAL || p.peek_kind() == TK_LIT_LPAREN { @@ -7482,13 +7508,13 @@ fn parse_insert_stmt(p: &mut Parser) -> Result { } let table_name = parse_table_name(p)?; if p.peek_kind() == TK_LIT_LPAREN { - let tok_13 = p.expect(TK_LIT_LPAREN, "'('")?; - let tok_14 = parse_column_name(p)?; + let lparen = p.expect(TK_LIT_LPAREN, "'('")?; + let column_name = parse_column_name(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_column_name(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let column_name = parse_column_name(p)?; } - let tok_15 = p.expect(TK_LIT_RPAREN, "')'")?; + let rparen = p.expect(TK_LIT_RPAREN, "')'")?; } let grp_kind_2 = p.peek_kind(); if grp_kind_2 == TK_K_VALUES || grp_kind_2 == TK_K_WITH || grp_kind_2 == TK_K_SELECT { @@ -7504,33 +7530,33 @@ fn parse_insert_stmt(p: &mut Parser) -> Result { let opt_r_3 = parse_expr(p); if let Err(_) = opt_r_3 { p.pos = saved_pos; break bt_try; } while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let expr = parse_expr(p)?; } let opt_r_4 = p.expect(TK_LIT_RPAREN, "')'"); if let Err(_) = opt_r_4 { p.pos = saved_pos; break bt_try; } while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = p.expect(TK_LIT_LPAREN, "'('")?; - let tok_3 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let lparen = p.expect(TK_LIT_LPAREN, "'('")?; + let expr = parse_expr(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let expr = parse_expr(p)?; } - let tok_4 = p.expect(TK_LIT_RPAREN, "')'")?; + let rparen = p.expect(TK_LIT_RPAREN, "')'")?; } bt_done = true; } } if !bt_done { - let tok = parse_select_stmt(p)?; + let select_stmt = parse_select_stmt(p)?; } } else if p.peek_kind() == TK_K_WITH || p.peek_kind() == TK_K_SELECT { - let tok_16 = parse_select_stmt(p)?; + let select_stmt = parse_select_stmt(p)?; } } else if grp_kind_2 == TK_K_DEFAULT { - let tok_17 = p.expect(TK_K_DEFAULT, "K_DEFAULT")?; - let tok_18 = p.expect(TK_K_VALUES, "K_VALUES")?; + let k_default = p.expect(TK_K_DEFAULT, "K_DEFAULT")?; + let k_values = p.expect(TK_K_VALUES, "K_VALUES")?; } return Result::::Ok(InsertStmtNode { span: Span::new(start, p.last_end()), @@ -7558,12 +7584,12 @@ fn parse_pragma_stmt(p: &mut Parser) -> Result { opt_bt_2: { let grp_kind = p.peek_kind(); if grp_kind == TK_LIT_EQ { - let tok = p.expect(TK_LIT_EQ, "'='")?; - let tok_2 = parse_pragma_value(p)?; + let eq = p.expect(TK_LIT_EQ, "'='")?; + let pragma_value = parse_pragma_value(p)?; } else if grp_kind == TK_LIT_LPAREN { - let tok_3 = p.expect(TK_LIT_LPAREN, "'('")?; - let tok_4 = parse_pragma_value(p)?; - let tok_5 = p.expect(TK_LIT_RPAREN, "')'")?; + let lparen = p.expect(TK_LIT_LPAREN, "'('")?; + let pragma_value = parse_pragma_value(p)?; + let rparen = p.expect(TK_LIT_RPAREN, "')'")?; } } } @@ -7602,23 +7628,25 @@ fn parse_reindex_stmt(p: &mut Parser) -> Result { if let Err(_) = opt_r_2 { p.pos = opt_saved; break opt_bt; } } } + let mut table_name_or_index_name_inner: Option = null; let grp_kind = p.peek_kind(); if grp_kind == TK_IDENTIFIER || grp_kind == TK_K_ABORT || grp_kind == TK_K_ACTION || grp_kind == TK_K_ADD || grp_kind == TK_K_AFTER || grp_kind == TK_K_ALL || grp_kind == TK_K_ALTER || grp_kind == TK_K_ANALYZE || grp_kind == TK_K_AND || grp_kind == TK_K_AS || grp_kind == TK_K_ASC || grp_kind == TK_K_ATTACH || grp_kind == TK_K_AUTOINCREMENT || grp_kind == TK_K_BEFORE || grp_kind == TK_K_BEGIN || grp_kind == TK_K_BETWEEN || grp_kind == TK_K_BY || grp_kind == TK_K_CASCADE || grp_kind == TK_K_CASE || grp_kind == TK_K_CAST || grp_kind == TK_K_CHECK || grp_kind == TK_K_COLLATE || grp_kind == TK_K_COLUMN || grp_kind == TK_K_COMMIT || grp_kind == TK_K_CONFLICT || grp_kind == TK_K_CONSTRAINT || grp_kind == TK_K_CREATE || grp_kind == TK_K_CROSS || grp_kind == TK_K_CURRENT_DATE || grp_kind == TK_K_CURRENT_TIME || grp_kind == TK_K_CURRENT_TIMESTAMP || grp_kind == TK_K_DATABASE || grp_kind == TK_K_DEFAULT || grp_kind == TK_K_DEFERRABLE || grp_kind == TK_K_DEFERRED || grp_kind == TK_K_DELETE || grp_kind == TK_K_DESC || grp_kind == TK_K_DETACH || grp_kind == TK_K_DISTINCT || grp_kind == TK_K_DROP || grp_kind == TK_K_EACH || grp_kind == TK_K_ELSE || grp_kind == TK_K_END || grp_kind == TK_K_ESCAPE || grp_kind == TK_K_EXCEPT || grp_kind == TK_K_EXCLUSIVE || grp_kind == TK_K_EXISTS || grp_kind == TK_K_EXPLAIN || grp_kind == TK_K_FAIL || grp_kind == TK_K_FOR || grp_kind == TK_K_FOREIGN || grp_kind == TK_K_FROM || grp_kind == TK_K_FULL || grp_kind == TK_K_GLOB || grp_kind == TK_K_GROUP || grp_kind == TK_K_HAVING || grp_kind == TK_K_IF || grp_kind == TK_K_IGNORE || grp_kind == TK_K_IMMEDIATE || grp_kind == TK_K_IN || grp_kind == TK_K_INDEX || grp_kind == TK_K_INDEXED || grp_kind == TK_K_INITIALLY || grp_kind == TK_K_INNER || grp_kind == TK_K_INSERT || grp_kind == TK_K_INSTEAD || grp_kind == TK_K_INTERSECT || grp_kind == TK_K_INTO || grp_kind == TK_K_IS || grp_kind == TK_K_ISNULL || grp_kind == TK_K_JOIN || grp_kind == TK_K_KEY || grp_kind == TK_K_LEFT || grp_kind == TK_K_LIKE || grp_kind == TK_K_LIMIT || grp_kind == TK_K_MATCH || grp_kind == TK_K_NATURAL || grp_kind == TK_K_NO || grp_kind == TK_K_NOT || grp_kind == TK_K_NOTNULL || grp_kind == TK_K_NULL || grp_kind == TK_K_OF || grp_kind == TK_K_OFFSET || grp_kind == TK_K_ON || grp_kind == TK_K_OR || grp_kind == TK_K_ORDER || grp_kind == TK_K_OUTER || grp_kind == TK_K_PLAN || grp_kind == TK_K_PRAGMA || grp_kind == TK_K_PRIMARY || grp_kind == TK_K_QUERY || grp_kind == TK_K_RAISE || grp_kind == TK_K_RECURSIVE || grp_kind == TK_K_REFERENCES || grp_kind == TK_K_REGEXP || grp_kind == TK_K_REINDEX || grp_kind == TK_K_RELEASE || grp_kind == TK_K_RENAME || grp_kind == TK_K_REPLACE || grp_kind == TK_K_RESTRICT || grp_kind == TK_K_RIGHT || grp_kind == TK_K_ROLLBACK || grp_kind == TK_K_ROW || grp_kind == TK_K_SAVEPOINT || grp_kind == TK_K_SELECT || grp_kind == TK_K_SET || grp_kind == TK_K_TABLE || grp_kind == TK_K_TEMP || grp_kind == TK_K_TEMPORARY || grp_kind == TK_K_THEN || grp_kind == TK_K_TO || grp_kind == TK_K_TRANSACTION || grp_kind == TK_K_TRIGGER || grp_kind == TK_K_UNION || grp_kind == TK_K_UNIQUE || grp_kind == TK_K_UPDATE || grp_kind == TK_K_USING || grp_kind == TK_K_VACUUM || grp_kind == TK_K_VALUES || grp_kind == TK_K_VIEW || grp_kind == TK_K_VIRTUAL || grp_kind == TK_K_WHEN || grp_kind == TK_K_WHERE || grp_kind == TK_K_WITH || grp_kind == TK_K_WITHOUT || grp_kind == TK_STRING_LITERAL || grp_kind == TK_LIT_LPAREN { - if p.peek_kind() == TK_IDENTIFIER || p.peek_kind() == TK_K_ABORT || p.peek_kind() == TK_K_ACTION || p.peek_kind() == TK_K_ADD || p.peek_kind() == TK_K_AFTER || p.peek_kind() == TK_K_ALL || p.peek_kind() == TK_K_ALTER || p.peek_kind() == TK_K_ANALYZE || p.peek_kind() == TK_K_AND || p.peek_kind() == TK_K_AS || p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_ATTACH || p.peek_kind() == TK_K_AUTOINCREMENT || p.peek_kind() == TK_K_BEFORE || p.peek_kind() == TK_K_BEGIN || p.peek_kind() == TK_K_BETWEEN || p.peek_kind() == TK_K_BY || p.peek_kind() == TK_K_CASCADE || p.peek_kind() == TK_K_CASE || p.peek_kind() == TK_K_CAST || p.peek_kind() == TK_K_CHECK || p.peek_kind() == TK_K_COLLATE || p.peek_kind() == TK_K_COLUMN || p.peek_kind() == TK_K_COMMIT || p.peek_kind() == TK_K_CONFLICT || p.peek_kind() == TK_K_CONSTRAINT || p.peek_kind() == TK_K_CREATE || p.peek_kind() == TK_K_CROSS || p.peek_kind() == TK_K_CURRENT_DATE || p.peek_kind() == TK_K_CURRENT_TIME || p.peek_kind() == TK_K_CURRENT_TIMESTAMP || p.peek_kind() == TK_K_DATABASE || p.peek_kind() == TK_K_DEFAULT || p.peek_kind() == TK_K_DEFERRABLE || p.peek_kind() == TK_K_DEFERRED || p.peek_kind() == TK_K_DELETE || p.peek_kind() == TK_K_DESC || p.peek_kind() == TK_K_DETACH || p.peek_kind() == TK_K_DISTINCT || p.peek_kind() == TK_K_DROP || p.peek_kind() == TK_K_EACH || p.peek_kind() == TK_K_ELSE || p.peek_kind() == TK_K_END || p.peek_kind() == TK_K_ESCAPE || p.peek_kind() == TK_K_EXCEPT || p.peek_kind() == TK_K_EXCLUSIVE || p.peek_kind() == TK_K_EXISTS || p.peek_kind() == TK_K_EXPLAIN || p.peek_kind() == TK_K_FAIL || p.peek_kind() == TK_K_FOR || p.peek_kind() == TK_K_FOREIGN || p.peek_kind() == TK_K_FROM || p.peek_kind() == TK_K_FULL || p.peek_kind() == TK_K_GLOB || p.peek_kind() == TK_K_GROUP || p.peek_kind() == TK_K_HAVING || p.peek_kind() == TK_K_IF || p.peek_kind() == TK_K_IGNORE || p.peek_kind() == TK_K_IMMEDIATE || p.peek_kind() == TK_K_IN || p.peek_kind() == TK_K_INDEX || p.peek_kind() == TK_K_INDEXED || p.peek_kind() == TK_K_INITIALLY || p.peek_kind() == TK_K_INNER || p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_INSTEAD || p.peek_kind() == TK_K_INTERSECT || p.peek_kind() == TK_K_INTO || p.peek_kind() == TK_K_IS || p.peek_kind() == TK_K_ISNULL || p.peek_kind() == TK_K_JOIN || p.peek_kind() == TK_K_KEY || p.peek_kind() == TK_K_LEFT || p.peek_kind() == TK_K_LIKE || p.peek_kind() == TK_K_LIMIT || p.peek_kind() == TK_K_MATCH || p.peek_kind() == TK_K_NATURAL || p.peek_kind() == TK_K_NO || p.peek_kind() == TK_K_NOT || p.peek_kind() == TK_K_NOTNULL || p.peek_kind() == TK_K_NULL || p.peek_kind() == TK_K_OF || p.peek_kind() == TK_K_OFFSET || p.peek_kind() == TK_K_ON || p.peek_kind() == TK_K_OR || p.peek_kind() == TK_K_ORDER || p.peek_kind() == TK_K_OUTER || p.peek_kind() == TK_K_PLAN || p.peek_kind() == TK_K_PRAGMA || p.peek_kind() == TK_K_PRIMARY || p.peek_kind() == TK_K_QUERY || p.peek_kind() == TK_K_RAISE || p.peek_kind() == TK_K_RECURSIVE || p.peek_kind() == TK_K_REFERENCES || p.peek_kind() == TK_K_REGEXP || p.peek_kind() == TK_K_REINDEX || p.peek_kind() == TK_K_RELEASE || p.peek_kind() == TK_K_RENAME || p.peek_kind() == TK_K_REPLACE || p.peek_kind() == TK_K_RESTRICT || p.peek_kind() == TK_K_RIGHT || p.peek_kind() == TK_K_ROLLBACK || p.peek_kind() == TK_K_ROW || p.peek_kind() == TK_K_SAVEPOINT || p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_SET || p.peek_kind() == TK_K_TABLE || p.peek_kind() == TK_K_TEMP || p.peek_kind() == TK_K_TEMPORARY || p.peek_kind() == TK_K_THEN || p.peek_kind() == TK_K_TO || p.peek_kind() == TK_K_TRANSACTION || p.peek_kind() == TK_K_TRIGGER || p.peek_kind() == TK_K_UNION || p.peek_kind() == TK_K_UNIQUE || p.peek_kind() == TK_K_UPDATE || p.peek_kind() == TK_K_USING || p.peek_kind() == TK_K_VACUUM || p.peek_kind() == TK_K_VALUES || p.peek_kind() == TK_K_VIEW || p.peek_kind() == TK_K_VIRTUAL || p.peek_kind() == TK_K_WHEN || p.peek_kind() == TK_K_WHERE || p.peek_kind() == TK_K_WITH || p.peek_kind() == TK_K_WITHOUT || p.peek_kind() == TK_STRING_LITERAL || p.peek_kind() == TK_LIT_LPAREN { - let saved_pos = p.pos; - let mut bt_done = false; - if !bt_done { - bt_try: { - let opt_r = parse_table_name(p); - if let Err(_) = opt_r { p.pos = saved_pos; break bt_try; } - bt_done = true; - } - } - if !bt_done { - let tok = parse_index_name(p)?; + let saved_pos = p.pos; + let mut bt_done = false; + if !bt_done { + bt_try: { + let opt_r = parse_table_name(p); + if let Err(_) = opt_r { p.pos = saved_pos; break bt_try; } + table_name_or_index_name_inner = Option::::Some(TableNameOrIndexNameGroup::TableName(opt_r.unwrap())); + bt_done = true; } } + if !bt_done { + let index_name = parse_index_name(p)?; + table_name_or_index_name_inner = Option::::Some(TableNameOrIndexNameGroup::IndexName(index_name)); + } } + let table_name_or_index_name = table_name_or_index_name_inner; } } } @@ -7652,18 +7680,18 @@ fn parse_rollback_stmt(p: &mut Parser) -> Result { let start = p.peek().span.start; let k_rollback = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; if p.peek_kind() == TK_K_TRANSACTION && (p.peek_at(1) == TK_IDENTIFIER || p.peek_at(1) == TK_K_ABORT || p.peek_at(1) == TK_K_ACTION || p.peek_at(1) == TK_K_ADD || p.peek_at(1) == TK_K_AFTER || p.peek_at(1) == TK_K_ALL || p.peek_at(1) == TK_K_ALTER || p.peek_at(1) == TK_K_ANALYZE || p.peek_at(1) == TK_K_AND || p.peek_at(1) == TK_K_AS || p.peek_at(1) == TK_K_ASC || p.peek_at(1) == TK_K_ATTACH || p.peek_at(1) == TK_K_AUTOINCREMENT || p.peek_at(1) == TK_K_BEFORE || p.peek_at(1) == TK_K_BEGIN || p.peek_at(1) == TK_K_BETWEEN || p.peek_at(1) == TK_K_BY || p.peek_at(1) == TK_K_CASCADE || p.peek_at(1) == TK_K_CASE || p.peek_at(1) == TK_K_CAST || p.peek_at(1) == TK_K_CHECK || p.peek_at(1) == TK_K_COLLATE || p.peek_at(1) == TK_K_COLUMN || p.peek_at(1) == TK_K_COMMIT || p.peek_at(1) == TK_K_CONFLICT || p.peek_at(1) == TK_K_CONSTRAINT || p.peek_at(1) == TK_K_CREATE || p.peek_at(1) == TK_K_CROSS || p.peek_at(1) == TK_K_CURRENT_DATE || p.peek_at(1) == TK_K_CURRENT_TIME || p.peek_at(1) == TK_K_CURRENT_TIMESTAMP || p.peek_at(1) == TK_K_DATABASE || p.peek_at(1) == TK_K_DEFAULT || p.peek_at(1) == TK_K_DEFERRABLE || p.peek_at(1) == TK_K_DEFERRED || p.peek_at(1) == TK_K_DELETE || p.peek_at(1) == TK_K_DESC || p.peek_at(1) == TK_K_DETACH || p.peek_at(1) == TK_K_DISTINCT || p.peek_at(1) == TK_K_DROP || p.peek_at(1) == TK_K_EACH || p.peek_at(1) == TK_K_ELSE || p.peek_at(1) == TK_K_END || p.peek_at(1) == TK_K_ESCAPE || p.peek_at(1) == TK_K_EXCEPT || p.peek_at(1) == TK_K_EXCLUSIVE || p.peek_at(1) == TK_K_EXISTS || p.peek_at(1) == TK_K_EXPLAIN || p.peek_at(1) == TK_K_FAIL || p.peek_at(1) == TK_K_FOR || p.peek_at(1) == TK_K_FOREIGN || p.peek_at(1) == TK_K_FROM || p.peek_at(1) == TK_K_FULL || p.peek_at(1) == TK_K_GLOB || p.peek_at(1) == TK_K_GROUP || p.peek_at(1) == TK_K_HAVING || p.peek_at(1) == TK_K_IF || p.peek_at(1) == TK_K_IGNORE || p.peek_at(1) == TK_K_IMMEDIATE || p.peek_at(1) == TK_K_IN || p.peek_at(1) == TK_K_INDEX || p.peek_at(1) == TK_K_INDEXED || p.peek_at(1) == TK_K_INITIALLY || p.peek_at(1) == TK_K_INNER || p.peek_at(1) == TK_K_INSERT || p.peek_at(1) == TK_K_INSTEAD || p.peek_at(1) == TK_K_INTERSECT || p.peek_at(1) == TK_K_INTO || p.peek_at(1) == TK_K_IS || p.peek_at(1) == TK_K_ISNULL || p.peek_at(1) == TK_K_JOIN || p.peek_at(1) == TK_K_KEY || p.peek_at(1) == TK_K_LEFT || p.peek_at(1) == TK_K_LIKE || p.peek_at(1) == TK_K_LIMIT || p.peek_at(1) == TK_K_MATCH || p.peek_at(1) == TK_K_NATURAL || p.peek_at(1) == TK_K_NO || p.peek_at(1) == TK_K_NOT || p.peek_at(1) == TK_K_NOTNULL || p.peek_at(1) == TK_K_NULL || p.peek_at(1) == TK_K_OF || p.peek_at(1) == TK_K_OFFSET || p.peek_at(1) == TK_K_ON || p.peek_at(1) == TK_K_OR || p.peek_at(1) == TK_K_ORDER || p.peek_at(1) == TK_K_OUTER || p.peek_at(1) == TK_K_PLAN || p.peek_at(1) == TK_K_PRAGMA || p.peek_at(1) == TK_K_PRIMARY || p.peek_at(1) == TK_K_QUERY || p.peek_at(1) == TK_K_RAISE || p.peek_at(1) == TK_K_RECURSIVE || p.peek_at(1) == TK_K_REFERENCES || p.peek_at(1) == TK_K_REGEXP || p.peek_at(1) == TK_K_REINDEX || p.peek_at(1) == TK_K_RELEASE || p.peek_at(1) == TK_K_RENAME || p.peek_at(1) == TK_K_REPLACE || p.peek_at(1) == TK_K_RESTRICT || p.peek_at(1) == TK_K_RIGHT || p.peek_at(1) == TK_K_ROLLBACK || p.peek_at(1) == TK_K_ROW || p.peek_at(1) == TK_K_SAVEPOINT || p.peek_at(1) == TK_K_SELECT || p.peek_at(1) == TK_K_SET || p.peek_at(1) == TK_K_TABLE || p.peek_at(1) == TK_K_TEMP || p.peek_at(1) == TK_K_TEMPORARY || p.peek_at(1) == TK_K_THEN || p.peek_at(1) == TK_K_TO || p.peek_at(1) == TK_K_TRANSACTION || p.peek_at(1) == TK_K_TRIGGER || p.peek_at(1) == TK_K_UNION || p.peek_at(1) == TK_K_UNIQUE || p.peek_at(1) == TK_K_UPDATE || p.peek_at(1) == TK_K_USING || p.peek_at(1) == TK_K_VACUUM || p.peek_at(1) == TK_K_VALUES || p.peek_at(1) == TK_K_VIEW || p.peek_at(1) == TK_K_VIRTUAL || p.peek_at(1) == TK_K_WHEN || p.peek_at(1) == TK_K_WHERE || p.peek_at(1) == TK_K_WITH || p.peek_at(1) == TK_K_WITHOUT || p.peek_at(1) == TK_STRING_LITERAL || p.peek_at(1) == TK_LIT_LPAREN) { - let tok = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; - let tok_2 = parse_transaction_name(p)?; + let k_transaction = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; + let transaction_name = parse_transaction_name(p)?; } else if p.peek_kind() == TK_K_TRANSACTION { - let tok_3 = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; + let k_transaction = p.expect(TK_K_TRANSACTION, "K_TRANSACTION")?; } if p.peek_kind() == TK_K_TO && p.peek_at(1) == TK_K_SAVEPOINT && (p.peek_at(2) == TK_IDENTIFIER || p.peek_at(2) == TK_K_ABORT || p.peek_at(2) == TK_K_ACTION || p.peek_at(2) == TK_K_ADD || p.peek_at(2) == TK_K_AFTER || p.peek_at(2) == TK_K_ALL || p.peek_at(2) == TK_K_ALTER || p.peek_at(2) == TK_K_ANALYZE || p.peek_at(2) == TK_K_AND || p.peek_at(2) == TK_K_AS || p.peek_at(2) == TK_K_ASC || p.peek_at(2) == TK_K_ATTACH || p.peek_at(2) == TK_K_AUTOINCREMENT || p.peek_at(2) == TK_K_BEFORE || p.peek_at(2) == TK_K_BEGIN || p.peek_at(2) == TK_K_BETWEEN || p.peek_at(2) == TK_K_BY || p.peek_at(2) == TK_K_CASCADE || p.peek_at(2) == TK_K_CASE || p.peek_at(2) == TK_K_CAST || p.peek_at(2) == TK_K_CHECK || p.peek_at(2) == TK_K_COLLATE || p.peek_at(2) == TK_K_COLUMN || p.peek_at(2) == TK_K_COMMIT || p.peek_at(2) == TK_K_CONFLICT || p.peek_at(2) == TK_K_CONSTRAINT || p.peek_at(2) == TK_K_CREATE || p.peek_at(2) == TK_K_CROSS || p.peek_at(2) == TK_K_CURRENT_DATE || p.peek_at(2) == TK_K_CURRENT_TIME || p.peek_at(2) == TK_K_CURRENT_TIMESTAMP || p.peek_at(2) == TK_K_DATABASE || p.peek_at(2) == TK_K_DEFAULT || p.peek_at(2) == TK_K_DEFERRABLE || p.peek_at(2) == TK_K_DEFERRED || p.peek_at(2) == TK_K_DELETE || p.peek_at(2) == TK_K_DESC || p.peek_at(2) == TK_K_DETACH || p.peek_at(2) == TK_K_DISTINCT || p.peek_at(2) == TK_K_DROP || p.peek_at(2) == TK_K_EACH || p.peek_at(2) == TK_K_ELSE || p.peek_at(2) == TK_K_END || p.peek_at(2) == TK_K_ESCAPE || p.peek_at(2) == TK_K_EXCEPT || p.peek_at(2) == TK_K_EXCLUSIVE || p.peek_at(2) == TK_K_EXISTS || p.peek_at(2) == TK_K_EXPLAIN || p.peek_at(2) == TK_K_FAIL || p.peek_at(2) == TK_K_FOR || p.peek_at(2) == TK_K_FOREIGN || p.peek_at(2) == TK_K_FROM || p.peek_at(2) == TK_K_FULL || p.peek_at(2) == TK_K_GLOB || p.peek_at(2) == TK_K_GROUP || p.peek_at(2) == TK_K_HAVING || p.peek_at(2) == TK_K_IF || p.peek_at(2) == TK_K_IGNORE || p.peek_at(2) == TK_K_IMMEDIATE || p.peek_at(2) == TK_K_IN || p.peek_at(2) == TK_K_INDEX || p.peek_at(2) == TK_K_INDEXED || p.peek_at(2) == TK_K_INITIALLY || p.peek_at(2) == TK_K_INNER || p.peek_at(2) == TK_K_INSERT || p.peek_at(2) == TK_K_INSTEAD || p.peek_at(2) == TK_K_INTERSECT || p.peek_at(2) == TK_K_INTO || p.peek_at(2) == TK_K_IS || p.peek_at(2) == TK_K_ISNULL || p.peek_at(2) == TK_K_JOIN || p.peek_at(2) == TK_K_KEY || p.peek_at(2) == TK_K_LEFT || p.peek_at(2) == TK_K_LIKE || p.peek_at(2) == TK_K_LIMIT || p.peek_at(2) == TK_K_MATCH || p.peek_at(2) == TK_K_NATURAL || p.peek_at(2) == TK_K_NO || p.peek_at(2) == TK_K_NOT || p.peek_at(2) == TK_K_NOTNULL || p.peek_at(2) == TK_K_NULL || p.peek_at(2) == TK_K_OF || p.peek_at(2) == TK_K_OFFSET || p.peek_at(2) == TK_K_ON || p.peek_at(2) == TK_K_OR || p.peek_at(2) == TK_K_ORDER || p.peek_at(2) == TK_K_OUTER || p.peek_at(2) == TK_K_PLAN || p.peek_at(2) == TK_K_PRAGMA || p.peek_at(2) == TK_K_PRIMARY || p.peek_at(2) == TK_K_QUERY || p.peek_at(2) == TK_K_RAISE || p.peek_at(2) == TK_K_RECURSIVE || p.peek_at(2) == TK_K_REFERENCES || p.peek_at(2) == TK_K_REGEXP || p.peek_at(2) == TK_K_REINDEX || p.peek_at(2) == TK_K_RELEASE || p.peek_at(2) == TK_K_RENAME || p.peek_at(2) == TK_K_REPLACE || p.peek_at(2) == TK_K_RESTRICT || p.peek_at(2) == TK_K_RIGHT || p.peek_at(2) == TK_K_ROLLBACK || p.peek_at(2) == TK_K_ROW || p.peek_at(2) == TK_K_SAVEPOINT || p.peek_at(2) == TK_K_SELECT || p.peek_at(2) == TK_K_SET || p.peek_at(2) == TK_K_TABLE || p.peek_at(2) == TK_K_TEMP || p.peek_at(2) == TK_K_TEMPORARY || p.peek_at(2) == TK_K_THEN || p.peek_at(2) == TK_K_TO || p.peek_at(2) == TK_K_TRANSACTION || p.peek_at(2) == TK_K_TRIGGER || p.peek_at(2) == TK_K_UNION || p.peek_at(2) == TK_K_UNIQUE || p.peek_at(2) == TK_K_UPDATE || p.peek_at(2) == TK_K_USING || p.peek_at(2) == TK_K_VACUUM || p.peek_at(2) == TK_K_VALUES || p.peek_at(2) == TK_K_VIEW || p.peek_at(2) == TK_K_VIRTUAL || p.peek_at(2) == TK_K_WHEN || p.peek_at(2) == TK_K_WHERE || p.peek_at(2) == TK_K_WITH || p.peek_at(2) == TK_K_WITHOUT || p.peek_at(2) == TK_STRING_LITERAL || p.peek_at(2) == TK_LIT_LPAREN) { - let tok_4 = p.expect(TK_K_TO, "K_TO")?; - let tok_5 = p.expect(TK_K_SAVEPOINT, "K_SAVEPOINT")?; - let tok_6 = parse_savepoint_name(p)?; + let k_to = p.expect(TK_K_TO, "K_TO")?; + let k_savepoint = p.expect(TK_K_SAVEPOINT, "K_SAVEPOINT")?; + let savepoint_name = parse_savepoint_name(p)?; } else if p.peek_kind() == TK_K_TO && (p.peek_at(1) == TK_IDENTIFIER || p.peek_at(1) == TK_K_ABORT || p.peek_at(1) == TK_K_ACTION || p.peek_at(1) == TK_K_ADD || p.peek_at(1) == TK_K_AFTER || p.peek_at(1) == TK_K_ALL || p.peek_at(1) == TK_K_ALTER || p.peek_at(1) == TK_K_ANALYZE || p.peek_at(1) == TK_K_AND || p.peek_at(1) == TK_K_AS || p.peek_at(1) == TK_K_ASC || p.peek_at(1) == TK_K_ATTACH || p.peek_at(1) == TK_K_AUTOINCREMENT || p.peek_at(1) == TK_K_BEFORE || p.peek_at(1) == TK_K_BEGIN || p.peek_at(1) == TK_K_BETWEEN || p.peek_at(1) == TK_K_BY || p.peek_at(1) == TK_K_CASCADE || p.peek_at(1) == TK_K_CASE || p.peek_at(1) == TK_K_CAST || p.peek_at(1) == TK_K_CHECK || p.peek_at(1) == TK_K_COLLATE || p.peek_at(1) == TK_K_COLUMN || p.peek_at(1) == TK_K_COMMIT || p.peek_at(1) == TK_K_CONFLICT || p.peek_at(1) == TK_K_CONSTRAINT || p.peek_at(1) == TK_K_CREATE || p.peek_at(1) == TK_K_CROSS || p.peek_at(1) == TK_K_CURRENT_DATE || p.peek_at(1) == TK_K_CURRENT_TIME || p.peek_at(1) == TK_K_CURRENT_TIMESTAMP || p.peek_at(1) == TK_K_DATABASE || p.peek_at(1) == TK_K_DEFAULT || p.peek_at(1) == TK_K_DEFERRABLE || p.peek_at(1) == TK_K_DEFERRED || p.peek_at(1) == TK_K_DELETE || p.peek_at(1) == TK_K_DESC || p.peek_at(1) == TK_K_DETACH || p.peek_at(1) == TK_K_DISTINCT || p.peek_at(1) == TK_K_DROP || p.peek_at(1) == TK_K_EACH || p.peek_at(1) == TK_K_ELSE || p.peek_at(1) == TK_K_END || p.peek_at(1) == TK_K_ESCAPE || p.peek_at(1) == TK_K_EXCEPT || p.peek_at(1) == TK_K_EXCLUSIVE || p.peek_at(1) == TK_K_EXISTS || p.peek_at(1) == TK_K_EXPLAIN || p.peek_at(1) == TK_K_FAIL || p.peek_at(1) == TK_K_FOR || p.peek_at(1) == TK_K_FOREIGN || p.peek_at(1) == TK_K_FROM || p.peek_at(1) == TK_K_FULL || p.peek_at(1) == TK_K_GLOB || p.peek_at(1) == TK_K_GROUP || p.peek_at(1) == TK_K_HAVING || p.peek_at(1) == TK_K_IF || p.peek_at(1) == TK_K_IGNORE || p.peek_at(1) == TK_K_IMMEDIATE || p.peek_at(1) == TK_K_IN || p.peek_at(1) == TK_K_INDEX || p.peek_at(1) == TK_K_INDEXED || p.peek_at(1) == TK_K_INITIALLY || p.peek_at(1) == TK_K_INNER || p.peek_at(1) == TK_K_INSERT || p.peek_at(1) == TK_K_INSTEAD || p.peek_at(1) == TK_K_INTERSECT || p.peek_at(1) == TK_K_INTO || p.peek_at(1) == TK_K_IS || p.peek_at(1) == TK_K_ISNULL || p.peek_at(1) == TK_K_JOIN || p.peek_at(1) == TK_K_KEY || p.peek_at(1) == TK_K_LEFT || p.peek_at(1) == TK_K_LIKE || p.peek_at(1) == TK_K_LIMIT || p.peek_at(1) == TK_K_MATCH || p.peek_at(1) == TK_K_NATURAL || p.peek_at(1) == TK_K_NO || p.peek_at(1) == TK_K_NOT || p.peek_at(1) == TK_K_NOTNULL || p.peek_at(1) == TK_K_NULL || p.peek_at(1) == TK_K_OF || p.peek_at(1) == TK_K_OFFSET || p.peek_at(1) == TK_K_ON || p.peek_at(1) == TK_K_OR || p.peek_at(1) == TK_K_ORDER || p.peek_at(1) == TK_K_OUTER || p.peek_at(1) == TK_K_PLAN || p.peek_at(1) == TK_K_PRAGMA || p.peek_at(1) == TK_K_PRIMARY || p.peek_at(1) == TK_K_QUERY || p.peek_at(1) == TK_K_RAISE || p.peek_at(1) == TK_K_RECURSIVE || p.peek_at(1) == TK_K_REFERENCES || p.peek_at(1) == TK_K_REGEXP || p.peek_at(1) == TK_K_REINDEX || p.peek_at(1) == TK_K_RELEASE || p.peek_at(1) == TK_K_RENAME || p.peek_at(1) == TK_K_REPLACE || p.peek_at(1) == TK_K_RESTRICT || p.peek_at(1) == TK_K_RIGHT || p.peek_at(1) == TK_K_ROLLBACK || p.peek_at(1) == TK_K_ROW || p.peek_at(1) == TK_K_SAVEPOINT || p.peek_at(1) == TK_K_SELECT || p.peek_at(1) == TK_K_SET || p.peek_at(1) == TK_K_TABLE || p.peek_at(1) == TK_K_TEMP || p.peek_at(1) == TK_K_TEMPORARY || p.peek_at(1) == TK_K_THEN || p.peek_at(1) == TK_K_TO || p.peek_at(1) == TK_K_TRANSACTION || p.peek_at(1) == TK_K_TRIGGER || p.peek_at(1) == TK_K_UNION || p.peek_at(1) == TK_K_UNIQUE || p.peek_at(1) == TK_K_UPDATE || p.peek_at(1) == TK_K_USING || p.peek_at(1) == TK_K_VACUUM || p.peek_at(1) == TK_K_VALUES || p.peek_at(1) == TK_K_VIEW || p.peek_at(1) == TK_K_VIRTUAL || p.peek_at(1) == TK_K_WHEN || p.peek_at(1) == TK_K_WHERE || p.peek_at(1) == TK_K_WITH || p.peek_at(1) == TK_K_WITHOUT || p.peek_at(1) == TK_STRING_LITERAL || p.peek_at(1) == TK_LIT_LPAREN) { - let tok_7 = p.expect(TK_K_TO, "K_TO")?; - let tok_8 = parse_savepoint_name(p)?; + let k_to = p.expect(TK_K_TO, "K_TO")?; + let savepoint_name = parse_savepoint_name(p)?; } return Result::::Ok(RollbackStmtNode { span: Span::new(start, p.last_end()), @@ -7692,27 +7720,27 @@ fn parse_simple_select_stmt(p: &mut Parser) -> Result::Ok(SimpleSelectStmtNode { span: Span::new(start, p.last_end()), @@ -7731,31 +7759,31 @@ fn parse_select_stmt(p: &mut Parser) -> Result { }; let select_or_values = parse_select_or_values(p)?; while p.peek_kind() == TK_K_UNION || p.peek_kind() == TK_K_INTERSECT || p.peek_kind() == TK_K_EXCEPT { - let tok = parse_compound_operator(p)?; - let tok_2 = parse_select_or_values(p)?; + let compound_operator = parse_compound_operator(p)?; + let select_or_values = parse_select_or_values(p)?; } if p.peek_kind() == TK_K_ORDER && p.peek_at(1) == TK_K_BY { - let tok = p.expect(TK_K_ORDER, "K_ORDER")?; - let tok_2 = p.expect(TK_K_BY, "K_BY")?; - let tok_3 = parse_ordering_term(p)?; + let k_order = p.expect(TK_K_ORDER, "K_ORDER")?; + let k_by = p.expect(TK_K_BY, "K_BY")?; + let ordering_term = parse_ordering_term(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_ordering_term(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let ordering_term = parse_ordering_term(p)?; } } if p.peek_kind() == TK_K_LIMIT && (p.peek_at(1) == TK_NUMERIC_LITERAL || p.peek_at(1) == TK_STRING_LITERAL || p.peek_at(1) == TK_BLOB_LITERAL || p.peek_at(1) == TK_K_NULL || p.peek_at(1) == TK_K_CURRENT_TIME || p.peek_at(1) == TK_K_CURRENT_DATE || p.peek_at(1) == TK_K_CURRENT_TIMESTAMP || p.peek_at(1) == TK_BIND_PARAMETER || p.peek_at(1) == TK_IDENTIFIER || p.peek_at(1) == TK_K_ABORT || p.peek_at(1) == TK_K_ACTION || p.peek_at(1) == TK_K_ADD || p.peek_at(1) == TK_K_AFTER || p.peek_at(1) == TK_K_ALL || p.peek_at(1) == TK_K_ALTER || p.peek_at(1) == TK_K_ANALYZE || p.peek_at(1) == TK_K_AND || p.peek_at(1) == TK_K_AS || p.peek_at(1) == TK_K_ASC || p.peek_at(1) == TK_K_ATTACH || p.peek_at(1) == TK_K_AUTOINCREMENT || p.peek_at(1) == TK_K_BEFORE || p.peek_at(1) == TK_K_BEGIN || p.peek_at(1) == TK_K_BETWEEN || p.peek_at(1) == TK_K_BY || p.peek_at(1) == TK_K_CASCADE || p.peek_at(1) == TK_K_CASE || p.peek_at(1) == TK_K_CAST || p.peek_at(1) == TK_K_CHECK || p.peek_at(1) == TK_K_COLLATE || p.peek_at(1) == TK_K_COLUMN || p.peek_at(1) == TK_K_COMMIT || p.peek_at(1) == TK_K_CONFLICT || p.peek_at(1) == TK_K_CONSTRAINT || p.peek_at(1) == TK_K_CREATE || p.peek_at(1) == TK_K_CROSS || p.peek_at(1) == TK_K_DATABASE || p.peek_at(1) == TK_K_DEFAULT || p.peek_at(1) == TK_K_DEFERRABLE || p.peek_at(1) == TK_K_DEFERRED || p.peek_at(1) == TK_K_DELETE || p.peek_at(1) == TK_K_DESC || p.peek_at(1) == TK_K_DETACH || p.peek_at(1) == TK_K_DISTINCT || p.peek_at(1) == TK_K_DROP || p.peek_at(1) == TK_K_EACH || p.peek_at(1) == TK_K_ELSE || p.peek_at(1) == TK_K_END || p.peek_at(1) == TK_K_ESCAPE || p.peek_at(1) == TK_K_EXCEPT || p.peek_at(1) == TK_K_EXCLUSIVE || p.peek_at(1) == TK_K_EXISTS || p.peek_at(1) == TK_K_EXPLAIN || p.peek_at(1) == TK_K_FAIL || p.peek_at(1) == TK_K_FOR || p.peek_at(1) == TK_K_FOREIGN || p.peek_at(1) == TK_K_FROM || p.peek_at(1) == TK_K_FULL || p.peek_at(1) == TK_K_GLOB || p.peek_at(1) == TK_K_GROUP || p.peek_at(1) == TK_K_HAVING || p.peek_at(1) == TK_K_IF || p.peek_at(1) == TK_K_IGNORE || p.peek_at(1) == TK_K_IMMEDIATE || p.peek_at(1) == TK_K_IN || p.peek_at(1) == TK_K_INDEX || p.peek_at(1) == TK_K_INDEXED || p.peek_at(1) == TK_K_INITIALLY || p.peek_at(1) == TK_K_INNER || p.peek_at(1) == TK_K_INSERT || p.peek_at(1) == TK_K_INSTEAD || p.peek_at(1) == TK_K_INTERSECT || p.peek_at(1) == TK_K_INTO || p.peek_at(1) == TK_K_IS || p.peek_at(1) == TK_K_ISNULL || p.peek_at(1) == TK_K_JOIN || p.peek_at(1) == TK_K_KEY || p.peek_at(1) == TK_K_LEFT || p.peek_at(1) == TK_K_LIKE || p.peek_at(1) == TK_K_LIMIT || p.peek_at(1) == TK_K_MATCH || p.peek_at(1) == TK_K_NATURAL || p.peek_at(1) == TK_K_NO || p.peek_at(1) == TK_K_NOT || p.peek_at(1) == TK_K_NOTNULL || p.peek_at(1) == TK_K_OF || p.peek_at(1) == TK_K_OFFSET || p.peek_at(1) == TK_K_ON || p.peek_at(1) == TK_K_OR || p.peek_at(1) == TK_K_ORDER || p.peek_at(1) == TK_K_OUTER || p.peek_at(1) == TK_K_PLAN || p.peek_at(1) == TK_K_PRAGMA || p.peek_at(1) == TK_K_PRIMARY || p.peek_at(1) == TK_K_QUERY || p.peek_at(1) == TK_K_RAISE || p.peek_at(1) == TK_K_RECURSIVE || p.peek_at(1) == TK_K_REFERENCES || p.peek_at(1) == TK_K_REGEXP || p.peek_at(1) == TK_K_REINDEX || p.peek_at(1) == TK_K_RELEASE || p.peek_at(1) == TK_K_RENAME || p.peek_at(1) == TK_K_REPLACE || p.peek_at(1) == TK_K_RESTRICT || p.peek_at(1) == TK_K_RIGHT || p.peek_at(1) == TK_K_ROLLBACK || p.peek_at(1) == TK_K_ROW || p.peek_at(1) == TK_K_SAVEPOINT || p.peek_at(1) == TK_K_SELECT || p.peek_at(1) == TK_K_SET || p.peek_at(1) == TK_K_TABLE || p.peek_at(1) == TK_K_TEMP || p.peek_at(1) == TK_K_TEMPORARY || p.peek_at(1) == TK_K_THEN || p.peek_at(1) == TK_K_TO || p.peek_at(1) == TK_K_TRANSACTION || p.peek_at(1) == TK_K_TRIGGER || p.peek_at(1) == TK_K_UNION || p.peek_at(1) == TK_K_UNIQUE || p.peek_at(1) == TK_K_UPDATE || p.peek_at(1) == TK_K_USING || p.peek_at(1) == TK_K_VACUUM || p.peek_at(1) == TK_K_VALUES || p.peek_at(1) == TK_K_VIEW || p.peek_at(1) == TK_K_VIRTUAL || p.peek_at(1) == TK_K_WHEN || p.peek_at(1) == TK_K_WHERE || p.peek_at(1) == TK_K_WITH || p.peek_at(1) == TK_K_WITHOUT || p.peek_at(1) == TK_LIT_LPAREN || p.peek_at(1) == TK_LIT_MINUS || p.peek_at(1) == TK_LIT_PLUS || p.peek_at(1) == TK_LIT_TILDE) && (p.peek_at(2) == TK_K_OFFSET || p.peek_at(2) == TK_LIT_COMMA) && (p.peek_at(3) == TK_NUMERIC_LITERAL || p.peek_at(3) == TK_STRING_LITERAL || p.peek_at(3) == TK_BLOB_LITERAL || p.peek_at(3) == TK_K_NULL || p.peek_at(3) == TK_K_CURRENT_TIME || p.peek_at(3) == TK_K_CURRENT_DATE || p.peek_at(3) == TK_K_CURRENT_TIMESTAMP || p.peek_at(3) == TK_BIND_PARAMETER || p.peek_at(3) == TK_IDENTIFIER || p.peek_at(3) == TK_K_ABORT || p.peek_at(3) == TK_K_ACTION || p.peek_at(3) == TK_K_ADD || p.peek_at(3) == TK_K_AFTER || p.peek_at(3) == TK_K_ALL || p.peek_at(3) == TK_K_ALTER || p.peek_at(3) == TK_K_ANALYZE || p.peek_at(3) == TK_K_AND || p.peek_at(3) == TK_K_AS || p.peek_at(3) == TK_K_ASC || p.peek_at(3) == TK_K_ATTACH || p.peek_at(3) == TK_K_AUTOINCREMENT || p.peek_at(3) == TK_K_BEFORE || p.peek_at(3) == TK_K_BEGIN || p.peek_at(3) == TK_K_BETWEEN || p.peek_at(3) == TK_K_BY || p.peek_at(3) == TK_K_CASCADE || p.peek_at(3) == TK_K_CASE || p.peek_at(3) == TK_K_CAST || p.peek_at(3) == TK_K_CHECK || p.peek_at(3) == TK_K_COLLATE || p.peek_at(3) == TK_K_COLUMN || p.peek_at(3) == TK_K_COMMIT || p.peek_at(3) == TK_K_CONFLICT || p.peek_at(3) == TK_K_CONSTRAINT || p.peek_at(3) == TK_K_CREATE || p.peek_at(3) == TK_K_CROSS || p.peek_at(3) == TK_K_DATABASE || p.peek_at(3) == TK_K_DEFAULT || p.peek_at(3) == TK_K_DEFERRABLE || p.peek_at(3) == TK_K_DEFERRED || p.peek_at(3) == TK_K_DELETE || p.peek_at(3) == TK_K_DESC || p.peek_at(3) == TK_K_DETACH || p.peek_at(3) == TK_K_DISTINCT || p.peek_at(3) == TK_K_DROP || p.peek_at(3) == TK_K_EACH || p.peek_at(3) == TK_K_ELSE || p.peek_at(3) == TK_K_END || p.peek_at(3) == TK_K_ESCAPE || p.peek_at(3) == TK_K_EXCEPT || p.peek_at(3) == TK_K_EXCLUSIVE || p.peek_at(3) == TK_K_EXISTS || p.peek_at(3) == TK_K_EXPLAIN || p.peek_at(3) == TK_K_FAIL || p.peek_at(3) == TK_K_FOR || p.peek_at(3) == TK_K_FOREIGN || p.peek_at(3) == TK_K_FROM || p.peek_at(3) == TK_K_FULL || p.peek_at(3) == TK_K_GLOB || p.peek_at(3) == TK_K_GROUP || p.peek_at(3) == TK_K_HAVING || p.peek_at(3) == TK_K_IF || p.peek_at(3) == TK_K_IGNORE || p.peek_at(3) == TK_K_IMMEDIATE || p.peek_at(3) == TK_K_IN || p.peek_at(3) == TK_K_INDEX || p.peek_at(3) == TK_K_INDEXED || p.peek_at(3) == TK_K_INITIALLY || p.peek_at(3) == TK_K_INNER || p.peek_at(3) == TK_K_INSERT || p.peek_at(3) == TK_K_INSTEAD || p.peek_at(3) == TK_K_INTERSECT || p.peek_at(3) == TK_K_INTO || p.peek_at(3) == TK_K_IS || p.peek_at(3) == TK_K_ISNULL || p.peek_at(3) == TK_K_JOIN || p.peek_at(3) == TK_K_KEY || p.peek_at(3) == TK_K_LEFT || p.peek_at(3) == TK_K_LIKE || p.peek_at(3) == TK_K_LIMIT || p.peek_at(3) == TK_K_MATCH || p.peek_at(3) == TK_K_NATURAL || p.peek_at(3) == TK_K_NO || p.peek_at(3) == TK_K_NOT || p.peek_at(3) == TK_K_NOTNULL || p.peek_at(3) == TK_K_OF || p.peek_at(3) == TK_K_OFFSET || p.peek_at(3) == TK_K_ON || p.peek_at(3) == TK_K_OR || p.peek_at(3) == TK_K_ORDER || p.peek_at(3) == TK_K_OUTER || p.peek_at(3) == TK_K_PLAN || p.peek_at(3) == TK_K_PRAGMA || p.peek_at(3) == TK_K_PRIMARY || p.peek_at(3) == TK_K_QUERY || p.peek_at(3) == TK_K_RAISE || p.peek_at(3) == TK_K_RECURSIVE || p.peek_at(3) == TK_K_REFERENCES || p.peek_at(3) == TK_K_REGEXP || p.peek_at(3) == TK_K_REINDEX || p.peek_at(3) == TK_K_RELEASE || p.peek_at(3) == TK_K_RENAME || p.peek_at(3) == TK_K_REPLACE || p.peek_at(3) == TK_K_RESTRICT || p.peek_at(3) == TK_K_RIGHT || p.peek_at(3) == TK_K_ROLLBACK || p.peek_at(3) == TK_K_ROW || p.peek_at(3) == TK_K_SAVEPOINT || p.peek_at(3) == TK_K_SELECT || p.peek_at(3) == TK_K_SET || p.peek_at(3) == TK_K_TABLE || p.peek_at(3) == TK_K_TEMP || p.peek_at(3) == TK_K_TEMPORARY || p.peek_at(3) == TK_K_THEN || p.peek_at(3) == TK_K_TO || p.peek_at(3) == TK_K_TRANSACTION || p.peek_at(3) == TK_K_TRIGGER || p.peek_at(3) == TK_K_UNION || p.peek_at(3) == TK_K_UNIQUE || p.peek_at(3) == TK_K_UPDATE || p.peek_at(3) == TK_K_USING || p.peek_at(3) == TK_K_VACUUM || p.peek_at(3) == TK_K_VALUES || p.peek_at(3) == TK_K_VIEW || p.peek_at(3) == TK_K_VIRTUAL || p.peek_at(3) == TK_K_WHEN || p.peek_at(3) == TK_K_WHERE || p.peek_at(3) == TK_K_WITH || p.peek_at(3) == TK_K_WITHOUT || p.peek_at(3) == TK_LIT_LPAREN || p.peek_at(3) == TK_LIT_MINUS || p.peek_at(3) == TK_LIT_PLUS || p.peek_at(3) == TK_LIT_TILDE) { - let tok_4 = p.expect(TK_K_LIMIT, "K_LIMIT")?; - let tok_5 = parse_expr(p)?; + let k_limit = p.expect(TK_K_LIMIT, "K_LIMIT")?; + let expr = parse_expr(p)?; let grp_kind = p.peek_kind(); if grp_kind == TK_K_OFFSET { - let tok_6 = p.expect(TK_K_OFFSET, "K_OFFSET")?; + let k_offset = p.expect(TK_K_OFFSET, "K_OFFSET")?; } else if grp_kind == TK_LIT_COMMA { - let tok_7 = p.expect(TK_LIT_COMMA, "','")?; + let comma = p.expect(TK_LIT_COMMA, "','")?; } - let tok_8 = parse_expr(p)?; + let expr_2 = parse_expr(p)?; } else if p.peek_kind() == TK_K_LIMIT && (p.peek_at(1) == TK_NUMERIC_LITERAL || p.peek_at(1) == TK_STRING_LITERAL || p.peek_at(1) == TK_BLOB_LITERAL || p.peek_at(1) == TK_K_NULL || p.peek_at(1) == TK_K_CURRENT_TIME || p.peek_at(1) == TK_K_CURRENT_DATE || p.peek_at(1) == TK_K_CURRENT_TIMESTAMP || p.peek_at(1) == TK_BIND_PARAMETER || p.peek_at(1) == TK_IDENTIFIER || p.peek_at(1) == TK_K_ABORT || p.peek_at(1) == TK_K_ACTION || p.peek_at(1) == TK_K_ADD || p.peek_at(1) == TK_K_AFTER || p.peek_at(1) == TK_K_ALL || p.peek_at(1) == TK_K_ALTER || p.peek_at(1) == TK_K_ANALYZE || p.peek_at(1) == TK_K_AND || p.peek_at(1) == TK_K_AS || p.peek_at(1) == TK_K_ASC || p.peek_at(1) == TK_K_ATTACH || p.peek_at(1) == TK_K_AUTOINCREMENT || p.peek_at(1) == TK_K_BEFORE || p.peek_at(1) == TK_K_BEGIN || p.peek_at(1) == TK_K_BETWEEN || p.peek_at(1) == TK_K_BY || p.peek_at(1) == TK_K_CASCADE || p.peek_at(1) == TK_K_CASE || p.peek_at(1) == TK_K_CAST || p.peek_at(1) == TK_K_CHECK || p.peek_at(1) == TK_K_COLLATE || p.peek_at(1) == TK_K_COLUMN || p.peek_at(1) == TK_K_COMMIT || p.peek_at(1) == TK_K_CONFLICT || p.peek_at(1) == TK_K_CONSTRAINT || p.peek_at(1) == TK_K_CREATE || p.peek_at(1) == TK_K_CROSS || p.peek_at(1) == TK_K_DATABASE || p.peek_at(1) == TK_K_DEFAULT || p.peek_at(1) == TK_K_DEFERRABLE || p.peek_at(1) == TK_K_DEFERRED || p.peek_at(1) == TK_K_DELETE || p.peek_at(1) == TK_K_DESC || p.peek_at(1) == TK_K_DETACH || p.peek_at(1) == TK_K_DISTINCT || p.peek_at(1) == TK_K_DROP || p.peek_at(1) == TK_K_EACH || p.peek_at(1) == TK_K_ELSE || p.peek_at(1) == TK_K_END || p.peek_at(1) == TK_K_ESCAPE || p.peek_at(1) == TK_K_EXCEPT || p.peek_at(1) == TK_K_EXCLUSIVE || p.peek_at(1) == TK_K_EXISTS || p.peek_at(1) == TK_K_EXPLAIN || p.peek_at(1) == TK_K_FAIL || p.peek_at(1) == TK_K_FOR || p.peek_at(1) == TK_K_FOREIGN || p.peek_at(1) == TK_K_FROM || p.peek_at(1) == TK_K_FULL || p.peek_at(1) == TK_K_GLOB || p.peek_at(1) == TK_K_GROUP || p.peek_at(1) == TK_K_HAVING || p.peek_at(1) == TK_K_IF || p.peek_at(1) == TK_K_IGNORE || p.peek_at(1) == TK_K_IMMEDIATE || p.peek_at(1) == TK_K_IN || p.peek_at(1) == TK_K_INDEX || p.peek_at(1) == TK_K_INDEXED || p.peek_at(1) == TK_K_INITIALLY || p.peek_at(1) == TK_K_INNER || p.peek_at(1) == TK_K_INSERT || p.peek_at(1) == TK_K_INSTEAD || p.peek_at(1) == TK_K_INTERSECT || p.peek_at(1) == TK_K_INTO || p.peek_at(1) == TK_K_IS || p.peek_at(1) == TK_K_ISNULL || p.peek_at(1) == TK_K_JOIN || p.peek_at(1) == TK_K_KEY || p.peek_at(1) == TK_K_LEFT || p.peek_at(1) == TK_K_LIKE || p.peek_at(1) == TK_K_LIMIT || p.peek_at(1) == TK_K_MATCH || p.peek_at(1) == TK_K_NATURAL || p.peek_at(1) == TK_K_NO || p.peek_at(1) == TK_K_NOT || p.peek_at(1) == TK_K_NOTNULL || p.peek_at(1) == TK_K_OF || p.peek_at(1) == TK_K_OFFSET || p.peek_at(1) == TK_K_ON || p.peek_at(1) == TK_K_OR || p.peek_at(1) == TK_K_ORDER || p.peek_at(1) == TK_K_OUTER || p.peek_at(1) == TK_K_PLAN || p.peek_at(1) == TK_K_PRAGMA || p.peek_at(1) == TK_K_PRIMARY || p.peek_at(1) == TK_K_QUERY || p.peek_at(1) == TK_K_RAISE || p.peek_at(1) == TK_K_RECURSIVE || p.peek_at(1) == TK_K_REFERENCES || p.peek_at(1) == TK_K_REGEXP || p.peek_at(1) == TK_K_REINDEX || p.peek_at(1) == TK_K_RELEASE || p.peek_at(1) == TK_K_RENAME || p.peek_at(1) == TK_K_REPLACE || p.peek_at(1) == TK_K_RESTRICT || p.peek_at(1) == TK_K_RIGHT || p.peek_at(1) == TK_K_ROLLBACK || p.peek_at(1) == TK_K_ROW || p.peek_at(1) == TK_K_SAVEPOINT || p.peek_at(1) == TK_K_SELECT || p.peek_at(1) == TK_K_SET || p.peek_at(1) == TK_K_TABLE || p.peek_at(1) == TK_K_TEMP || p.peek_at(1) == TK_K_TEMPORARY || p.peek_at(1) == TK_K_THEN || p.peek_at(1) == TK_K_TO || p.peek_at(1) == TK_K_TRANSACTION || p.peek_at(1) == TK_K_TRIGGER || p.peek_at(1) == TK_K_UNION || p.peek_at(1) == TK_K_UNIQUE || p.peek_at(1) == TK_K_UPDATE || p.peek_at(1) == TK_K_USING || p.peek_at(1) == TK_K_VACUUM || p.peek_at(1) == TK_K_VALUES || p.peek_at(1) == TK_K_VIEW || p.peek_at(1) == TK_K_VIRTUAL || p.peek_at(1) == TK_K_WHEN || p.peek_at(1) == TK_K_WHERE || p.peek_at(1) == TK_K_WITH || p.peek_at(1) == TK_K_WITHOUT || p.peek_at(1) == TK_LIT_LPAREN || p.peek_at(1) == TK_LIT_MINUS || p.peek_at(1) == TK_LIT_PLUS || p.peek_at(1) == TK_LIT_TILDE) { - let tok_9 = p.expect(TK_K_LIMIT, "K_LIMIT")?; - let tok_10 = parse_expr(p)?; + let k_limit = p.expect(TK_K_LIMIT, "K_LIMIT")?; + let expr = parse_expr(p)?; } return Result::::Ok(SelectStmtNode { span: Span::new(start, p.last_end()), @@ -7774,19 +7802,19 @@ fn parse_select_or_values(p: &mut Parser) -> Result Result::Ok(SelectOrValuesNode::Alt0(SelectOrValuesAlt0 { span: Span::new(start, p.last_end()), @@ -7853,19 +7881,19 @@ fn parse_select_or_values(p: &mut Parser) -> Result::Ok(SelectOrValuesNode::Alt1(SelectOrValuesAlt1 { span: Span::new(start, p.last_end()), @@ -7896,17 +7924,17 @@ fn parse_update_stmt(p: &mut Parser) -> Result { opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_K_OR { - let tok = p.expect(TK_K_OR, "K_OR")?; + let k_or = p.expect(TK_K_OR, "K_OR")?; if p.peek_kind() == TK_K_ROLLBACK { - let tok_2 = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; + let k_rollback = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; } else if p.peek_kind() == TK_K_ABORT { - let tok_3 = p.expect(TK_K_ABORT, "K_ABORT")?; + let k_abort = p.expect(TK_K_ABORT, "K_ABORT")?; } else if p.peek_kind() == TK_K_REPLACE { - let tok_4 = p.expect(TK_K_REPLACE, "K_REPLACE")?; + let k_replace = p.expect(TK_K_REPLACE, "K_REPLACE")?; } else if p.peek_kind() == TK_K_FAIL { - let tok_5 = p.expect(TK_K_FAIL, "K_FAIL")?; + let k_fail = p.expect(TK_K_FAIL, "K_FAIL")?; } else if p.peek_kind() == TK_K_IGNORE { - let tok_6 = p.expect(TK_K_IGNORE, "K_IGNORE")?; + let k_ignore = p.expect(TK_K_IGNORE, "K_IGNORE")?; } } } @@ -7917,14 +7945,14 @@ fn parse_update_stmt(p: &mut Parser) -> Result { let eq = p.expect(TK_LIT_EQ, "'='")?; let expr = parse_expr(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_column_name(p)?; - let tok_3 = p.expect(TK_LIT_EQ, "'='")?; - let tok_4 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let column_name = parse_column_name(p)?; + let eq = p.expect(TK_LIT_EQ, "'='")?; + let expr = parse_expr(p)?; } if p.peek_kind() == TK_K_WHERE { - let tok = p.expect(TK_K_WHERE, "K_WHERE")?; - let tok_2 = parse_expr(p)?; + let k_where = p.expect(TK_K_WHERE, "K_WHERE")?; + let expr = parse_expr(p)?; } return Result::::Ok(UpdateStmtNode { span: Span::new(start, p.last_end()), @@ -7952,17 +7980,17 @@ fn parse_update_stmt_limited(p: &mut Parser) -> Result Result::Ok(UpdateStmtLimitedNode { span: Span::new(start, p.last_end()), @@ -8075,36 +8103,36 @@ fn parse_type_name(p: &mut Parser) -> Result { opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_LIT_LPAREN { - let tok = p.expect(TK_LIT_LPAREN, "'('")?; + let lparen = p.expect(TK_LIT_LPAREN, "'('")?; if p.peek_kind() == TK_LIT_PLUS { if p.peek_at(1) == TK_LIT_RPAREN { - let tok_2 = parse_signed_number(p)?; - let tok_3 = p.expect(TK_LIT_RPAREN, "')'")?; + let signed_number = parse_signed_number(p)?; + let rparen = p.expect(TK_LIT_RPAREN, "')'")?; } else if p.peek_at(1) == TK_LIT_COMMA { - let tok_4 = parse_signed_number(p)?; - let tok_5 = p.expect(TK_LIT_COMMA, "','")?; - let tok_6 = parse_signed_number(p)?; - let tok_7 = p.expect(TK_LIT_RPAREN, "')'")?; + let signed_number_2 = parse_signed_number(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let signed_number_3 = parse_signed_number(p)?; + let rparen_2 = p.expect(TK_LIT_RPAREN, "')'")?; } } else if p.peek_kind() == TK_LIT_MINUS { if p.peek_at(1) == TK_LIT_RPAREN { - let tok_8 = parse_signed_number(p)?; - let tok_9 = p.expect(TK_LIT_RPAREN, "')'")?; + let signed_number_4 = parse_signed_number(p)?; + let rparen_3 = p.expect(TK_LIT_RPAREN, "')'")?; } else if p.peek_at(1) == TK_LIT_COMMA { - let tok_10 = parse_signed_number(p)?; - let tok_11 = p.expect(TK_LIT_COMMA, "','")?; - let tok_12 = parse_signed_number(p)?; - let tok_13 = p.expect(TK_LIT_RPAREN, "')'")?; + let signed_number_5 = parse_signed_number(p)?; + let comma_2 = p.expect(TK_LIT_COMMA, "','")?; + let signed_number_6 = parse_signed_number(p)?; + let rparen_4 = p.expect(TK_LIT_RPAREN, "')'")?; } } else if p.peek_kind() == TK_NUMERIC_LITERAL { if p.peek_at(1) == TK_LIT_RPAREN { - let tok_14 = parse_signed_number(p)?; - let tok_15 = p.expect(TK_LIT_RPAREN, "')'")?; + let signed_number_7 = parse_signed_number(p)?; + let rparen_5 = p.expect(TK_LIT_RPAREN, "')'")?; } else if p.peek_at(1) == TK_LIT_COMMA { - let tok_16 = parse_signed_number(p)?; - let tok_17 = p.expect(TK_LIT_COMMA, "','")?; - let tok_18 = parse_signed_number(p)?; - let tok_19 = p.expect(TK_LIT_RPAREN, "')'")?; + let signed_number_8 = parse_signed_number(p)?; + let comma_3 = p.expect(TK_LIT_COMMA, "','")?; + let signed_number_9 = parse_signed_number(p)?; + let rparen_6 = p.expect(TK_LIT_RPAREN, "')'")?; } } } @@ -8119,25 +8147,25 @@ fn parse_type_name(p: &mut Parser) -> Result { fn parse_column_constraint(p: &mut Parser) -> Result { let start = p.peek().span.start; if p.peek_kind() == TK_K_CONSTRAINT { - let tok = p.expect(TK_K_CONSTRAINT, "K_CONSTRAINT")?; - let tok_2 = parse_name(p)?; + let k_constraint = p.expect(TK_K_CONSTRAINT, "K_CONSTRAINT")?; + let name = parse_name(p)?; } let grp_kind = p.peek_kind(); if grp_kind == TK_K_PRIMARY { - let tok_3 = p.expect(TK_K_PRIMARY, "K_PRIMARY")?; - let tok_4 = p.expect(TK_K_KEY, "K_KEY")?; + let k_primary = p.expect(TK_K_PRIMARY, "K_PRIMARY")?; + let k_key = p.expect(TK_K_KEY, "K_KEY")?; if p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_DESC { let opt_saved = p.pos; opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_K_ASC { - let tok = p.expect(TK_K_ASC, "K_ASC")?; + let k_asc = p.expect(TK_K_ASC, "K_ASC")?; } else if grp_kind == TK_K_DESC { - let tok_2 = p.expect(TK_K_DESC, "K_DESC")?; + let k_desc = p.expect(TK_K_DESC, "K_DESC")?; } } } - let tok_5 = parse_conflict_clause(p)?; + let conflict_clause = parse_conflict_clause(p)?; let k_autoincrement: Option = if p.peek_kind() == TK_K_AUTOINCREMENT { let k_autoincrement = p.expect(TK_K_AUTOINCREMENT, "K_AUTOINCREMENT")?; Option::::Some(k_autoincrement) @@ -8151,22 +8179,22 @@ fn parse_column_constraint(p: &mut Parser) -> Result Result::Ok(ColumnConstraintNode { span: Span::new(start, p.last_end()), @@ -8202,19 +8230,19 @@ fn parse_column_constraint(p: &mut Parser) -> Result Result { let start = p.peek().span.start; if p.peek_kind() == TK_K_ON && p.peek_at(1) == TK_K_CONFLICT { - let tok = p.expect(TK_K_ON, "K_ON")?; - let tok_2 = p.expect(TK_K_CONFLICT, "K_CONFLICT")?; + let k_on = p.expect(TK_K_ON, "K_ON")?; + let k_conflict = p.expect(TK_K_CONFLICT, "K_CONFLICT")?; let grp_kind = p.peek_kind(); if grp_kind == TK_K_ROLLBACK { - let tok_3 = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; + let k_rollback = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; } else if grp_kind == TK_K_ABORT { - let tok_4 = p.expect(TK_K_ABORT, "K_ABORT")?; + let k_abort = p.expect(TK_K_ABORT, "K_ABORT")?; } else if grp_kind == TK_K_FAIL { - let tok_5 = p.expect(TK_K_FAIL, "K_FAIL")?; + let k_fail = p.expect(TK_K_FAIL, "K_FAIL")?; } else if grp_kind == TK_K_IGNORE { - let tok_6 = p.expect(TK_K_IGNORE, "K_IGNORE")?; + let k_ignore = p.expect(TK_K_IGNORE, "K_IGNORE")?; } else if grp_kind == TK_K_REPLACE { - let tok_7 = p.expect(TK_K_REPLACE, "K_REPLACE")?; + let k_replace = p.expect(TK_K_REPLACE, "K_REPLACE")?; } } return Result::::Ok(ConflictClauseNode { @@ -8263,19 +8291,19 @@ fn parse_expr_bt_22(p: &mut Parser) -> Result { } else { null }; - let tok = p.expect(TK_K_WHEN, "K_WHEN")?; - let tok_2 = parse_expr(p)?; - let tok_3 = p.expect(TK_K_THEN, "K_THEN")?; - let tok_4 = parse_expr(p)?; + let k_when = p.expect(TK_K_WHEN, "K_WHEN")?; + let expr_2 = parse_expr(p)?; + let k_then = p.expect(TK_K_THEN, "K_THEN")?; + let expr_3 = parse_expr(p)?; while p.peek_kind() == TK_K_WHEN { - let tok = p.expect(TK_K_WHEN, "K_WHEN")?; - let tok_2 = parse_expr(p)?; - let tok_3 = p.expect(TK_K_THEN, "K_THEN")?; - let tok_4 = parse_expr(p)?; + let k_when = p.expect(TK_K_WHEN, "K_WHEN")?; + let expr = parse_expr(p)?; + let k_then = p.expect(TK_K_THEN, "K_THEN")?; + let expr_2 = parse_expr(p)?; } if p.peek_kind() == TK_K_ELSE { - let tok_5 = p.expect(TK_K_ELSE, "K_ELSE")?; - let tok_6 = parse_expr(p)?; + let k_else = p.expect(TK_K_ELSE, "K_ELSE")?; + let expr = parse_expr(p)?; } let k_end = p.expect(TK_K_END, "K_END")?; return Result::::Ok(ExprNode::Alt22(ExprAlt22 { @@ -8289,10 +8317,10 @@ fn parse_expr_bt_22(p: &mut Parser) -> Result { fn parse_expr_bt_21(p: &mut Parser) -> Result { let start = p.peek().span.start; if p.peek_kind() == TK_K_NOT && p.peek_at(1) == TK_K_EXISTS { - let tok = p.expect(TK_K_NOT, "K_NOT")?; - let tok_2 = p.expect(TK_K_EXISTS, "K_EXISTS")?; + let k_not = p.expect(TK_K_NOT, "K_NOT")?; + let k_exists = p.expect(TK_K_EXISTS, "K_EXISTS")?; } else if p.peek_kind() == TK_K_EXISTS { - let tok_3 = p.expect(TK_K_EXISTS, "K_EXISTS")?; + let k_exists = p.expect(TK_K_EXISTS, "K_EXISTS")?; } let lparen = p.expect(TK_LIT_LPAREN, "'('")?; let select_stmt = parse_select_stmt(p)?; @@ -8338,13 +8366,13 @@ fn parse_expr_bt_13(p: &mut Parser) -> Result { } else { null }; - let tok = parse_expr(p)?; + let expr = parse_expr(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let expr = parse_expr(p)?; } } else if grp_kind == TK_LIT_STAR { - let tok_2 = p.expect(TK_LIT_STAR, "'*'")?; + let star = p.expect(TK_LIT_STAR, "'*'")?; } } } @@ -8371,13 +8399,13 @@ fn parse_expr_bt_3(p: &mut Parser) -> Result { fn parse_expr_bt_2(p: &mut Parser) -> Result { let start = p.peek().span.start; if (p.peek_kind() == TK_IDENTIFIER || p.peek_kind() == TK_K_ABORT || p.peek_kind() == TK_K_ACTION || p.peek_kind() == TK_K_ADD || p.peek_kind() == TK_K_AFTER || p.peek_kind() == TK_K_ALL || p.peek_kind() == TK_K_ALTER || p.peek_kind() == TK_K_ANALYZE || p.peek_kind() == TK_K_AND || p.peek_kind() == TK_K_AS || p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_ATTACH || p.peek_kind() == TK_K_AUTOINCREMENT || p.peek_kind() == TK_K_BEFORE || p.peek_kind() == TK_K_BEGIN || p.peek_kind() == TK_K_BETWEEN || p.peek_kind() == TK_K_BY || p.peek_kind() == TK_K_CASCADE || p.peek_kind() == TK_K_CASE || p.peek_kind() == TK_K_CAST || p.peek_kind() == TK_K_CHECK || p.peek_kind() == TK_K_COLLATE || p.peek_kind() == TK_K_COLUMN || p.peek_kind() == TK_K_COMMIT || p.peek_kind() == TK_K_CONFLICT || p.peek_kind() == TK_K_CONSTRAINT || p.peek_kind() == TK_K_CREATE || p.peek_kind() == TK_K_CROSS || p.peek_kind() == TK_K_CURRENT_DATE || p.peek_kind() == TK_K_CURRENT_TIME || p.peek_kind() == TK_K_CURRENT_TIMESTAMP || p.peek_kind() == TK_K_DATABASE || p.peek_kind() == TK_K_DEFAULT || p.peek_kind() == TK_K_DEFERRABLE || p.peek_kind() == TK_K_DEFERRED || p.peek_kind() == TK_K_DELETE || p.peek_kind() == TK_K_DESC || p.peek_kind() == TK_K_DETACH || p.peek_kind() == TK_K_DISTINCT || p.peek_kind() == TK_K_DROP || p.peek_kind() == TK_K_EACH || p.peek_kind() == TK_K_ELSE || p.peek_kind() == TK_K_END || p.peek_kind() == TK_K_ESCAPE || p.peek_kind() == TK_K_EXCEPT || p.peek_kind() == TK_K_EXCLUSIVE || p.peek_kind() == TK_K_EXISTS || p.peek_kind() == TK_K_EXPLAIN || p.peek_kind() == TK_K_FAIL || p.peek_kind() == TK_K_FOR || p.peek_kind() == TK_K_FOREIGN || p.peek_kind() == TK_K_FROM || p.peek_kind() == TK_K_FULL || p.peek_kind() == TK_K_GLOB || p.peek_kind() == TK_K_GROUP || p.peek_kind() == TK_K_HAVING || p.peek_kind() == TK_K_IF || p.peek_kind() == TK_K_IGNORE || p.peek_kind() == TK_K_IMMEDIATE || p.peek_kind() == TK_K_IN || p.peek_kind() == TK_K_INDEX || p.peek_kind() == TK_K_INDEXED || p.peek_kind() == TK_K_INITIALLY || p.peek_kind() == TK_K_INNER || p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_INSTEAD || p.peek_kind() == TK_K_INTERSECT || p.peek_kind() == TK_K_INTO || p.peek_kind() == TK_K_IS || p.peek_kind() == TK_K_ISNULL || p.peek_kind() == TK_K_JOIN || p.peek_kind() == TK_K_KEY || p.peek_kind() == TK_K_LEFT || p.peek_kind() == TK_K_LIKE || p.peek_kind() == TK_K_LIMIT || p.peek_kind() == TK_K_MATCH || p.peek_kind() == TK_K_NATURAL || p.peek_kind() == TK_K_NO || p.peek_kind() == TK_K_NOT || p.peek_kind() == TK_K_NOTNULL || p.peek_kind() == TK_K_NULL || p.peek_kind() == TK_K_OF || p.peek_kind() == TK_K_OFFSET || p.peek_kind() == TK_K_ON || p.peek_kind() == TK_K_OR || p.peek_kind() == TK_K_ORDER || p.peek_kind() == TK_K_OUTER || p.peek_kind() == TK_K_PLAN || p.peek_kind() == TK_K_PRAGMA || p.peek_kind() == TK_K_PRIMARY || p.peek_kind() == TK_K_QUERY || p.peek_kind() == TK_K_RAISE || p.peek_kind() == TK_K_RECURSIVE || p.peek_kind() == TK_K_REFERENCES || p.peek_kind() == TK_K_REGEXP || p.peek_kind() == TK_K_REINDEX || p.peek_kind() == TK_K_RELEASE || p.peek_kind() == TK_K_RENAME || p.peek_kind() == TK_K_REPLACE || p.peek_kind() == TK_K_RESTRICT || p.peek_kind() == TK_K_RIGHT || p.peek_kind() == TK_K_ROLLBACK || p.peek_kind() == TK_K_ROW || p.peek_kind() == TK_K_SAVEPOINT || p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_SET || p.peek_kind() == TK_K_TABLE || p.peek_kind() == TK_K_TEMP || p.peek_kind() == TK_K_TEMPORARY || p.peek_kind() == TK_K_THEN || p.peek_kind() == TK_K_TO || p.peek_kind() == TK_K_TRANSACTION || p.peek_kind() == TK_K_TRIGGER || p.peek_kind() == TK_K_UNION || p.peek_kind() == TK_K_UNIQUE || p.peek_kind() == TK_K_UPDATE || p.peek_kind() == TK_K_USING || p.peek_kind() == TK_K_VACUUM || p.peek_kind() == TK_K_VALUES || p.peek_kind() == TK_K_VIEW || p.peek_kind() == TK_K_VIRTUAL || p.peek_kind() == TK_K_WHEN || p.peek_kind() == TK_K_WHERE || p.peek_kind() == TK_K_WITH || p.peek_kind() == TK_K_WITHOUT || p.peek_kind() == TK_STRING_LITERAL || p.peek_kind() == TK_LIT_LPAREN) && p.peek_at(1) == TK_LIT_DOT && (p.peek_at(2) == TK_IDENTIFIER || p.peek_at(2) == TK_K_ABORT || p.peek_at(2) == TK_K_ACTION || p.peek_at(2) == TK_K_ADD || p.peek_at(2) == TK_K_AFTER || p.peek_at(2) == TK_K_ALL || p.peek_at(2) == TK_K_ALTER || p.peek_at(2) == TK_K_ANALYZE || p.peek_at(2) == TK_K_AND || p.peek_at(2) == TK_K_AS || p.peek_at(2) == TK_K_ASC || p.peek_at(2) == TK_K_ATTACH || p.peek_at(2) == TK_K_AUTOINCREMENT || p.peek_at(2) == TK_K_BEFORE || p.peek_at(2) == TK_K_BEGIN || p.peek_at(2) == TK_K_BETWEEN || p.peek_at(2) == TK_K_BY || p.peek_at(2) == TK_K_CASCADE || p.peek_at(2) == TK_K_CASE || p.peek_at(2) == TK_K_CAST || p.peek_at(2) == TK_K_CHECK || p.peek_at(2) == TK_K_COLLATE || p.peek_at(2) == TK_K_COLUMN || p.peek_at(2) == TK_K_COMMIT || p.peek_at(2) == TK_K_CONFLICT || p.peek_at(2) == TK_K_CONSTRAINT || p.peek_at(2) == TK_K_CREATE || p.peek_at(2) == TK_K_CROSS || p.peek_at(2) == TK_K_CURRENT_DATE || p.peek_at(2) == TK_K_CURRENT_TIME || p.peek_at(2) == TK_K_CURRENT_TIMESTAMP || p.peek_at(2) == TK_K_DATABASE || p.peek_at(2) == TK_K_DEFAULT || p.peek_at(2) == TK_K_DEFERRABLE || p.peek_at(2) == TK_K_DEFERRED || p.peek_at(2) == TK_K_DELETE || p.peek_at(2) == TK_K_DESC || p.peek_at(2) == TK_K_DETACH || p.peek_at(2) == TK_K_DISTINCT || p.peek_at(2) == TK_K_DROP || p.peek_at(2) == TK_K_EACH || p.peek_at(2) == TK_K_ELSE || p.peek_at(2) == TK_K_END || p.peek_at(2) == TK_K_ESCAPE || p.peek_at(2) == TK_K_EXCEPT || p.peek_at(2) == TK_K_EXCLUSIVE || p.peek_at(2) == TK_K_EXISTS || p.peek_at(2) == TK_K_EXPLAIN || p.peek_at(2) == TK_K_FAIL || p.peek_at(2) == TK_K_FOR || p.peek_at(2) == TK_K_FOREIGN || p.peek_at(2) == TK_K_FROM || p.peek_at(2) == TK_K_FULL || p.peek_at(2) == TK_K_GLOB || p.peek_at(2) == TK_K_GROUP || p.peek_at(2) == TK_K_HAVING || p.peek_at(2) == TK_K_IF || p.peek_at(2) == TK_K_IGNORE || p.peek_at(2) == TK_K_IMMEDIATE || p.peek_at(2) == TK_K_IN || p.peek_at(2) == TK_K_INDEX || p.peek_at(2) == TK_K_INDEXED || p.peek_at(2) == TK_K_INITIALLY || p.peek_at(2) == TK_K_INNER || p.peek_at(2) == TK_K_INSERT || p.peek_at(2) == TK_K_INSTEAD || p.peek_at(2) == TK_K_INTERSECT || p.peek_at(2) == TK_K_INTO || p.peek_at(2) == TK_K_IS || p.peek_at(2) == TK_K_ISNULL || p.peek_at(2) == TK_K_JOIN || p.peek_at(2) == TK_K_KEY || p.peek_at(2) == TK_K_LEFT || p.peek_at(2) == TK_K_LIKE || p.peek_at(2) == TK_K_LIMIT || p.peek_at(2) == TK_K_MATCH || p.peek_at(2) == TK_K_NATURAL || p.peek_at(2) == TK_K_NO || p.peek_at(2) == TK_K_NOT || p.peek_at(2) == TK_K_NOTNULL || p.peek_at(2) == TK_K_NULL || p.peek_at(2) == TK_K_OF || p.peek_at(2) == TK_K_OFFSET || p.peek_at(2) == TK_K_ON || p.peek_at(2) == TK_K_OR || p.peek_at(2) == TK_K_ORDER || p.peek_at(2) == TK_K_OUTER || p.peek_at(2) == TK_K_PLAN || p.peek_at(2) == TK_K_PRAGMA || p.peek_at(2) == TK_K_PRIMARY || p.peek_at(2) == TK_K_QUERY || p.peek_at(2) == TK_K_RAISE || p.peek_at(2) == TK_K_RECURSIVE || p.peek_at(2) == TK_K_REFERENCES || p.peek_at(2) == TK_K_REGEXP || p.peek_at(2) == TK_K_REINDEX || p.peek_at(2) == TK_K_RELEASE || p.peek_at(2) == TK_K_RENAME || p.peek_at(2) == TK_K_REPLACE || p.peek_at(2) == TK_K_RESTRICT || p.peek_at(2) == TK_K_RIGHT || p.peek_at(2) == TK_K_ROLLBACK || p.peek_at(2) == TK_K_ROW || p.peek_at(2) == TK_K_SAVEPOINT || p.peek_at(2) == TK_K_SELECT || p.peek_at(2) == TK_K_SET || p.peek_at(2) == TK_K_TABLE || p.peek_at(2) == TK_K_TEMP || p.peek_at(2) == TK_K_TEMPORARY || p.peek_at(2) == TK_K_THEN || p.peek_at(2) == TK_K_TO || p.peek_at(2) == TK_K_TRANSACTION || p.peek_at(2) == TK_K_TRIGGER || p.peek_at(2) == TK_K_UNION || p.peek_at(2) == TK_K_UNIQUE || p.peek_at(2) == TK_K_UPDATE || p.peek_at(2) == TK_K_USING || p.peek_at(2) == TK_K_VACUUM || p.peek_at(2) == TK_K_VALUES || p.peek_at(2) == TK_K_VIEW || p.peek_at(2) == TK_K_VIRTUAL || p.peek_at(2) == TK_K_WHEN || p.peek_at(2) == TK_K_WHERE || p.peek_at(2) == TK_K_WITH || p.peek_at(2) == TK_K_WITHOUT || p.peek_at(2) == TK_STRING_LITERAL || p.peek_at(2) == TK_LIT_LPAREN) && p.peek_at(3) == TK_LIT_DOT { - let tok = parse_database_name(p)?; - let tok_2 = p.expect(TK_LIT_DOT, "'.'")?; - let tok_3 = parse_table_name(p)?; - let tok_4 = p.expect(TK_LIT_DOT, "'.'")?; + let database_name = parse_database_name(p)?; + let dot = p.expect(TK_LIT_DOT, "'.'")?; + let table_name = parse_table_name(p)?; + let dot_2 = p.expect(TK_LIT_DOT, "'.'")?; } else if (p.peek_kind() == TK_IDENTIFIER || p.peek_kind() == TK_K_ABORT || p.peek_kind() == TK_K_ACTION || p.peek_kind() == TK_K_ADD || p.peek_kind() == TK_K_AFTER || p.peek_kind() == TK_K_ALL || p.peek_kind() == TK_K_ALTER || p.peek_kind() == TK_K_ANALYZE || p.peek_kind() == TK_K_AND || p.peek_kind() == TK_K_AS || p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_ATTACH || p.peek_kind() == TK_K_AUTOINCREMENT || p.peek_kind() == TK_K_BEFORE || p.peek_kind() == TK_K_BEGIN || p.peek_kind() == TK_K_BETWEEN || p.peek_kind() == TK_K_BY || p.peek_kind() == TK_K_CASCADE || p.peek_kind() == TK_K_CASE || p.peek_kind() == TK_K_CAST || p.peek_kind() == TK_K_CHECK || p.peek_kind() == TK_K_COLLATE || p.peek_kind() == TK_K_COLUMN || p.peek_kind() == TK_K_COMMIT || p.peek_kind() == TK_K_CONFLICT || p.peek_kind() == TK_K_CONSTRAINT || p.peek_kind() == TK_K_CREATE || p.peek_kind() == TK_K_CROSS || p.peek_kind() == TK_K_CURRENT_DATE || p.peek_kind() == TK_K_CURRENT_TIME || p.peek_kind() == TK_K_CURRENT_TIMESTAMP || p.peek_kind() == TK_K_DATABASE || p.peek_kind() == TK_K_DEFAULT || p.peek_kind() == TK_K_DEFERRABLE || p.peek_kind() == TK_K_DEFERRED || p.peek_kind() == TK_K_DELETE || p.peek_kind() == TK_K_DESC || p.peek_kind() == TK_K_DETACH || p.peek_kind() == TK_K_DISTINCT || p.peek_kind() == TK_K_DROP || p.peek_kind() == TK_K_EACH || p.peek_kind() == TK_K_ELSE || p.peek_kind() == TK_K_END || p.peek_kind() == TK_K_ESCAPE || p.peek_kind() == TK_K_EXCEPT || p.peek_kind() == TK_K_EXCLUSIVE || p.peek_kind() == TK_K_EXISTS || p.peek_kind() == TK_K_EXPLAIN || p.peek_kind() == TK_K_FAIL || p.peek_kind() == TK_K_FOR || p.peek_kind() == TK_K_FOREIGN || p.peek_kind() == TK_K_FROM || p.peek_kind() == TK_K_FULL || p.peek_kind() == TK_K_GLOB || p.peek_kind() == TK_K_GROUP || p.peek_kind() == TK_K_HAVING || p.peek_kind() == TK_K_IF || p.peek_kind() == TK_K_IGNORE || p.peek_kind() == TK_K_IMMEDIATE || p.peek_kind() == TK_K_IN || p.peek_kind() == TK_K_INDEX || p.peek_kind() == TK_K_INDEXED || p.peek_kind() == TK_K_INITIALLY || p.peek_kind() == TK_K_INNER || p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_INSTEAD || p.peek_kind() == TK_K_INTERSECT || p.peek_kind() == TK_K_INTO || p.peek_kind() == TK_K_IS || p.peek_kind() == TK_K_ISNULL || p.peek_kind() == TK_K_JOIN || p.peek_kind() == TK_K_KEY || p.peek_kind() == TK_K_LEFT || p.peek_kind() == TK_K_LIKE || p.peek_kind() == TK_K_LIMIT || p.peek_kind() == TK_K_MATCH || p.peek_kind() == TK_K_NATURAL || p.peek_kind() == TK_K_NO || p.peek_kind() == TK_K_NOT || p.peek_kind() == TK_K_NOTNULL || p.peek_kind() == TK_K_NULL || p.peek_kind() == TK_K_OF || p.peek_kind() == TK_K_OFFSET || p.peek_kind() == TK_K_ON || p.peek_kind() == TK_K_OR || p.peek_kind() == TK_K_ORDER || p.peek_kind() == TK_K_OUTER || p.peek_kind() == TK_K_PLAN || p.peek_kind() == TK_K_PRAGMA || p.peek_kind() == TK_K_PRIMARY || p.peek_kind() == TK_K_QUERY || p.peek_kind() == TK_K_RAISE || p.peek_kind() == TK_K_RECURSIVE || p.peek_kind() == TK_K_REFERENCES || p.peek_kind() == TK_K_REGEXP || p.peek_kind() == TK_K_REINDEX || p.peek_kind() == TK_K_RELEASE || p.peek_kind() == TK_K_RENAME || p.peek_kind() == TK_K_REPLACE || p.peek_kind() == TK_K_RESTRICT || p.peek_kind() == TK_K_RIGHT || p.peek_kind() == TK_K_ROLLBACK || p.peek_kind() == TK_K_ROW || p.peek_kind() == TK_K_SAVEPOINT || p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_SET || p.peek_kind() == TK_K_TABLE || p.peek_kind() == TK_K_TEMP || p.peek_kind() == TK_K_TEMPORARY || p.peek_kind() == TK_K_THEN || p.peek_kind() == TK_K_TO || p.peek_kind() == TK_K_TRANSACTION || p.peek_kind() == TK_K_TRIGGER || p.peek_kind() == TK_K_UNION || p.peek_kind() == TK_K_UNIQUE || p.peek_kind() == TK_K_UPDATE || p.peek_kind() == TK_K_USING || p.peek_kind() == TK_K_VACUUM || p.peek_kind() == TK_K_VALUES || p.peek_kind() == TK_K_VIEW || p.peek_kind() == TK_K_VIRTUAL || p.peek_kind() == TK_K_WHEN || p.peek_kind() == TK_K_WHERE || p.peek_kind() == TK_K_WITH || p.peek_kind() == TK_K_WITHOUT || p.peek_kind() == TK_STRING_LITERAL || p.peek_kind() == TK_LIT_LPAREN) && p.peek_at(1) == TK_LIT_DOT { - let tok_5 = parse_table_name(p)?; - let tok_6 = p.expect(TK_LIT_DOT, "'.'")?; + let table_name = parse_table_name(p)?; + let dot = p.expect(TK_LIT_DOT, "'.'")?; } let column_name = parse_column_name(p)?; return Result::::Ok(ExprNode::Alt2(ExprAlt2 { @@ -8630,17 +8658,17 @@ fn parse_expr_lr_10(p: &mut Parser, left: ExprNode, start: i32) -> Result Result Result::Ok(ExprNode::Alt10(ExprAlt10 { @@ -8727,8 +8755,8 @@ fn parse_expr_lr_17(p: &mut Parser, left: ExprNode, start: i32) -> Result::Ok(ExprNode::Alt17(ExprAlt17 { span: Span::new(start, p.last_end()), @@ -8741,12 +8769,12 @@ fn parse_expr_lr_17(p: &mut Parser, left: ExprNode, start: i32) -> Result Result { let grp_kind = p.peek_kind(); if grp_kind == TK_K_ISNULL { - let tok = p.expect(TK_K_ISNULL, "K_ISNULL")?; + let k_isnull = p.expect(TK_K_ISNULL, "K_ISNULL")?; } else if grp_kind == TK_K_NOTNULL { - let tok_2 = p.expect(TK_K_NOTNULL, "K_NOTNULL")?; + let k_notnull = p.expect(TK_K_NOTNULL, "K_NOTNULL")?; } else if grp_kind == TK_K_NOT { - let tok_3 = p.expect(TK_K_NOT, "K_NOT")?; - let tok_4 = p.expect(TK_K_NULL, "K_NULL")?; + let k_not = p.expect(TK_K_NOT, "K_NOT")?; + let k_null = p.expect(TK_K_NULL, "K_NULL")?; } return Result::::Ok(ExprNode::Alt18(ExprAlt18 { span: Span::new(start, p.last_end()), @@ -8951,73 +8979,73 @@ fn parse_foreign_key_clause(p: &mut Parser) -> Result::Ok(ForeignKeyClauseNode { span: Span::new(start, p.last_end()), @@ -9032,18 +9060,18 @@ fn parse_raise_function(p: &mut Parser) -> Result let lparen = p.expect(TK_LIT_LPAREN, "'('")?; let grp_kind = p.peek_kind(); if grp_kind == TK_K_IGNORE { - let tok = p.expect(TK_K_IGNORE, "K_IGNORE")?; + let k_ignore = p.expect(TK_K_IGNORE, "K_IGNORE")?; } else if grp_kind == TK_K_ROLLBACK || grp_kind == TK_K_ABORT || grp_kind == TK_K_FAIL { - let grp_kind_2 = p.peek_kind(); - if grp_kind_2 == TK_K_ROLLBACK { - let tok_2 = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; - } else if grp_kind_2 == TK_K_ABORT { - let tok_3 = p.expect(TK_K_ABORT, "K_ABORT")?; - } else if grp_kind_2 == TK_K_FAIL { - let tok_4 = p.expect(TK_K_FAIL, "K_FAIL")?; + let grp_kind = p.peek_kind(); + if grp_kind == TK_K_ROLLBACK { + let k_rollback = p.expect(TK_K_ROLLBACK, "K_ROLLBACK")?; + } else if grp_kind == TK_K_ABORT { + let k_abort = p.expect(TK_K_ABORT, "K_ABORT")?; + } else if grp_kind == TK_K_FAIL { + let k_fail = p.expect(TK_K_FAIL, "K_FAIL")?; } - let tok_5 = p.expect(TK_LIT_COMMA, "','")?; - let tok_6 = parse_error_message(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let error_message = parse_error_message(p)?; } let rparen = p.expect(TK_LIT_RPAREN, "')'")?; return Result::::Ok(RaiseFunctionNode { @@ -9058,17 +9086,17 @@ fn parse_indexed_column(p: &mut Parser) -> Result let start = p.peek().span.start; let column_name = parse_column_name(p)?; if p.peek_kind() == TK_K_COLLATE { - let tok = p.expect(TK_K_COLLATE, "K_COLLATE")?; - let tok_2 = parse_collation_name(p)?; + let k_collate = p.expect(TK_K_COLLATE, "K_COLLATE")?; + let collation_name = parse_collation_name(p)?; } if p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_DESC { let opt_saved = p.pos; opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_K_ASC { - let tok = p.expect(TK_K_ASC, "K_ASC")?; + let k_asc = p.expect(TK_K_ASC, "K_ASC")?; } else if grp_kind == TK_K_DESC { - let tok_2 = p.expect(TK_K_DESC, "K_DESC")?; + let k_desc = p.expect(TK_K_DESC, "K_DESC")?; } } } @@ -9081,42 +9109,42 @@ fn parse_indexed_column(p: &mut Parser) -> Result fn parse_table_constraint(p: &mut Parser) -> Result { let start = p.peek().span.start; if p.peek_kind() == TK_K_CONSTRAINT { - let tok = p.expect(TK_K_CONSTRAINT, "K_CONSTRAINT")?; - let tok_2 = parse_name(p)?; + let k_constraint = p.expect(TK_K_CONSTRAINT, "K_CONSTRAINT")?; + let name = parse_name(p)?; } let grp_kind = p.peek_kind(); if grp_kind == TK_K_PRIMARY || grp_kind == TK_K_UNIQUE { - let grp_kind_2 = p.peek_kind(); - if grp_kind_2 == TK_K_PRIMARY { - let tok_3 = p.expect(TK_K_PRIMARY, "K_PRIMARY")?; - let tok_4 = p.expect(TK_K_KEY, "K_KEY")?; - } else if grp_kind_2 == TK_K_UNIQUE { - let tok_5 = p.expect(TK_K_UNIQUE, "K_UNIQUE")?; - } - let tok_6 = p.expect(TK_LIT_LPAREN, "'('")?; - let tok_7 = parse_indexed_column(p)?; + let grp_kind = p.peek_kind(); + if grp_kind == TK_K_PRIMARY { + let k_primary = p.expect(TK_K_PRIMARY, "K_PRIMARY")?; + let k_key = p.expect(TK_K_KEY, "K_KEY")?; + } else if grp_kind == TK_K_UNIQUE { + let k_unique = p.expect(TK_K_UNIQUE, "K_UNIQUE")?; + } + let lparen = p.expect(TK_LIT_LPAREN, "'('")?; + let indexed_column = parse_indexed_column(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_indexed_column(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let indexed_column = parse_indexed_column(p)?; } - let tok_8 = p.expect(TK_LIT_RPAREN, "')'")?; - let tok_9 = parse_conflict_clause(p)?; + let rparen = p.expect(TK_LIT_RPAREN, "')'")?; + let conflict_clause = parse_conflict_clause(p)?; } else if grp_kind == TK_K_CHECK { - let tok_10 = p.expect(TK_K_CHECK, "K_CHECK")?; - let tok_11 = p.expect(TK_LIT_LPAREN, "'('")?; - let tok_12 = parse_expr(p)?; - let tok_13 = p.expect(TK_LIT_RPAREN, "')'")?; + let k_check = p.expect(TK_K_CHECK, "K_CHECK")?; + let lparen = p.expect(TK_LIT_LPAREN, "'('")?; + let expr = parse_expr(p)?; + let rparen = p.expect(TK_LIT_RPAREN, "')'")?; } else if grp_kind == TK_K_FOREIGN { - let tok_14 = p.expect(TK_K_FOREIGN, "K_FOREIGN")?; - let tok_15 = p.expect(TK_K_KEY, "K_KEY")?; - let tok_16 = p.expect(TK_LIT_LPAREN, "'('")?; - let tok_17 = parse_column_name(p)?; + let k_foreign = p.expect(TK_K_FOREIGN, "K_FOREIGN")?; + let k_key = p.expect(TK_K_KEY, "K_KEY")?; + let lparen = p.expect(TK_LIT_LPAREN, "'('")?; + let column_name = parse_column_name(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_column_name(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let column_name = parse_column_name(p)?; } - let tok_18 = p.expect(TK_LIT_RPAREN, "')'")?; - let tok_19 = parse_foreign_key_clause(p)?; + let rparen = p.expect(TK_LIT_RPAREN, "')'")?; + let foreign_key_clause = parse_foreign_key_clause(p)?; } return Result::::Ok(TableConstraintNode { span: Span::new(start, p.last_end()), @@ -9134,8 +9162,8 @@ fn parse_with_clause(p: &mut Parser) -> Result { }; let common_table_expression = parse_common_table_expression(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_common_table_expression(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let common_table_expression = parse_common_table_expression(p)?; } return Result::::Ok(WithClauseNode { span: Span::new(start, p.last_end()), @@ -9162,12 +9190,12 @@ fn parse_qualified_table_name(p: &mut Parser) -> Result Result { let start = p.peek().span.start; let expr = parse_expr(p)?; if p.peek_kind() == TK_K_COLLATE { - let tok = p.expect(TK_K_COLLATE, "K_COLLATE")?; - let tok_2 = parse_collation_name(p)?; + let k_collate = p.expect(TK_K_COLLATE, "K_COLLATE")?; + let collation_name = parse_collation_name(p)?; } if p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_DESC { let opt_saved = p.pos; opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_K_ASC { - let tok = p.expect(TK_K_ASC, "K_ASC")?; + let k_asc = p.expect(TK_K_ASC, "K_ASC")?; } else if grp_kind == TK_K_DESC { - let tok_2 = p.expect(TK_K_DESC, "K_DESC")?; + let k_desc = p.expect(TK_K_DESC, "K_DESC")?; } } } @@ -9254,13 +9282,13 @@ fn parse_common_table_expression(p: &mut Parser) -> Result Result::Ok(ResultColumnNode::Alt2(ResultColumnAlt2 { span: Span::new(start, p.last_end()), @@ -9351,10 +9379,10 @@ fn parse_table_or_subquery_bt_2(p: &mut Parser) -> Result Result::Ok(TableOrSubqueryNode::Alt3(TableOrSubqueryAlt3 { span: Span::new(start, p.last_end()), @@ -9402,20 +9430,20 @@ fn parse_table_or_subquery_bt_1(p: &mut Parser) -> Result::Ok(TableOrSubqueryNode::Alt1(TableOrSubqueryAlt1 { span: Span::new(start, p.last_end()), @@ -9438,22 +9466,22 @@ fn parse_table_or_subquery_bt_0(p: &mut Parser) -> Result Result { let start = p.peek().span.start; let table_or_subquery = parse_table_or_subquery(p)?; while p.peek_kind() == TK_LIT_COMMA || p.peek_kind() == TK_K_NATURAL || p.peek_kind() == TK_K_LEFT || p.peek_kind() == TK_K_INNER || p.peek_kind() == TK_K_CROSS || p.peek_kind() == TK_K_JOIN { - let tok = parse_join_operator(p)?; - let tok_2 = parse_table_or_subquery(p)?; - let tok_3 = parse_join_constraint(p)?; + let join_operator = parse_join_operator(p)?; + let table_or_subquery = parse_table_or_subquery(p)?; + let join_constraint = parse_join_constraint(p)?; } return Result::::Ok(JoinClauseNode { span: Span::new(start, p.last_end()), @@ -9542,7 +9570,7 @@ fn parse_join_operator(p: &mut Parser) -> Result { opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_K_LEFT { - let tok = p.expect(TK_K_LEFT, "K_LEFT")?; + let k_left = p.expect(TK_K_LEFT, "K_LEFT")?; let k_outer: Option = if p.peek_kind() == TK_K_OUTER { let k_outer = p.expect(TK_K_OUTER, "K_OUTER")?; Option::::Some(k_outer) @@ -9550,9 +9578,9 @@ fn parse_join_operator(p: &mut Parser) -> Result { null }; } else if grp_kind == TK_K_INNER { - let tok_2 = p.expect(TK_K_INNER, "K_INNER")?; + let k_inner = p.expect(TK_K_INNER, "K_INNER")?; } else if grp_kind == TK_K_CROSS { - let tok_3 = p.expect(TK_K_CROSS, "K_CROSS")?; + let k_cross = p.expect(TK_K_CROSS, "K_CROSS")?; } } } @@ -9577,17 +9605,17 @@ fn parse_join_constraint(p: &mut Parser) -> Result Result { opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_K_DISTINCT { - let tok = p.expect(TK_K_DISTINCT, "K_DISTINCT")?; + let k_distinct = p.expect(TK_K_DISTINCT, "K_DISTINCT")?; } else if grp_kind == TK_K_ALL { - let tok_2 = p.expect(TK_K_ALL, "K_ALL")?; + let k_all = p.expect(TK_K_ALL, "K_ALL")?; } } } let result_column = parse_result_column(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_result_column(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let result_column = parse_result_column(p)?; } if p.peek_kind() == TK_K_FROM { - let tok = p.expect(TK_K_FROM, "K_FROM")?; + let k_from = p.expect(TK_K_FROM, "K_FROM")?; let grp_kind = p.peek_kind(); if grp_kind == TK_IDENTIFIER || grp_kind == TK_K_ABORT || grp_kind == TK_K_ACTION || grp_kind == TK_K_ADD || grp_kind == TK_K_AFTER || grp_kind == TK_K_ALL || grp_kind == TK_K_ALTER || grp_kind == TK_K_ANALYZE || grp_kind == TK_K_AND || grp_kind == TK_K_AS || grp_kind == TK_K_ASC || grp_kind == TK_K_ATTACH || grp_kind == TK_K_AUTOINCREMENT || grp_kind == TK_K_BEFORE || grp_kind == TK_K_BEGIN || grp_kind == TK_K_BETWEEN || grp_kind == TK_K_BY || grp_kind == TK_K_CASCADE || grp_kind == TK_K_CASE || grp_kind == TK_K_CAST || grp_kind == TK_K_CHECK || grp_kind == TK_K_COLLATE || grp_kind == TK_K_COLUMN || grp_kind == TK_K_COMMIT || grp_kind == TK_K_CONFLICT || grp_kind == TK_K_CONSTRAINT || grp_kind == TK_K_CREATE || grp_kind == TK_K_CROSS || grp_kind == TK_K_CURRENT_DATE || grp_kind == TK_K_CURRENT_TIME || grp_kind == TK_K_CURRENT_TIMESTAMP || grp_kind == TK_K_DATABASE || grp_kind == TK_K_DEFAULT || grp_kind == TK_K_DEFERRABLE || grp_kind == TK_K_DEFERRED || grp_kind == TK_K_DELETE || grp_kind == TK_K_DESC || grp_kind == TK_K_DETACH || grp_kind == TK_K_DISTINCT || grp_kind == TK_K_DROP || grp_kind == TK_K_EACH || grp_kind == TK_K_ELSE || grp_kind == TK_K_END || grp_kind == TK_K_ESCAPE || grp_kind == TK_K_EXCEPT || grp_kind == TK_K_EXCLUSIVE || grp_kind == TK_K_EXISTS || grp_kind == TK_K_EXPLAIN || grp_kind == TK_K_FAIL || grp_kind == TK_K_FOR || grp_kind == TK_K_FOREIGN || grp_kind == TK_K_FROM || grp_kind == TK_K_FULL || grp_kind == TK_K_GLOB || grp_kind == TK_K_GROUP || grp_kind == TK_K_HAVING || grp_kind == TK_K_IF || grp_kind == TK_K_IGNORE || grp_kind == TK_K_IMMEDIATE || grp_kind == TK_K_IN || grp_kind == TK_K_INDEX || grp_kind == TK_K_INDEXED || grp_kind == TK_K_INITIALLY || grp_kind == TK_K_INNER || grp_kind == TK_K_INSERT || grp_kind == TK_K_INSTEAD || grp_kind == TK_K_INTERSECT || grp_kind == TK_K_INTO || grp_kind == TK_K_IS || grp_kind == TK_K_ISNULL || grp_kind == TK_K_JOIN || grp_kind == TK_K_KEY || grp_kind == TK_K_LEFT || grp_kind == TK_K_LIKE || grp_kind == TK_K_LIMIT || grp_kind == TK_K_MATCH || grp_kind == TK_K_NATURAL || grp_kind == TK_K_NO || grp_kind == TK_K_NOT || grp_kind == TK_K_NOTNULL || grp_kind == TK_K_NULL || grp_kind == TK_K_OF || grp_kind == TK_K_OFFSET || grp_kind == TK_K_ON || grp_kind == TK_K_OR || grp_kind == TK_K_ORDER || grp_kind == TK_K_OUTER || grp_kind == TK_K_PLAN || grp_kind == TK_K_PRAGMA || grp_kind == TK_K_PRIMARY || grp_kind == TK_K_QUERY || grp_kind == TK_K_RAISE || grp_kind == TK_K_RECURSIVE || grp_kind == TK_K_REFERENCES || grp_kind == TK_K_REGEXP || grp_kind == TK_K_REINDEX || grp_kind == TK_K_RELEASE || grp_kind == TK_K_RENAME || grp_kind == TK_K_REPLACE || grp_kind == TK_K_RESTRICT || grp_kind == TK_K_RIGHT || grp_kind == TK_K_ROLLBACK || grp_kind == TK_K_ROW || grp_kind == TK_K_SAVEPOINT || grp_kind == TK_K_SELECT || grp_kind == TK_K_SET || grp_kind == TK_K_TABLE || grp_kind == TK_K_TEMP || grp_kind == TK_K_TEMPORARY || grp_kind == TK_K_THEN || grp_kind == TK_K_TO || grp_kind == TK_K_TRANSACTION || grp_kind == TK_K_TRIGGER || grp_kind == TK_K_UNION || grp_kind == TK_K_UNIQUE || grp_kind == TK_K_UPDATE || grp_kind == TK_K_USING || grp_kind == TK_K_VACUUM || grp_kind == TK_K_VALUES || grp_kind == TK_K_VIEW || grp_kind == TK_K_VIRTUAL || grp_kind == TK_K_WHEN || grp_kind == TK_K_WHERE || grp_kind == TK_K_WITH || grp_kind == TK_K_WITHOUT || grp_kind == TK_STRING_LITERAL || grp_kind == TK_LIT_LPAREN { if p.peek_kind() == TK_IDENTIFIER || p.peek_kind() == TK_K_ABORT || p.peek_kind() == TK_K_ACTION || p.peek_kind() == TK_K_ADD || p.peek_kind() == TK_K_AFTER || p.peek_kind() == TK_K_ALL || p.peek_kind() == TK_K_ALTER || p.peek_kind() == TK_K_ANALYZE || p.peek_kind() == TK_K_AND || p.peek_kind() == TK_K_AS || p.peek_kind() == TK_K_ASC || p.peek_kind() == TK_K_ATTACH || p.peek_kind() == TK_K_AUTOINCREMENT || p.peek_kind() == TK_K_BEFORE || p.peek_kind() == TK_K_BEGIN || p.peek_kind() == TK_K_BETWEEN || p.peek_kind() == TK_K_BY || p.peek_kind() == TK_K_CASCADE || p.peek_kind() == TK_K_CASE || p.peek_kind() == TK_K_CAST || p.peek_kind() == TK_K_CHECK || p.peek_kind() == TK_K_COLLATE || p.peek_kind() == TK_K_COLUMN || p.peek_kind() == TK_K_COMMIT || p.peek_kind() == TK_K_CONFLICT || p.peek_kind() == TK_K_CONSTRAINT || p.peek_kind() == TK_K_CREATE || p.peek_kind() == TK_K_CROSS || p.peek_kind() == TK_K_CURRENT_DATE || p.peek_kind() == TK_K_CURRENT_TIME || p.peek_kind() == TK_K_CURRENT_TIMESTAMP || p.peek_kind() == TK_K_DATABASE || p.peek_kind() == TK_K_DEFAULT || p.peek_kind() == TK_K_DEFERRABLE || p.peek_kind() == TK_K_DEFERRED || p.peek_kind() == TK_K_DELETE || p.peek_kind() == TK_K_DESC || p.peek_kind() == TK_K_DETACH || p.peek_kind() == TK_K_DISTINCT || p.peek_kind() == TK_K_DROP || p.peek_kind() == TK_K_EACH || p.peek_kind() == TK_K_ELSE || p.peek_kind() == TK_K_END || p.peek_kind() == TK_K_ESCAPE || p.peek_kind() == TK_K_EXCEPT || p.peek_kind() == TK_K_EXCLUSIVE || p.peek_kind() == TK_K_EXISTS || p.peek_kind() == TK_K_EXPLAIN || p.peek_kind() == TK_K_FAIL || p.peek_kind() == TK_K_FOR || p.peek_kind() == TK_K_FOREIGN || p.peek_kind() == TK_K_FROM || p.peek_kind() == TK_K_FULL || p.peek_kind() == TK_K_GLOB || p.peek_kind() == TK_K_GROUP || p.peek_kind() == TK_K_HAVING || p.peek_kind() == TK_K_IF || p.peek_kind() == TK_K_IGNORE || p.peek_kind() == TK_K_IMMEDIATE || p.peek_kind() == TK_K_IN || p.peek_kind() == TK_K_INDEX || p.peek_kind() == TK_K_INDEXED || p.peek_kind() == TK_K_INITIALLY || p.peek_kind() == TK_K_INNER || p.peek_kind() == TK_K_INSERT || p.peek_kind() == TK_K_INSTEAD || p.peek_kind() == TK_K_INTERSECT || p.peek_kind() == TK_K_INTO || p.peek_kind() == TK_K_IS || p.peek_kind() == TK_K_ISNULL || p.peek_kind() == TK_K_JOIN || p.peek_kind() == TK_K_KEY || p.peek_kind() == TK_K_LEFT || p.peek_kind() == TK_K_LIKE || p.peek_kind() == TK_K_LIMIT || p.peek_kind() == TK_K_MATCH || p.peek_kind() == TK_K_NATURAL || p.peek_kind() == TK_K_NO || p.peek_kind() == TK_K_NOT || p.peek_kind() == TK_K_NOTNULL || p.peek_kind() == TK_K_NULL || p.peek_kind() == TK_K_OF || p.peek_kind() == TK_K_OFFSET || p.peek_kind() == TK_K_ON || p.peek_kind() == TK_K_OR || p.peek_kind() == TK_K_ORDER || p.peek_kind() == TK_K_OUTER || p.peek_kind() == TK_K_PLAN || p.peek_kind() == TK_K_PRAGMA || p.peek_kind() == TK_K_PRIMARY || p.peek_kind() == TK_K_QUERY || p.peek_kind() == TK_K_RAISE || p.peek_kind() == TK_K_RECURSIVE || p.peek_kind() == TK_K_REFERENCES || p.peek_kind() == TK_K_REGEXP || p.peek_kind() == TK_K_REINDEX || p.peek_kind() == TK_K_RELEASE || p.peek_kind() == TK_K_RENAME || p.peek_kind() == TK_K_REPLACE || p.peek_kind() == TK_K_RESTRICT || p.peek_kind() == TK_K_RIGHT || p.peek_kind() == TK_K_ROLLBACK || p.peek_kind() == TK_K_ROW || p.peek_kind() == TK_K_SAVEPOINT || p.peek_kind() == TK_K_SELECT || p.peek_kind() == TK_K_SET || p.peek_kind() == TK_K_TABLE || p.peek_kind() == TK_K_TEMP || p.peek_kind() == TK_K_TEMPORARY || p.peek_kind() == TK_K_THEN || p.peek_kind() == TK_K_TO || p.peek_kind() == TK_K_TRANSACTION || p.peek_kind() == TK_K_TRIGGER || p.peek_kind() == TK_K_UNION || p.peek_kind() == TK_K_UNIQUE || p.peek_kind() == TK_K_UPDATE || p.peek_kind() == TK_K_USING || p.peek_kind() == TK_K_VACUUM || p.peek_kind() == TK_K_VALUES || p.peek_kind() == TK_K_VIEW || p.peek_kind() == TK_K_VIRTUAL || p.peek_kind() == TK_K_WHEN || p.peek_kind() == TK_K_WHERE || p.peek_kind() == TK_K_WITH || p.peek_kind() == TK_K_WITHOUT || p.peek_kind() == TK_STRING_LITERAL || p.peek_kind() == TK_LIT_LPAREN { @@ -9632,47 +9660,47 @@ fn parse_select_core(p: &mut Parser) -> Result { } } if !bt_done { - let tok = parse_table_or_subquery(p)?; + let table_or_subquery = parse_table_or_subquery(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_table_or_subquery(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let table_or_subquery = parse_table_or_subquery(p)?; } } } } } if p.peek_kind() == TK_K_WHERE { - let tok_2 = p.expect(TK_K_WHERE, "K_WHERE")?; - let tok_3 = parse_expr(p)?; + let k_where = p.expect(TK_K_WHERE, "K_WHERE")?; + let expr = parse_expr(p)?; } if p.peek_kind() == TK_K_GROUP && p.peek_at(1) == TK_K_BY && (p.peek_at(2) == TK_NUMERIC_LITERAL || p.peek_at(2) == TK_STRING_LITERAL || p.peek_at(2) == TK_BLOB_LITERAL || p.peek_at(2) == TK_K_NULL || p.peek_at(2) == TK_K_CURRENT_TIME || p.peek_at(2) == TK_K_CURRENT_DATE || p.peek_at(2) == TK_K_CURRENT_TIMESTAMP || p.peek_at(2) == TK_BIND_PARAMETER || p.peek_at(2) == TK_IDENTIFIER || p.peek_at(2) == TK_K_ABORT || p.peek_at(2) == TK_K_ACTION || p.peek_at(2) == TK_K_ADD || p.peek_at(2) == TK_K_AFTER || p.peek_at(2) == TK_K_ALL || p.peek_at(2) == TK_K_ALTER || p.peek_at(2) == TK_K_ANALYZE || p.peek_at(2) == TK_K_AND || p.peek_at(2) == TK_K_AS || p.peek_at(2) == TK_K_ASC || p.peek_at(2) == TK_K_ATTACH || p.peek_at(2) == TK_K_AUTOINCREMENT || p.peek_at(2) == TK_K_BEFORE || p.peek_at(2) == TK_K_BEGIN || p.peek_at(2) == TK_K_BETWEEN || p.peek_at(2) == TK_K_BY || p.peek_at(2) == TK_K_CASCADE || p.peek_at(2) == TK_K_CASE || p.peek_at(2) == TK_K_CAST || p.peek_at(2) == TK_K_CHECK || p.peek_at(2) == TK_K_COLLATE || p.peek_at(2) == TK_K_COLUMN || p.peek_at(2) == TK_K_COMMIT || p.peek_at(2) == TK_K_CONFLICT || p.peek_at(2) == TK_K_CONSTRAINT || p.peek_at(2) == TK_K_CREATE || p.peek_at(2) == TK_K_CROSS || p.peek_at(2) == TK_K_DATABASE || p.peek_at(2) == TK_K_DEFAULT || p.peek_at(2) == TK_K_DEFERRABLE || p.peek_at(2) == TK_K_DEFERRED || p.peek_at(2) == TK_K_DELETE || p.peek_at(2) == TK_K_DESC || p.peek_at(2) == TK_K_DETACH || p.peek_at(2) == TK_K_DISTINCT || p.peek_at(2) == TK_K_DROP || p.peek_at(2) == TK_K_EACH || p.peek_at(2) == TK_K_ELSE || p.peek_at(2) == TK_K_END || p.peek_at(2) == TK_K_ESCAPE || p.peek_at(2) == TK_K_EXCEPT || p.peek_at(2) == TK_K_EXCLUSIVE || p.peek_at(2) == TK_K_EXISTS || p.peek_at(2) == TK_K_EXPLAIN || p.peek_at(2) == TK_K_FAIL || p.peek_at(2) == TK_K_FOR || p.peek_at(2) == TK_K_FOREIGN || p.peek_at(2) == TK_K_FROM || p.peek_at(2) == TK_K_FULL || p.peek_at(2) == TK_K_GLOB || p.peek_at(2) == TK_K_GROUP || p.peek_at(2) == TK_K_HAVING || p.peek_at(2) == TK_K_IF || p.peek_at(2) == TK_K_IGNORE || p.peek_at(2) == TK_K_IMMEDIATE || p.peek_at(2) == TK_K_IN || p.peek_at(2) == TK_K_INDEX || p.peek_at(2) == TK_K_INDEXED || p.peek_at(2) == TK_K_INITIALLY || p.peek_at(2) == TK_K_INNER || p.peek_at(2) == TK_K_INSERT || p.peek_at(2) == TK_K_INSTEAD || p.peek_at(2) == TK_K_INTERSECT || p.peek_at(2) == TK_K_INTO || p.peek_at(2) == TK_K_IS || p.peek_at(2) == TK_K_ISNULL || p.peek_at(2) == TK_K_JOIN || p.peek_at(2) == TK_K_KEY || p.peek_at(2) == TK_K_LEFT || p.peek_at(2) == TK_K_LIKE || p.peek_at(2) == TK_K_LIMIT || p.peek_at(2) == TK_K_MATCH || p.peek_at(2) == TK_K_NATURAL || p.peek_at(2) == TK_K_NO || p.peek_at(2) == TK_K_NOT || p.peek_at(2) == TK_K_NOTNULL || p.peek_at(2) == TK_K_OF || p.peek_at(2) == TK_K_OFFSET || p.peek_at(2) == TK_K_ON || p.peek_at(2) == TK_K_OR || p.peek_at(2) == TK_K_ORDER || p.peek_at(2) == TK_K_OUTER || p.peek_at(2) == TK_K_PLAN || p.peek_at(2) == TK_K_PRAGMA || p.peek_at(2) == TK_K_PRIMARY || p.peek_at(2) == TK_K_QUERY || p.peek_at(2) == TK_K_RAISE || p.peek_at(2) == TK_K_RECURSIVE || p.peek_at(2) == TK_K_REFERENCES || p.peek_at(2) == TK_K_REGEXP || p.peek_at(2) == TK_K_REINDEX || p.peek_at(2) == TK_K_RELEASE || p.peek_at(2) == TK_K_RENAME || p.peek_at(2) == TK_K_REPLACE || p.peek_at(2) == TK_K_RESTRICT || p.peek_at(2) == TK_K_RIGHT || p.peek_at(2) == TK_K_ROLLBACK || p.peek_at(2) == TK_K_ROW || p.peek_at(2) == TK_K_SAVEPOINT || p.peek_at(2) == TK_K_SELECT || p.peek_at(2) == TK_K_SET || p.peek_at(2) == TK_K_TABLE || p.peek_at(2) == TK_K_TEMP || p.peek_at(2) == TK_K_TEMPORARY || p.peek_at(2) == TK_K_THEN || p.peek_at(2) == TK_K_TO || p.peek_at(2) == TK_K_TRANSACTION || p.peek_at(2) == TK_K_TRIGGER || p.peek_at(2) == TK_K_UNION || p.peek_at(2) == TK_K_UNIQUE || p.peek_at(2) == TK_K_UPDATE || p.peek_at(2) == TK_K_USING || p.peek_at(2) == TK_K_VACUUM || p.peek_at(2) == TK_K_VALUES || p.peek_at(2) == TK_K_VIEW || p.peek_at(2) == TK_K_VIRTUAL || p.peek_at(2) == TK_K_WHEN || p.peek_at(2) == TK_K_WHERE || p.peek_at(2) == TK_K_WITH || p.peek_at(2) == TK_K_WITHOUT || p.peek_at(2) == TK_LIT_LPAREN || p.peek_at(2) == TK_LIT_MINUS || p.peek_at(2) == TK_LIT_PLUS || p.peek_at(2) == TK_LIT_TILDE) && p.peek_at(3) == TK_LIT_COMMA && p.peek_at(4) == TK_K_HAVING && (p.peek_at(5) == TK_NUMERIC_LITERAL || p.peek_at(5) == TK_STRING_LITERAL || p.peek_at(5) == TK_BLOB_LITERAL || p.peek_at(5) == TK_K_NULL || p.peek_at(5) == TK_K_CURRENT_TIME || p.peek_at(5) == TK_K_CURRENT_DATE || p.peek_at(5) == TK_K_CURRENT_TIMESTAMP || p.peek_at(5) == TK_BIND_PARAMETER || p.peek_at(5) == TK_IDENTIFIER || p.peek_at(5) == TK_K_ABORT || p.peek_at(5) == TK_K_ACTION || p.peek_at(5) == TK_K_ADD || p.peek_at(5) == TK_K_AFTER || p.peek_at(5) == TK_K_ALL || p.peek_at(5) == TK_K_ALTER || p.peek_at(5) == TK_K_ANALYZE || p.peek_at(5) == TK_K_AND || p.peek_at(5) == TK_K_AS || p.peek_at(5) == TK_K_ASC || p.peek_at(5) == TK_K_ATTACH || p.peek_at(5) == TK_K_AUTOINCREMENT || p.peek_at(5) == TK_K_BEFORE || p.peek_at(5) == TK_K_BEGIN || p.peek_at(5) == TK_K_BETWEEN || p.peek_at(5) == TK_K_BY || p.peek_at(5) == TK_K_CASCADE || p.peek_at(5) == TK_K_CASE || p.peek_at(5) == TK_K_CAST || p.peek_at(5) == TK_K_CHECK || p.peek_at(5) == TK_K_COLLATE || p.peek_at(5) == TK_K_COLUMN || p.peek_at(5) == TK_K_COMMIT || p.peek_at(5) == TK_K_CONFLICT || p.peek_at(5) == TK_K_CONSTRAINT || p.peek_at(5) == TK_K_CREATE || p.peek_at(5) == TK_K_CROSS || p.peek_at(5) == TK_K_DATABASE || p.peek_at(5) == TK_K_DEFAULT || p.peek_at(5) == TK_K_DEFERRABLE || p.peek_at(5) == TK_K_DEFERRED || p.peek_at(5) == TK_K_DELETE || p.peek_at(5) == TK_K_DESC || p.peek_at(5) == TK_K_DETACH || p.peek_at(5) == TK_K_DISTINCT || p.peek_at(5) == TK_K_DROP || p.peek_at(5) == TK_K_EACH || p.peek_at(5) == TK_K_ELSE || p.peek_at(5) == TK_K_END || p.peek_at(5) == TK_K_ESCAPE || p.peek_at(5) == TK_K_EXCEPT || p.peek_at(5) == TK_K_EXCLUSIVE || p.peek_at(5) == TK_K_EXISTS || p.peek_at(5) == TK_K_EXPLAIN || p.peek_at(5) == TK_K_FAIL || p.peek_at(5) == TK_K_FOR || p.peek_at(5) == TK_K_FOREIGN || p.peek_at(5) == TK_K_FROM || p.peek_at(5) == TK_K_FULL || p.peek_at(5) == TK_K_GLOB || p.peek_at(5) == TK_K_GROUP || p.peek_at(5) == TK_K_HAVING || p.peek_at(5) == TK_K_IF || p.peek_at(5) == TK_K_IGNORE || p.peek_at(5) == TK_K_IMMEDIATE || p.peek_at(5) == TK_K_IN || p.peek_at(5) == TK_K_INDEX || p.peek_at(5) == TK_K_INDEXED || p.peek_at(5) == TK_K_INITIALLY || p.peek_at(5) == TK_K_INNER || p.peek_at(5) == TK_K_INSERT || p.peek_at(5) == TK_K_INSTEAD || p.peek_at(5) == TK_K_INTERSECT || p.peek_at(5) == TK_K_INTO || p.peek_at(5) == TK_K_IS || p.peek_at(5) == TK_K_ISNULL || p.peek_at(5) == TK_K_JOIN || p.peek_at(5) == TK_K_KEY || p.peek_at(5) == TK_K_LEFT || p.peek_at(5) == TK_K_LIKE || p.peek_at(5) == TK_K_LIMIT || p.peek_at(5) == TK_K_MATCH || p.peek_at(5) == TK_K_NATURAL || p.peek_at(5) == TK_K_NO || p.peek_at(5) == TK_K_NOT || p.peek_at(5) == TK_K_NOTNULL || p.peek_at(5) == TK_K_OF || p.peek_at(5) == TK_K_OFFSET || p.peek_at(5) == TK_K_ON || p.peek_at(5) == TK_K_OR || p.peek_at(5) == TK_K_ORDER || p.peek_at(5) == TK_K_OUTER || p.peek_at(5) == TK_K_PLAN || p.peek_at(5) == TK_K_PRAGMA || p.peek_at(5) == TK_K_PRIMARY || p.peek_at(5) == TK_K_QUERY || p.peek_at(5) == TK_K_RAISE || p.peek_at(5) == TK_K_RECURSIVE || p.peek_at(5) == TK_K_REFERENCES || p.peek_at(5) == TK_K_REGEXP || p.peek_at(5) == TK_K_REINDEX || p.peek_at(5) == TK_K_RELEASE || p.peek_at(5) == TK_K_RENAME || p.peek_at(5) == TK_K_REPLACE || p.peek_at(5) == TK_K_RESTRICT || p.peek_at(5) == TK_K_RIGHT || p.peek_at(5) == TK_K_ROLLBACK || p.peek_at(5) == TK_K_ROW || p.peek_at(5) == TK_K_SAVEPOINT || p.peek_at(5) == TK_K_SELECT || p.peek_at(5) == TK_K_SET || p.peek_at(5) == TK_K_TABLE || p.peek_at(5) == TK_K_TEMP || p.peek_at(5) == TK_K_TEMPORARY || p.peek_at(5) == TK_K_THEN || p.peek_at(5) == TK_K_TO || p.peek_at(5) == TK_K_TRANSACTION || p.peek_at(5) == TK_K_TRIGGER || p.peek_at(5) == TK_K_UNION || p.peek_at(5) == TK_K_UNIQUE || p.peek_at(5) == TK_K_UPDATE || p.peek_at(5) == TK_K_USING || p.peek_at(5) == TK_K_VACUUM || p.peek_at(5) == TK_K_VALUES || p.peek_at(5) == TK_K_VIEW || p.peek_at(5) == TK_K_VIRTUAL || p.peek_at(5) == TK_K_WHEN || p.peek_at(5) == TK_K_WHERE || p.peek_at(5) == TK_K_WITH || p.peek_at(5) == TK_K_WITHOUT || p.peek_at(5) == TK_LIT_LPAREN || p.peek_at(5) == TK_LIT_MINUS || p.peek_at(5) == TK_LIT_PLUS || p.peek_at(5) == TK_LIT_TILDE) { - let tok_4 = p.expect(TK_K_GROUP, "K_GROUP")?; - let tok_5 = p.expect(TK_K_BY, "K_BY")?; - let tok_6 = parse_expr(p)?; + let k_group = p.expect(TK_K_GROUP, "K_GROUP")?; + let k_by = p.expect(TK_K_BY, "K_BY")?; + let expr = parse_expr(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let expr = parse_expr(p)?; } - let tok_7 = p.expect(TK_K_HAVING, "K_HAVING")?; - let tok_8 = parse_expr(p)?; + let k_having = p.expect(TK_K_HAVING, "K_HAVING")?; + let expr_2 = parse_expr(p)?; } else if p.peek_kind() == TK_K_GROUP && p.peek_at(1) == TK_K_BY && (p.peek_at(2) == TK_NUMERIC_LITERAL || p.peek_at(2) == TK_STRING_LITERAL || p.peek_at(2) == TK_BLOB_LITERAL || p.peek_at(2) == TK_K_NULL || p.peek_at(2) == TK_K_CURRENT_TIME || p.peek_at(2) == TK_K_CURRENT_DATE || p.peek_at(2) == TK_K_CURRENT_TIMESTAMP || p.peek_at(2) == TK_BIND_PARAMETER || p.peek_at(2) == TK_IDENTIFIER || p.peek_at(2) == TK_K_ABORT || p.peek_at(2) == TK_K_ACTION || p.peek_at(2) == TK_K_ADD || p.peek_at(2) == TK_K_AFTER || p.peek_at(2) == TK_K_ALL || p.peek_at(2) == TK_K_ALTER || p.peek_at(2) == TK_K_ANALYZE || p.peek_at(2) == TK_K_AND || p.peek_at(2) == TK_K_AS || p.peek_at(2) == TK_K_ASC || p.peek_at(2) == TK_K_ATTACH || p.peek_at(2) == TK_K_AUTOINCREMENT || p.peek_at(2) == TK_K_BEFORE || p.peek_at(2) == TK_K_BEGIN || p.peek_at(2) == TK_K_BETWEEN || p.peek_at(2) == TK_K_BY || p.peek_at(2) == TK_K_CASCADE || p.peek_at(2) == TK_K_CASE || p.peek_at(2) == TK_K_CAST || p.peek_at(2) == TK_K_CHECK || p.peek_at(2) == TK_K_COLLATE || p.peek_at(2) == TK_K_COLUMN || p.peek_at(2) == TK_K_COMMIT || p.peek_at(2) == TK_K_CONFLICT || p.peek_at(2) == TK_K_CONSTRAINT || p.peek_at(2) == TK_K_CREATE || p.peek_at(2) == TK_K_CROSS || p.peek_at(2) == TK_K_DATABASE || p.peek_at(2) == TK_K_DEFAULT || p.peek_at(2) == TK_K_DEFERRABLE || p.peek_at(2) == TK_K_DEFERRED || p.peek_at(2) == TK_K_DELETE || p.peek_at(2) == TK_K_DESC || p.peek_at(2) == TK_K_DETACH || p.peek_at(2) == TK_K_DISTINCT || p.peek_at(2) == TK_K_DROP || p.peek_at(2) == TK_K_EACH || p.peek_at(2) == TK_K_ELSE || p.peek_at(2) == TK_K_END || p.peek_at(2) == TK_K_ESCAPE || p.peek_at(2) == TK_K_EXCEPT || p.peek_at(2) == TK_K_EXCLUSIVE || p.peek_at(2) == TK_K_EXISTS || p.peek_at(2) == TK_K_EXPLAIN || p.peek_at(2) == TK_K_FAIL || p.peek_at(2) == TK_K_FOR || p.peek_at(2) == TK_K_FOREIGN || p.peek_at(2) == TK_K_FROM || p.peek_at(2) == TK_K_FULL || p.peek_at(2) == TK_K_GLOB || p.peek_at(2) == TK_K_GROUP || p.peek_at(2) == TK_K_HAVING || p.peek_at(2) == TK_K_IF || p.peek_at(2) == TK_K_IGNORE || p.peek_at(2) == TK_K_IMMEDIATE || p.peek_at(2) == TK_K_IN || p.peek_at(2) == TK_K_INDEX || p.peek_at(2) == TK_K_INDEXED || p.peek_at(2) == TK_K_INITIALLY || p.peek_at(2) == TK_K_INNER || p.peek_at(2) == TK_K_INSERT || p.peek_at(2) == TK_K_INSTEAD || p.peek_at(2) == TK_K_INTERSECT || p.peek_at(2) == TK_K_INTO || p.peek_at(2) == TK_K_IS || p.peek_at(2) == TK_K_ISNULL || p.peek_at(2) == TK_K_JOIN || p.peek_at(2) == TK_K_KEY || p.peek_at(2) == TK_K_LEFT || p.peek_at(2) == TK_K_LIKE || p.peek_at(2) == TK_K_LIMIT || p.peek_at(2) == TK_K_MATCH || p.peek_at(2) == TK_K_NATURAL || p.peek_at(2) == TK_K_NO || p.peek_at(2) == TK_K_NOT || p.peek_at(2) == TK_K_NOTNULL || p.peek_at(2) == TK_K_OF || p.peek_at(2) == TK_K_OFFSET || p.peek_at(2) == TK_K_ON || p.peek_at(2) == TK_K_OR || p.peek_at(2) == TK_K_ORDER || p.peek_at(2) == TK_K_OUTER || p.peek_at(2) == TK_K_PLAN || p.peek_at(2) == TK_K_PRAGMA || p.peek_at(2) == TK_K_PRIMARY || p.peek_at(2) == TK_K_QUERY || p.peek_at(2) == TK_K_RAISE || p.peek_at(2) == TK_K_RECURSIVE || p.peek_at(2) == TK_K_REFERENCES || p.peek_at(2) == TK_K_REGEXP || p.peek_at(2) == TK_K_REINDEX || p.peek_at(2) == TK_K_RELEASE || p.peek_at(2) == TK_K_RENAME || p.peek_at(2) == TK_K_REPLACE || p.peek_at(2) == TK_K_RESTRICT || p.peek_at(2) == TK_K_RIGHT || p.peek_at(2) == TK_K_ROLLBACK || p.peek_at(2) == TK_K_ROW || p.peek_at(2) == TK_K_SAVEPOINT || p.peek_at(2) == TK_K_SELECT || p.peek_at(2) == TK_K_SET || p.peek_at(2) == TK_K_TABLE || p.peek_at(2) == TK_K_TEMP || p.peek_at(2) == TK_K_TEMPORARY || p.peek_at(2) == TK_K_THEN || p.peek_at(2) == TK_K_TO || p.peek_at(2) == TK_K_TRANSACTION || p.peek_at(2) == TK_K_TRIGGER || p.peek_at(2) == TK_K_UNION || p.peek_at(2) == TK_K_UNIQUE || p.peek_at(2) == TK_K_UPDATE || p.peek_at(2) == TK_K_USING || p.peek_at(2) == TK_K_VACUUM || p.peek_at(2) == TK_K_VALUES || p.peek_at(2) == TK_K_VIEW || p.peek_at(2) == TK_K_VIRTUAL || p.peek_at(2) == TK_K_WHEN || p.peek_at(2) == TK_K_WHERE || p.peek_at(2) == TK_K_WITH || p.peek_at(2) == TK_K_WITHOUT || p.peek_at(2) == TK_LIT_LPAREN || p.peek_at(2) == TK_LIT_MINUS || p.peek_at(2) == TK_LIT_PLUS || p.peek_at(2) == TK_LIT_TILDE) && p.peek_at(3) == TK_K_HAVING && (p.peek_at(4) == TK_NUMERIC_LITERAL || p.peek_at(4) == TK_STRING_LITERAL || p.peek_at(4) == TK_BLOB_LITERAL || p.peek_at(4) == TK_K_NULL || p.peek_at(4) == TK_K_CURRENT_TIME || p.peek_at(4) == TK_K_CURRENT_DATE || p.peek_at(4) == TK_K_CURRENT_TIMESTAMP || p.peek_at(4) == TK_BIND_PARAMETER || p.peek_at(4) == TK_IDENTIFIER || p.peek_at(4) == TK_K_ABORT || p.peek_at(4) == TK_K_ACTION || p.peek_at(4) == TK_K_ADD || p.peek_at(4) == TK_K_AFTER || p.peek_at(4) == TK_K_ALL || p.peek_at(4) == TK_K_ALTER || p.peek_at(4) == TK_K_ANALYZE || p.peek_at(4) == TK_K_AND || p.peek_at(4) == TK_K_AS || p.peek_at(4) == TK_K_ASC || p.peek_at(4) == TK_K_ATTACH || p.peek_at(4) == TK_K_AUTOINCREMENT || p.peek_at(4) == TK_K_BEFORE || p.peek_at(4) == TK_K_BEGIN || p.peek_at(4) == TK_K_BETWEEN || p.peek_at(4) == TK_K_BY || p.peek_at(4) == TK_K_CASCADE || p.peek_at(4) == TK_K_CASE || p.peek_at(4) == TK_K_CAST || p.peek_at(4) == TK_K_CHECK || p.peek_at(4) == TK_K_COLLATE || p.peek_at(4) == TK_K_COLUMN || p.peek_at(4) == TK_K_COMMIT || p.peek_at(4) == TK_K_CONFLICT || p.peek_at(4) == TK_K_CONSTRAINT || p.peek_at(4) == TK_K_CREATE || p.peek_at(4) == TK_K_CROSS || p.peek_at(4) == TK_K_DATABASE || p.peek_at(4) == TK_K_DEFAULT || p.peek_at(4) == TK_K_DEFERRABLE || p.peek_at(4) == TK_K_DEFERRED || p.peek_at(4) == TK_K_DELETE || p.peek_at(4) == TK_K_DESC || p.peek_at(4) == TK_K_DETACH || p.peek_at(4) == TK_K_DISTINCT || p.peek_at(4) == TK_K_DROP || p.peek_at(4) == TK_K_EACH || p.peek_at(4) == TK_K_ELSE || p.peek_at(4) == TK_K_END || p.peek_at(4) == TK_K_ESCAPE || p.peek_at(4) == TK_K_EXCEPT || p.peek_at(4) == TK_K_EXCLUSIVE || p.peek_at(4) == TK_K_EXISTS || p.peek_at(4) == TK_K_EXPLAIN || p.peek_at(4) == TK_K_FAIL || p.peek_at(4) == TK_K_FOR || p.peek_at(4) == TK_K_FOREIGN || p.peek_at(4) == TK_K_FROM || p.peek_at(4) == TK_K_FULL || p.peek_at(4) == TK_K_GLOB || p.peek_at(4) == TK_K_GROUP || p.peek_at(4) == TK_K_HAVING || p.peek_at(4) == TK_K_IF || p.peek_at(4) == TK_K_IGNORE || p.peek_at(4) == TK_K_IMMEDIATE || p.peek_at(4) == TK_K_IN || p.peek_at(4) == TK_K_INDEX || p.peek_at(4) == TK_K_INDEXED || p.peek_at(4) == TK_K_INITIALLY || p.peek_at(4) == TK_K_INNER || p.peek_at(4) == TK_K_INSERT || p.peek_at(4) == TK_K_INSTEAD || p.peek_at(4) == TK_K_INTERSECT || p.peek_at(4) == TK_K_INTO || p.peek_at(4) == TK_K_IS || p.peek_at(4) == TK_K_ISNULL || p.peek_at(4) == TK_K_JOIN || p.peek_at(4) == TK_K_KEY || p.peek_at(4) == TK_K_LEFT || p.peek_at(4) == TK_K_LIKE || p.peek_at(4) == TK_K_LIMIT || p.peek_at(4) == TK_K_MATCH || p.peek_at(4) == TK_K_NATURAL || p.peek_at(4) == TK_K_NO || p.peek_at(4) == TK_K_NOT || p.peek_at(4) == TK_K_NOTNULL || p.peek_at(4) == TK_K_OF || p.peek_at(4) == TK_K_OFFSET || p.peek_at(4) == TK_K_ON || p.peek_at(4) == TK_K_OR || p.peek_at(4) == TK_K_ORDER || p.peek_at(4) == TK_K_OUTER || p.peek_at(4) == TK_K_PLAN || p.peek_at(4) == TK_K_PRAGMA || p.peek_at(4) == TK_K_PRIMARY || p.peek_at(4) == TK_K_QUERY || p.peek_at(4) == TK_K_RAISE || p.peek_at(4) == TK_K_RECURSIVE || p.peek_at(4) == TK_K_REFERENCES || p.peek_at(4) == TK_K_REGEXP || p.peek_at(4) == TK_K_REINDEX || p.peek_at(4) == TK_K_RELEASE || p.peek_at(4) == TK_K_RENAME || p.peek_at(4) == TK_K_REPLACE || p.peek_at(4) == TK_K_RESTRICT || p.peek_at(4) == TK_K_RIGHT || p.peek_at(4) == TK_K_ROLLBACK || p.peek_at(4) == TK_K_ROW || p.peek_at(4) == TK_K_SAVEPOINT || p.peek_at(4) == TK_K_SELECT || p.peek_at(4) == TK_K_SET || p.peek_at(4) == TK_K_TABLE || p.peek_at(4) == TK_K_TEMP || p.peek_at(4) == TK_K_TEMPORARY || p.peek_at(4) == TK_K_THEN || p.peek_at(4) == TK_K_TO || p.peek_at(4) == TK_K_TRANSACTION || p.peek_at(4) == TK_K_TRIGGER || p.peek_at(4) == TK_K_UNION || p.peek_at(4) == TK_K_UNIQUE || p.peek_at(4) == TK_K_UPDATE || p.peek_at(4) == TK_K_USING || p.peek_at(4) == TK_K_VACUUM || p.peek_at(4) == TK_K_VALUES || p.peek_at(4) == TK_K_VIEW || p.peek_at(4) == TK_K_VIRTUAL || p.peek_at(4) == TK_K_WHEN || p.peek_at(4) == TK_K_WHERE || p.peek_at(4) == TK_K_WITH || p.peek_at(4) == TK_K_WITHOUT || p.peek_at(4) == TK_LIT_LPAREN || p.peek_at(4) == TK_LIT_MINUS || p.peek_at(4) == TK_LIT_PLUS || p.peek_at(4) == TK_LIT_TILDE) { - let tok_9 = p.expect(TK_K_GROUP, "K_GROUP")?; - let tok_10 = p.expect(TK_K_BY, "K_BY")?; - let tok_11 = parse_expr(p)?; - let tok_12 = p.expect(TK_K_HAVING, "K_HAVING")?; - let tok_13 = parse_expr(p)?; + let k_group = p.expect(TK_K_GROUP, "K_GROUP")?; + let k_by = p.expect(TK_K_BY, "K_BY")?; + let expr = parse_expr(p)?; + let k_having = p.expect(TK_K_HAVING, "K_HAVING")?; + let expr_2 = parse_expr(p)?; } else if p.peek_kind() == TK_K_GROUP && p.peek_at(1) == TK_K_BY && (p.peek_at(2) == TK_NUMERIC_LITERAL || p.peek_at(2) == TK_STRING_LITERAL || p.peek_at(2) == TK_BLOB_LITERAL || p.peek_at(2) == TK_K_NULL || p.peek_at(2) == TK_K_CURRENT_TIME || p.peek_at(2) == TK_K_CURRENT_DATE || p.peek_at(2) == TK_K_CURRENT_TIMESTAMP || p.peek_at(2) == TK_BIND_PARAMETER || p.peek_at(2) == TK_IDENTIFIER || p.peek_at(2) == TK_K_ABORT || p.peek_at(2) == TK_K_ACTION || p.peek_at(2) == TK_K_ADD || p.peek_at(2) == TK_K_AFTER || p.peek_at(2) == TK_K_ALL || p.peek_at(2) == TK_K_ALTER || p.peek_at(2) == TK_K_ANALYZE || p.peek_at(2) == TK_K_AND || p.peek_at(2) == TK_K_AS || p.peek_at(2) == TK_K_ASC || p.peek_at(2) == TK_K_ATTACH || p.peek_at(2) == TK_K_AUTOINCREMENT || p.peek_at(2) == TK_K_BEFORE || p.peek_at(2) == TK_K_BEGIN || p.peek_at(2) == TK_K_BETWEEN || p.peek_at(2) == TK_K_BY || p.peek_at(2) == TK_K_CASCADE || p.peek_at(2) == TK_K_CASE || p.peek_at(2) == TK_K_CAST || p.peek_at(2) == TK_K_CHECK || p.peek_at(2) == TK_K_COLLATE || p.peek_at(2) == TK_K_COLUMN || p.peek_at(2) == TK_K_COMMIT || p.peek_at(2) == TK_K_CONFLICT || p.peek_at(2) == TK_K_CONSTRAINT || p.peek_at(2) == TK_K_CREATE || p.peek_at(2) == TK_K_CROSS || p.peek_at(2) == TK_K_DATABASE || p.peek_at(2) == TK_K_DEFAULT || p.peek_at(2) == TK_K_DEFERRABLE || p.peek_at(2) == TK_K_DEFERRED || p.peek_at(2) == TK_K_DELETE || p.peek_at(2) == TK_K_DESC || p.peek_at(2) == TK_K_DETACH || p.peek_at(2) == TK_K_DISTINCT || p.peek_at(2) == TK_K_DROP || p.peek_at(2) == TK_K_EACH || p.peek_at(2) == TK_K_ELSE || p.peek_at(2) == TK_K_END || p.peek_at(2) == TK_K_ESCAPE || p.peek_at(2) == TK_K_EXCEPT || p.peek_at(2) == TK_K_EXCLUSIVE || p.peek_at(2) == TK_K_EXISTS || p.peek_at(2) == TK_K_EXPLAIN || p.peek_at(2) == TK_K_FAIL || p.peek_at(2) == TK_K_FOR || p.peek_at(2) == TK_K_FOREIGN || p.peek_at(2) == TK_K_FROM || p.peek_at(2) == TK_K_FULL || p.peek_at(2) == TK_K_GLOB || p.peek_at(2) == TK_K_GROUP || p.peek_at(2) == TK_K_HAVING || p.peek_at(2) == TK_K_IF || p.peek_at(2) == TK_K_IGNORE || p.peek_at(2) == TK_K_IMMEDIATE || p.peek_at(2) == TK_K_IN || p.peek_at(2) == TK_K_INDEX || p.peek_at(2) == TK_K_INDEXED || p.peek_at(2) == TK_K_INITIALLY || p.peek_at(2) == TK_K_INNER || p.peek_at(2) == TK_K_INSERT || p.peek_at(2) == TK_K_INSTEAD || p.peek_at(2) == TK_K_INTERSECT || p.peek_at(2) == TK_K_INTO || p.peek_at(2) == TK_K_IS || p.peek_at(2) == TK_K_ISNULL || p.peek_at(2) == TK_K_JOIN || p.peek_at(2) == TK_K_KEY || p.peek_at(2) == TK_K_LEFT || p.peek_at(2) == TK_K_LIKE || p.peek_at(2) == TK_K_LIMIT || p.peek_at(2) == TK_K_MATCH || p.peek_at(2) == TK_K_NATURAL || p.peek_at(2) == TK_K_NO || p.peek_at(2) == TK_K_NOT || p.peek_at(2) == TK_K_NOTNULL || p.peek_at(2) == TK_K_OF || p.peek_at(2) == TK_K_OFFSET || p.peek_at(2) == TK_K_ON || p.peek_at(2) == TK_K_OR || p.peek_at(2) == TK_K_ORDER || p.peek_at(2) == TK_K_OUTER || p.peek_at(2) == TK_K_PLAN || p.peek_at(2) == TK_K_PRAGMA || p.peek_at(2) == TK_K_PRIMARY || p.peek_at(2) == TK_K_QUERY || p.peek_at(2) == TK_K_RAISE || p.peek_at(2) == TK_K_RECURSIVE || p.peek_at(2) == TK_K_REFERENCES || p.peek_at(2) == TK_K_REGEXP || p.peek_at(2) == TK_K_REINDEX || p.peek_at(2) == TK_K_RELEASE || p.peek_at(2) == TK_K_RENAME || p.peek_at(2) == TK_K_REPLACE || p.peek_at(2) == TK_K_RESTRICT || p.peek_at(2) == TK_K_RIGHT || p.peek_at(2) == TK_K_ROLLBACK || p.peek_at(2) == TK_K_ROW || p.peek_at(2) == TK_K_SAVEPOINT || p.peek_at(2) == TK_K_SELECT || p.peek_at(2) == TK_K_SET || p.peek_at(2) == TK_K_TABLE || p.peek_at(2) == TK_K_TEMP || p.peek_at(2) == TK_K_TEMPORARY || p.peek_at(2) == TK_K_THEN || p.peek_at(2) == TK_K_TO || p.peek_at(2) == TK_K_TRANSACTION || p.peek_at(2) == TK_K_TRIGGER || p.peek_at(2) == TK_K_UNION || p.peek_at(2) == TK_K_UNIQUE || p.peek_at(2) == TK_K_UPDATE || p.peek_at(2) == TK_K_USING || p.peek_at(2) == TK_K_VACUUM || p.peek_at(2) == TK_K_VALUES || p.peek_at(2) == TK_K_VIEW || p.peek_at(2) == TK_K_VIRTUAL || p.peek_at(2) == TK_K_WHEN || p.peek_at(2) == TK_K_WHERE || p.peek_at(2) == TK_K_WITH || p.peek_at(2) == TK_K_WITHOUT || p.peek_at(2) == TK_LIT_LPAREN || p.peek_at(2) == TK_LIT_MINUS || p.peek_at(2) == TK_LIT_PLUS || p.peek_at(2) == TK_LIT_TILDE) && p.peek_at(3) == TK_LIT_COMMA { - let tok_14 = p.expect(TK_K_GROUP, "K_GROUP")?; - let tok_15 = p.expect(TK_K_BY, "K_BY")?; - let tok_16 = parse_expr(p)?; + let k_group = p.expect(TK_K_GROUP, "K_GROUP")?; + let k_by = p.expect(TK_K_BY, "K_BY")?; + let expr = parse_expr(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let expr = parse_expr(p)?; } } else if p.peek_kind() == TK_K_GROUP && p.peek_at(1) == TK_K_BY && (p.peek_at(2) == TK_NUMERIC_LITERAL || p.peek_at(2) == TK_STRING_LITERAL || p.peek_at(2) == TK_BLOB_LITERAL || p.peek_at(2) == TK_K_NULL || p.peek_at(2) == TK_K_CURRENT_TIME || p.peek_at(2) == TK_K_CURRENT_DATE || p.peek_at(2) == TK_K_CURRENT_TIMESTAMP || p.peek_at(2) == TK_BIND_PARAMETER || p.peek_at(2) == TK_IDENTIFIER || p.peek_at(2) == TK_K_ABORT || p.peek_at(2) == TK_K_ACTION || p.peek_at(2) == TK_K_ADD || p.peek_at(2) == TK_K_AFTER || p.peek_at(2) == TK_K_ALL || p.peek_at(2) == TK_K_ALTER || p.peek_at(2) == TK_K_ANALYZE || p.peek_at(2) == TK_K_AND || p.peek_at(2) == TK_K_AS || p.peek_at(2) == TK_K_ASC || p.peek_at(2) == TK_K_ATTACH || p.peek_at(2) == TK_K_AUTOINCREMENT || p.peek_at(2) == TK_K_BEFORE || p.peek_at(2) == TK_K_BEGIN || p.peek_at(2) == TK_K_BETWEEN || p.peek_at(2) == TK_K_BY || p.peek_at(2) == TK_K_CASCADE || p.peek_at(2) == TK_K_CASE || p.peek_at(2) == TK_K_CAST || p.peek_at(2) == TK_K_CHECK || p.peek_at(2) == TK_K_COLLATE || p.peek_at(2) == TK_K_COLUMN || p.peek_at(2) == TK_K_COMMIT || p.peek_at(2) == TK_K_CONFLICT || p.peek_at(2) == TK_K_CONSTRAINT || p.peek_at(2) == TK_K_CREATE || p.peek_at(2) == TK_K_CROSS || p.peek_at(2) == TK_K_DATABASE || p.peek_at(2) == TK_K_DEFAULT || p.peek_at(2) == TK_K_DEFERRABLE || p.peek_at(2) == TK_K_DEFERRED || p.peek_at(2) == TK_K_DELETE || p.peek_at(2) == TK_K_DESC || p.peek_at(2) == TK_K_DETACH || p.peek_at(2) == TK_K_DISTINCT || p.peek_at(2) == TK_K_DROP || p.peek_at(2) == TK_K_EACH || p.peek_at(2) == TK_K_ELSE || p.peek_at(2) == TK_K_END || p.peek_at(2) == TK_K_ESCAPE || p.peek_at(2) == TK_K_EXCEPT || p.peek_at(2) == TK_K_EXCLUSIVE || p.peek_at(2) == TK_K_EXISTS || p.peek_at(2) == TK_K_EXPLAIN || p.peek_at(2) == TK_K_FAIL || p.peek_at(2) == TK_K_FOR || p.peek_at(2) == TK_K_FOREIGN || p.peek_at(2) == TK_K_FROM || p.peek_at(2) == TK_K_FULL || p.peek_at(2) == TK_K_GLOB || p.peek_at(2) == TK_K_GROUP || p.peek_at(2) == TK_K_HAVING || p.peek_at(2) == TK_K_IF || p.peek_at(2) == TK_K_IGNORE || p.peek_at(2) == TK_K_IMMEDIATE || p.peek_at(2) == TK_K_IN || p.peek_at(2) == TK_K_INDEX || p.peek_at(2) == TK_K_INDEXED || p.peek_at(2) == TK_K_INITIALLY || p.peek_at(2) == TK_K_INNER || p.peek_at(2) == TK_K_INSERT || p.peek_at(2) == TK_K_INSTEAD || p.peek_at(2) == TK_K_INTERSECT || p.peek_at(2) == TK_K_INTO || p.peek_at(2) == TK_K_IS || p.peek_at(2) == TK_K_ISNULL || p.peek_at(2) == TK_K_JOIN || p.peek_at(2) == TK_K_KEY || p.peek_at(2) == TK_K_LEFT || p.peek_at(2) == TK_K_LIKE || p.peek_at(2) == TK_K_LIMIT || p.peek_at(2) == TK_K_MATCH || p.peek_at(2) == TK_K_NATURAL || p.peek_at(2) == TK_K_NO || p.peek_at(2) == TK_K_NOT || p.peek_at(2) == TK_K_NOTNULL || p.peek_at(2) == TK_K_OF || p.peek_at(2) == TK_K_OFFSET || p.peek_at(2) == TK_K_ON || p.peek_at(2) == TK_K_OR || p.peek_at(2) == TK_K_ORDER || p.peek_at(2) == TK_K_OUTER || p.peek_at(2) == TK_K_PLAN || p.peek_at(2) == TK_K_PRAGMA || p.peek_at(2) == TK_K_PRIMARY || p.peek_at(2) == TK_K_QUERY || p.peek_at(2) == TK_K_RAISE || p.peek_at(2) == TK_K_RECURSIVE || p.peek_at(2) == TK_K_REFERENCES || p.peek_at(2) == TK_K_REGEXP || p.peek_at(2) == TK_K_REINDEX || p.peek_at(2) == TK_K_RELEASE || p.peek_at(2) == TK_K_RENAME || p.peek_at(2) == TK_K_REPLACE || p.peek_at(2) == TK_K_RESTRICT || p.peek_at(2) == TK_K_RIGHT || p.peek_at(2) == TK_K_ROLLBACK || p.peek_at(2) == TK_K_ROW || p.peek_at(2) == TK_K_SAVEPOINT || p.peek_at(2) == TK_K_SELECT || p.peek_at(2) == TK_K_SET || p.peek_at(2) == TK_K_TABLE || p.peek_at(2) == TK_K_TEMP || p.peek_at(2) == TK_K_TEMPORARY || p.peek_at(2) == TK_K_THEN || p.peek_at(2) == TK_K_TO || p.peek_at(2) == TK_K_TRANSACTION || p.peek_at(2) == TK_K_TRIGGER || p.peek_at(2) == TK_K_UNION || p.peek_at(2) == TK_K_UNIQUE || p.peek_at(2) == TK_K_UPDATE || p.peek_at(2) == TK_K_USING || p.peek_at(2) == TK_K_VACUUM || p.peek_at(2) == TK_K_VALUES || p.peek_at(2) == TK_K_VIEW || p.peek_at(2) == TK_K_VIRTUAL || p.peek_at(2) == TK_K_WHEN || p.peek_at(2) == TK_K_WHERE || p.peek_at(2) == TK_K_WITH || p.peek_at(2) == TK_K_WITHOUT || p.peek_at(2) == TK_LIT_LPAREN || p.peek_at(2) == TK_LIT_MINUS || p.peek_at(2) == TK_LIT_PLUS || p.peek_at(2) == TK_LIT_TILDE) { - let tok_17 = p.expect(TK_K_GROUP, "K_GROUP")?; - let tok_18 = p.expect(TK_K_BY, "K_BY")?; - let tok_19 = parse_expr(p)?; + let k_group = p.expect(TK_K_GROUP, "K_GROUP")?; + let k_by = p.expect(TK_K_BY, "K_BY")?; + let expr = parse_expr(p)?; } return Result::::Ok(SelectCoreNode::Alt0(SelectCoreAlt0 { span: Span::new(start, p.last_end()), @@ -9685,19 +9713,19 @@ fn parse_select_core(p: &mut Parser) -> Result { let lparen = p.expect(TK_LIT_LPAREN, "'('")?; let expr = parse_expr(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let expr = parse_expr(p)?; } let rparen = p.expect(TK_LIT_RPAREN, "')'")?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = p.expect(TK_LIT_LPAREN, "'('")?; - let tok_3 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let lparen = p.expect(TK_LIT_LPAREN, "'('")?; + let expr = parse_expr(p)?; while p.peek_kind() == TK_LIT_COMMA { - let tok = p.expect(TK_LIT_COMMA, "','")?; - let tok_2 = parse_expr(p)?; + let comma = p.expect(TK_LIT_COMMA, "','")?; + let expr = parse_expr(p)?; } - let tok_4 = p.expect(TK_LIT_RPAREN, "')'")?; + let rparen = p.expect(TK_LIT_RPAREN, "')'")?; } return Result::::Ok(SelectCoreNode::Alt1(SelectCoreAlt1 { span: Span::new(start, p.last_end()), @@ -9776,9 +9804,9 @@ fn parse_signed_number(p: &mut Parser) -> Result { opt_bt: { let grp_kind = p.peek_kind(); if grp_kind == TK_LIT_PLUS { - let tok = p.expect(TK_LIT_PLUS, "'+'")?; + let plus = p.expect(TK_LIT_PLUS, "'+'")?; } else if grp_kind == TK_LIT_MINUS { - let tok_2 = p.expect(TK_LIT_MINUS, "'-'")?; + let minus = p.expect(TK_LIT_MINUS, "'-'")?; } } }