Skip to content

Fix global constant patterns in match/matches expressions #754

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
gfx merged 6 commits into from
Apr 2, 2026
Merged

Fix global constant patterns in match/matches expressions #754

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
471e027
feat: support immutable globals and associated constants as match pat…
claude Apr 2, 2026
651455b
refactor(gale): use match/matches with global constant patterns in ge…
claude Apr 2, 2026
99f114a
fix: panic on unlowered ConstantValue patterns instead of silently pr…
claude Apr 2, 2026
e700116
fix: prevent matches pattern bare idents from shadowing global constants
claude Apr 2, 2026
41f590f
chore: apply formatting and golden fixture updates from on-task-done
claude Apr 2, 2026
270830f
chore: regenerate golden fixture for match_global_constant_pattern
claude Apr 2, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
33 changes: 23 additions & 10 deletions package-gale/src/lexer_gen.wado
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -409,13 +409,24 @@ fn gen_tokenize_fn(w: &mut CodeWriter, lexer_rules: &Array<LexerRule>, lit_token
w.line("lexer.pos = start + 1;");
w.else_begin("else");

w.write("let is_skip = false");
let mut skip_names: Array<String> = [];
for let rule of lexer_rules {
if rule.skip {
w.write(` || best_kind == TK_{rule.name}`);
skip_names.push(`TK_{rule.name}`);
}
}
w.write(";\n");
if skip_names.is_empty() {
w.line("let is_skip = false;");
} else {
w.write("let is_skip = best_kind matches { ");
for let mut i = 0; i < skip_names.len(); i += 1 {
if i > 0 {
w.write(" | ");
}
w.write(&skip_names[i]);
}
w.write(" };\n");
}

w.begin("if is_skip");
w.line("trivia.push(Token::new(best_kind, lexer.slice(start, best_end), Span::new(start, best_end)));");
Expand All @@ -440,20 +451,22 @@ fn gen_token_kind_name_fn(w: &mut CodeWriter, lexer_rules: &Array<LexerRule>, li
f.set_return_type("String");
f.emit_begin(w);

w.line("return match kind {");
w.indent();
for let rule of lexer_rules {
if !rule.is_fragment {
w.line(`if kind == TK_{rule.name} \{ return "{rule.name}"; \}`);
w.line(`TK_{rule.name} => "{rule.name}",`);
}
}
w.line("if kind == TK_EOF { return \"Eof\"; }");
w.line("if kind == TK_ERROR { return \"Error\"; }");

w.line("TK_EOF => \"Eof\",");
w.line("TK_ERROR => \"Error\",");
for let lit of lit_tokens {
let name = lit.const_name;
w.line(`if kind == {name} \{ return "{name}"; \}`);
w.line(`{name} => "{name}",`);
}

w.line("return \"Unknown\";");
w.line("_ => \"Unknown\",");
w.dedent();
w.line("};");
w.end(); // fn
w.blank();
}
17 changes: 11 additions & 6 deletions package-gale/src/parser_gen.wado
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3266,13 +3266,18 @@ fn kind_check_str(tokens: &Array<String>, expr: &String) -> String {
if tokens.len() == 0 {
return "true";
}
if tokens.len() == 1 {
return `{expr} == {tokens[0]}`;
}
let mut result = String::with_capacity(64);
result.push_str(`{expr} matches \{ `);
for let mut i = 0; i < tokens.len(); i += 1 {
if i > 0 {
result.push_str(" || ");
result.push_str(" | ");
}
result.push_str(`{expr} == {tokens[i]}`);
result.push_str(&tokens[i]);
}
result.push_str(" }");
return result;
}

Expand All @@ -3287,14 +3292,14 @@ fn build_lookahead_condition(pos_sets: &Array<Array<String>>, depth: i32) -> Str
if tokens.len() == 1 {
cond.push_str(`{check_expr} == {tokens[0]}`);
} else {
cond.push_str("(");
cond.push_str(`{check_expr} matches \{ `);
for let mut j = 0; j < tokens.len(); j += 1 {
if j > 0 {
cond.push_str(" || ");
cond.push_str(" | ");
}
cond.push_str(`{check_expr} == {tokens[j]}`);
cond.push_str(&tokens[j]);
}
cond.push_str(")");
cond.push_str(" }");
}
}
return cond;
Expand Down
74 changes: 38 additions & 36 deletions package-gale/tests/golden/calculator.wado
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -953,7 +953,7 @@ pub fn tokenize(input: &String) -> Array<Token> {
trivia = [];
lexer.pos = start + 1;
} else {
let is_skip = false || best_kind == TK_WS;
let is_skip = best_kind matches { TK_WS };
if is_skip {
trivia.push(Token::new(best_kind, lexer.slice(start, best_end), Span::new(start, best_end)));
} else {
Expand All @@ -969,36 +969,38 @@ pub fn tokenize(input: &String) -> Array<Token> {
}

pub fn token_kind_name(kind: i32) -> String {
if kind == TK_COS { return "COS"; }
if kind == TK_SIN { return "SIN"; }
if kind == TK_TAN { return "TAN"; }
if kind == TK_ACOS { return "ACOS"; }
if kind == TK_ASIN { return "ASIN"; }
if kind == TK_ATAN { return "ATAN"; }
if kind == TK_LN { return "LN"; }
if kind == TK_LOG { return "LOG"; }
if kind == TK_SQRT { return "SQRT"; }
if kind == TK_LPAREN { return "LPAREN"; }
if kind == TK_RPAREN { return "RPAREN"; }
if kind == TK_PLUS { return "PLUS"; }
if kind == TK_MINUS { return "MINUS"; }
if kind == TK_TIMES { return "TIMES"; }
if kind == TK_DIV { return "DIV"; }
if kind == TK_GT { return "GT"; }
if kind == TK_LT { return "LT"; }
if kind == TK_EQ { return "EQ"; }
if kind == TK_COMMA { return "COMMA"; }
if kind == TK_POINT { return "POINT"; }
if kind == TK_POW { return "POW"; }
if kind == TK_PI { return "PI"; }
if kind == TK_EULER { return "EULER"; }
if kind == TK_I { return "I"; }
if kind == TK_VARIABLE { return "VARIABLE"; }
if kind == TK_SCIENTIFIC_NUMBER { return "SCIENTIFIC_NUMBER"; }
if kind == TK_WS { return "WS"; }
if kind == TK_EOF { return "Eof"; }
if kind == TK_ERROR { return "Error"; }
return "Unknown";
return match kind {
TK_COS => "COS",
TK_SIN => "SIN",
TK_TAN => "TAN",
TK_ACOS => "ACOS",
TK_ASIN => "ASIN",
TK_ATAN => "ATAN",
TK_LN => "LN",
TK_LOG => "LOG",
TK_SQRT => "SQRT",
TK_LPAREN => "LPAREN",
TK_RPAREN => "RPAREN",
TK_PLUS => "PLUS",
TK_MINUS => "MINUS",
TK_TIMES => "TIMES",
TK_DIV => "DIV",
TK_GT => "GT",
TK_LT => "LT",
TK_EQ => "EQ",
TK_COMMA => "COMMA",
TK_POINT => "POINT",
TK_POW => "POW",
TK_PI => "PI",
TK_EULER => "EULER",
TK_I => "I",
TK_VARIABLE => "VARIABLE",
TK_SCIENTIFIC_NUMBER => "SCIENTIFIC_NUMBER",
TK_WS => "WS",
TK_EOF => "Eof",
TK_ERROR => "Error",
_ => "Unknown",
};
}

struct Parser {
Expand Down Expand Up @@ -1068,7 +1070,7 @@ fn parse_expression(p: &mut Parser) -> Result<ExpressionNode, ParseError> {
let start = p.peek().span.start;
let multiplying_expression = parse_multiplying_expression(p)?;
let mut item_multiplying_expression_list: Array<ItemMultiplyingExpressionItem> = [];
while p.peek_kind() == TK_PLUS || p.peek_kind() == TK_MINUS {
while p.peek_kind() matches { TK_PLUS | TK_MINUS } {
let plus_or_minus = p.advance();
let multiplying_expression = parse_multiplying_expression(p)?;
let item_multiplying_expression = ItemMultiplyingExpressionItem {
Expand All @@ -1088,7 +1090,7 @@ fn parse_multiplying_expression(p: &mut Parser) -> Result<MultiplyingExpressionN
let start = p.peek().span.start;
let pow_expression = parse_pow_expression(p)?;
let mut item_pow_expression_list: Array<ItemPowExpressionItem> = [];
while p.peek_kind() == TK_TIMES || p.peek_kind() == TK_DIV {
while p.peek_kind() matches { TK_TIMES | TK_DIV } {
let times_or_div = p.advance();
let pow_expression = parse_pow_expression(p)?;
let item_pow_expression = ItemPowExpressionItem {
Expand Down Expand Up @@ -1145,14 +1147,14 @@ fn parse_signed_atom(p: &mut Parser) -> Result<SignedAtomNode, ParseError> {
signed_atom,
}));
}
if (kind == TK_COS || kind == TK_TAN || kind == TK_SIN || kind == TK_ACOS || kind == TK_ATAN || kind == TK_ASIN || kind == TK_LOG || kind == TK_LN || kind == TK_SQRT) {
if kind matches { TK_COS | TK_TAN | TK_SIN | TK_ACOS | TK_ATAN | TK_ASIN | TK_LOG | TK_LN | TK_SQRT } {
let func_ = parse_func_(p)?;
return Result::<SignedAtomNode, ParseError>::Ok(SignedAtomNode::Alt2(SignedAtomAlt2 {
span: Span::new(start, p.last_end()),
func_,
}));
}
if (kind == TK_SCIENTIFIC_NUMBER || kind == TK_VARIABLE || kind == TK_PI || kind == TK_EULER || kind == TK_I || kind == TK_LPAREN) {
if kind matches { TK_SCIENTIFIC_NUMBER | TK_VARIABLE | TK_PI | TK_EULER | TK_I | TK_LPAREN } {
let atom = parse_atom(p)?;
return Result::<SignedAtomNode, ParseError>::Ok(SignedAtomNode::Alt3(SignedAtomAlt3 {
span: Span::new(start, p.last_end()),
Expand Down Expand Up @@ -1183,7 +1185,7 @@ fn parse_atom(p: &mut Parser) -> Result<AtomNode, ParseError> {
variable,
}));
}
if (kind == TK_PI || kind == TK_EULER || kind == TK_I) {
if kind matches { TK_PI | TK_EULER | TK_I } {
let constant = parse_constant(p)?;
return Result::<AtomNode, ParseError>::Ok(AtomNode::Alt2(AtomAlt2 {
span: Span::new(start, p.last_end()),
Expand Down
36 changes: 19 additions & 17 deletions package-gale/tests/golden/json.wado
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -588,7 +588,7 @@ pub fn tokenize(input: &String) -> Array<Token> {
trivia = [];
lexer.pos = start + 1;
} else {
let is_skip = false || best_kind == TK_WS;
let is_skip = best_kind matches { TK_WS };
if is_skip {
trivia.push(Token::new(best_kind, lexer.slice(start, best_end), Span::new(start, best_end)));
} else {
Expand All @@ -604,21 +604,23 @@ pub fn tokenize(input: &String) -> Array<Token> {
}

pub fn token_kind_name(kind: i32) -> String {
if kind == TK_STRING { return "STRING"; }
if kind == TK_NUMBER { return "NUMBER"; }
if kind == TK_WS { return "WS"; }
if kind == TK_EOF { return "Eof"; }
if kind == TK_ERROR { return "Error"; }
if kind == TK_LIT_LBRACE { return "TK_LIT_LBRACE"; }
if kind == TK_LIT_COMMA { return "TK_LIT_COMMA"; }
if kind == TK_LIT_RBRACE { return "TK_LIT_RBRACE"; }
if kind == TK_LIT_COLON { return "TK_LIT_COLON"; }
if kind == TK_LIT_LBRACKET { return "TK_LIT_LBRACKET"; }
if kind == TK_LIT_RBRACKET { return "TK_LIT_RBRACKET"; }
if kind == TK_LIT_TRUE { return "TK_LIT_TRUE"; }
if kind == TK_LIT_FALSE { return "TK_LIT_FALSE"; }
if kind == TK_LIT_NULL { return "TK_LIT_NULL"; }
return "Unknown";
return match kind {
TK_STRING => "STRING",
TK_NUMBER => "NUMBER",
TK_WS => "WS",
TK_EOF => "Eof",
TK_ERROR => "Error",
TK_LIT_LBRACE => "TK_LIT_LBRACE",
TK_LIT_COMMA => "TK_LIT_COMMA",
TK_LIT_RBRACE => "TK_LIT_RBRACE",
TK_LIT_COLON => "TK_LIT_COLON",
TK_LIT_LBRACKET => "TK_LIT_LBRACKET",
TK_LIT_RBRACKET => "TK_LIT_RBRACKET",
TK_LIT_TRUE => "TK_LIT_TRUE",
TK_LIT_FALSE => "TK_LIT_FALSE",
TK_LIT_NULL => "TK_LIT_NULL",
_ => "Unknown",
};
}

struct Parser {
Expand Down Expand Up @@ -809,7 +811,7 @@ fn parse_arr(p: &mut Parser) -> Result<ArrNode, ParseError> {
let kind = p.peek_kind();
if kind == TK_LIT_LBRACKET {
let lbracket = p.expect(TK_LIT_LBRACKET, "'['")?;
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 {
if p.peek_kind() matches { TK_STRING | TK_NUMBER | TK_LIT_LBRACE | TK_LIT_LBRACKET | TK_LIT_TRUE | TK_LIT_FALSE | TK_LIT_NULL } {
let value = parse_value(p)?;
let mut comma_value_list: Array<CommaValueItem> = [];
while p.peek_kind() == TK_LIT_COMMA {
Expand Down
30 changes: 16 additions & 14 deletions package-gale/tests/golden/sexpression.wado
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -654,7 +654,7 @@ pub fn tokenize(input: &String) -> Array<Token> {
trivia = [];
lexer.pos = start + 1;
} else {
let is_skip = false || best_kind == TK_WHITESPACE;
let is_skip = best_kind matches { TK_WHITESPACE };
if is_skip {
trivia.push(Token::new(best_kind, lexer.slice(start, best_end), Span::new(start, best_end)));
} else {
Expand All @@ -670,16 +670,18 @@ pub fn tokenize(input: &String) -> Array<Token> {
}

pub fn token_kind_name(kind: i32) -> String {
if kind == TK_STRING { return "STRING"; }
if kind == TK_WHITESPACE { return "WHITESPACE"; }
if kind == TK_NUMBER { return "NUMBER"; }
if kind == TK_SYMBOL { return "SYMBOL"; }
if kind == TK_LPAREN { return "LPAREN"; }
if kind == TK_RPAREN { return "RPAREN"; }
if kind == TK_DOT { return "DOT"; }
if kind == TK_EOF { return "Eof"; }
if kind == TK_ERROR { return "Error"; }
return "Unknown";
return match kind {
TK_STRING => "STRING",
TK_WHITESPACE => "WHITESPACE",
TK_NUMBER => "NUMBER",
TK_SYMBOL => "SYMBOL",
TK_LPAREN => "LPAREN",
TK_RPAREN => "RPAREN",
TK_DOT => "DOT",
TK_EOF => "Eof",
TK_ERROR => "Error",
_ => "Unknown",
};
}

struct Parser {
Expand Down Expand Up @@ -733,7 +735,7 @@ impl Parser {
fn parse_sexpr(p: &mut Parser) -> Result<SexprNode, ParseError> {
let start = p.peek().span.start;
let mut item_list: Array<ItemNode> = [];
while p.peek_kind() == TK_STRING || p.peek_kind() == TK_SYMBOL || p.peek_kind() == TK_NUMBER || p.peek_kind() == TK_DOT || p.peek_kind() == TK_LPAREN {
while p.peek_kind() matches { TK_STRING | TK_SYMBOL | TK_NUMBER | TK_DOT | TK_LPAREN } {
let item = parse_item(p)?;
item_list.push(item);
}
Expand Down Expand Up @@ -774,7 +776,7 @@ fn parse_item_bt_1(p: &mut Parser) -> Result<ItemNode, ParseError> {
fn parse_item(p: &mut Parser) -> Result<ItemNode, ParseError> {
let start = p.peek().span.start;
let kind = p.peek_kind();
if kind == TK_STRING || kind == TK_SYMBOL || kind == TK_NUMBER || kind == TK_DOT {
if kind matches { TK_STRING | TK_SYMBOL | TK_NUMBER | TK_DOT } {
let atom = parse_atom(p)?;
return Result::<ItemNode, ParseError>::Ok(ItemNode::Alt0(ItemAlt0 {
span: Span::new(start, p.last_end()),
Expand Down Expand Up @@ -804,7 +806,7 @@ fn parse_list_(p: &mut Parser) -> Result<ListNode, ParseError> {
let start = p.peek().span.start;
let lparen = p.expect(TK_LPAREN, "LPAREN")?;
let mut item_list: Array<ItemNode> = [];
while p.peek_kind() == TK_STRING || p.peek_kind() == TK_SYMBOL || p.peek_kind() == TK_NUMBER || p.peek_kind() == TK_DOT || p.peek_kind() == TK_LPAREN {
while p.peek_kind() matches { TK_STRING | TK_SYMBOL | TK_NUMBER | TK_DOT | TK_LPAREN } {
let item = parse_item(p)?;
item_list.push(item);
}
Expand Down
Loading
Loading