From 1bb744dbb467e652cd4280001096455be771f141 Mon Sep 17 00:00:00 2001 From: Rohan Kumar Date: Sat, 25 Apr 2026 21:15:23 -0700 Subject: [PATCH 1/6] fix(compiler): fix lang server cell parsing --- core/lang-server/src/lib.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/core/lang-server/src/lib.rs b/core/lang-server/src/lib.rs index 61225b2..8b8f4c2 100644 --- a/core/lang-server/src/lib.rs +++ b/core/lang-server/src/lib.rs @@ -179,8 +179,7 @@ impl StateMut { static_output.errors.extend(parse_errs); Some(CompileOutput::StaticErrors(static_output)) } else if let Some(cell) = &self.cell { - let input = parse::format_cell_input(cell); - match parse::parse_cell(&input) { + match parse::parse_cell(cell) { Ok(cell_ast) => { let cell_path = cell_ast .func From c0e922d1de315e6bbe4ee08e627a74909ae8becb Mon Sep 17 00:00:00 2001 From: Rohan Kumar Date: Sat, 25 Apr 2026 22:11:57 -0700 Subject: [PATCH 2/6] fix precedence --- core/compiler/grammar/Argon.g4 | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/compiler/grammar/Argon.g4 b/core/compiler/grammar/Argon.g4 index e98b544..46aeeca 100644 --- a/core/compiler/grammar/Argon.g4 +++ b/core/compiler/grammar/Argon.g4 @@ -155,7 +155,8 @@ matchArm ; nonBlockExpr - : BANG nonBlockExpr + : LPAREN expr RPAREN + | BANG nonBlockExpr | MINUS nonBlockExpr | nonBlockExpr DOT ident | nonBlockExpr DOT intLiteral @@ -168,7 +169,6 @@ nonBlockExpr | nilLiteral | seqNilLiteral | tupleExpr - | LPAREN expr RPAREN | callExpr | identPath | literal From a282006d95659dcd8be2e4030ba041f90f474792 Mon Sep 17 00:00:00 2001 From: Rohan Kumar Date: Sat, 25 Apr 2026 22:18:03 -0700 Subject: [PATCH 3/6] revert precedence change --- core/compiler/grammar/Argon.g4 | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/compiler/grammar/Argon.g4 b/core/compiler/grammar/Argon.g4 index 46aeeca..e98b544 100644 --- a/core/compiler/grammar/Argon.g4 +++ b/core/compiler/grammar/Argon.g4 @@ -155,8 +155,7 @@ matchArm ; nonBlockExpr - : LPAREN expr RPAREN - | BANG nonBlockExpr + : BANG nonBlockExpr | MINUS nonBlockExpr | nonBlockExpr DOT ident | nonBlockExpr DOT intLiteral @@ -169,6 +168,7 @@ nonBlockExpr | nilLiteral | seqNilLiteral | tupleExpr + | LPAREN expr RPAREN | callExpr | identPath | literal From 6de22dc90d0ff0c99295ad7080738628c19157fa Mon Sep 17 00:00:00 2001 From: Rohan Kumar Date: Thu, 30 Apr 2026 10:43:29 -0700 Subject: [PATCH 4/6] wip: fix precedence bug --- core/compiler/grammar/Argon.g4 | 33 +++-- core/compiler/src/antlr.rs | 221 +++++++++++++++++---------------- core/compiler/src/lib.rs | 32 +++++ examples/precedence/lib.ar | 4 + 4 files changed, 165 insertions(+), 125 deletions(-) create mode 100644 examples/precedence/lib.ar diff --git a/core/compiler/grammar/Argon.g4 b/core/compiler/grammar/Argon.g4 index e98b544..32eb0ea 100644 --- a/core/compiler/grammar/Argon.g4 +++ b/core/compiler/grammar/Argon.g4 @@ -107,7 +107,7 @@ scopeAnnotation unannotatedScope : LBRACE statements RBRACE - | LBRACE statements nonBlockExpr RBRACE + | LBRACE statements expr RBRACE ; statements @@ -131,13 +131,6 @@ forLoop : FOR ident IN expr scope ; -expr - : nonBlockExpr - | ifExpr - | matchExpr - | scope - ; - ifExpr : scopeAnnotation? IF expr scope ELSE scope ; @@ -154,21 +147,23 @@ matchArm : identPath FAT_ARROW expr COMMA ; -nonBlockExpr - : BANG nonBlockExpr - | MINUS nonBlockExpr - | nonBlockExpr DOT ident - | nonBlockExpr DOT intLiteral - | nonBlockExpr LBRACK expr RBRACK - | nonBlockExpr BANG - | nonBlockExpr AS tySpec - | nonBlockExpr (STAR | SLASH | PERCENT) nonBlockExpr - | nonBlockExpr (PLUS | MINUS) nonBlockExpr - | nonBlockExpr (EQEQ | NEQ | GEQ | GT | LEQ | LT) nonBlockExpr +expr + : unaryOp=(BANG|MINUS) expr + | fieldAccessBase=expr DOT ident + | indexFieldAccessBase=expr DOT intLiteral + | indexBase=expr LBRACK expr RBRACK + | emitValue=expr BANG + | castValue=expr AS tySpec + | expr binaryOp=(STAR | SLASH | PERCENT) expr + | expr binaryOp=(PLUS | MINUS) expr + | expr comparisonOp=(EQEQ | NEQ | GEQ | GT | LEQ | LT) expr | nilLiteral | seqNilLiteral | tupleExpr | LPAREN expr RPAREN + | ifExpr + | matchExpr + | scope | callExpr | identPath | literal diff --git a/core/compiler/src/antlr.rs b/core/compiler/src/antlr.rs index 182b905..36dbc1d 100644 --- a/core/compiler/src/antlr.rs +++ b/core/compiler/src/antlr.rs @@ -364,9 +364,7 @@ impl<'input> AstBuilder<'input> { .statements() .map(|stmts| self.build_statements(stmts.as_ref())) .unwrap_or_default(); - let mut tail = ctx - .nonBlockExpr() - .map(|expr| self.build_non_block_expr(expr.as_ref())); + let mut tail = ctx.expr().map(|expr| self.build_expr(expr.as_ref())); if tail.is_none() && let Some(Statement::Expr { value, @@ -444,18 +442,6 @@ impl<'input> AstBuilder<'input> { } } - fn build_expr(&mut self, ctx: &ExprContext<'input>) -> Expr<&'input str, ParseMetadata> { - if let Some(if_expr) = ctx.ifExpr() { - Expr::If(Box::new(self.build_if_expr(if_expr.as_ref()))) - } else if let Some(match_expr) = ctx.matchExpr() { - Expr::Match(Box::new(self.build_match_expr(match_expr.as_ref()))) - } else if let Some(scope) = ctx.scope() { - Expr::Scope(Box::new(self.build_scope(scope.as_ref()))) - } else { - self.build_non_block_expr(ctx.nonBlockExpr().unwrap().as_ref()) - } - } - fn build_if_expr(&mut self, ctx: &IfExprContext<'input>) -> IfExpr<&'input str, ParseMetadata> { IfExpr { scope_annotation: ctx @@ -502,107 +488,132 @@ impl<'input> AstBuilder<'input> { } } - fn build_non_block_expr( - &mut self, - ctx: &NonBlockExprContext<'input>, - ) -> Expr<&'input str, ParseMetadata> { - if ctx.start().get_token_type() == BANG { - let operand = self.build_non_block_expr(ctx.nonBlockExpr(0).unwrap().as_ref()); + fn build_expr(&mut self, ctx: &ExprContext<'input>) -> Expr<&'input str, ParseMetadata> { + if let Some(op) = &ctx.unaryOp { + let op = match op.get_token_type() { + BANG => UnaryOp::Not, + MINUS => UnaryOp::Neg, + _ => unreachable!("invalid unary op"), + }; + let operand = self.build_expr(ctx.expr(0).unwrap().as_ref()); Expr::UnaryOp(Box::new(UnaryOpExpr { op: UnaryOp::Not, operand, span: self.span_of(ctx), metadata: (), })) - } else if ctx.start().get_token_type() == MINUS { - let operand = self.build_non_block_expr(ctx.nonBlockExpr(0).unwrap().as_ref()); - Expr::UnaryOp(Box::new(UnaryOpExpr { - op: UnaryOp::Neg, - operand, - span: self.span_of(ctx), - metadata: (), - })) - } else if let Some(rhs) = ctx.nonBlockExpr(1) { - let left = self.build_non_block_expr(ctx.nonBlockExpr(0).unwrap().as_ref()); - let right = self.build_non_block_expr(rhs.as_ref()); - let span = Span::new(left.span().start(), right.span().end()); - if let Some(op) = self.single_comparison_op(ctx) { - Expr::Comparison(Box::new(ComparisonExpr { - op, - left, - right, - span, - metadata: (), - })) - } else { - Expr::BinOp(Box::new(BinOpExpr { - op: self.single_bin_op(ctx), - left, - right, - span, - metadata: (), - })) - } - } else if let Some(ty) = ctx.tySpec() { - let value = self.build_non_block_expr(ctx.nonBlockExpr(0).unwrap().as_ref()); - let ty = self.build_ty_spec(ty.as_ref()); - let span = Span::new(value.span().start(), ty.span.end()); - Expr::Cast(Box::new(CastExpr { - value, - ty, - span, - metadata: (), - })) - } else if let Some(ident) = ctx.ident() { - let base = self.build_non_block_expr(ctx.nonBlockExpr(0).unwrap().as_ref()); + } else if let Some(base) = &ctx.fieldAccessBase { Expr::FieldAccess(Box::new(FieldAccessExpr { - base, - field: self.build_ident(ident.as_ref()), + base: self.build_expr(base), + field: self.build_ident(ctx.ident().as_ref().unwrap()), span: self.span_of(ctx), metadata: (), })) - } else if let Some(intlit) = ctx.intLiteral() { - let base = self.build_non_block_expr(ctx.nonBlockExpr(0).unwrap().as_ref()); + } else if let Some(base) = &ctx.indexFieldAccessBase { Expr::IndexFieldAccess(Box::new(IndexFieldAccessExpr { - base, - field: self.build_int_literal(intlit.as_ref()), + base: self.build_expr(base), + field: self.build_int_literal(ctx.intLiteral().as_ref().unwrap()), span: self.span_of(ctx), metadata: (), })) - } else if let Some(expr) = ctx.expr() { - if let Some(base) = ctx.nonBlockExpr(0) { - Expr::Index(Box::new(IndexExpr { - base: self.build_non_block_expr(base.as_ref()), - index: self.build_expr(expr.as_ref()), - span: self.span_of(ctx), - metadata: (), - })) - } else { - self.build_expr(expr.as_ref()) - } - } else if let Some(nil) = ctx.nilLiteral() { - Expr::Nil(NilLiteral { - span: self.span_of(nil.as_ref()), - }) - } else if let Some(seq_nil) = ctx.seqNilLiteral() { - Expr::SeqNil(SeqNilLiteral { - span: self.span_of(seq_nil.as_ref()), - }) - } else if let Some(tuple) = ctx.tupleExpr() { - Expr::Tuple(self.build_tuple_expr(tuple.as_ref())) - } else if let Some(call) = ctx.callExpr() { - Expr::Call(self.build_call_expr(call.as_ref())) - } else if let Some(path) = ctx.identPath() { - Expr::IdentPath(self.build_ident_path(path.as_ref())) - } else if let Some(literal) = ctx.literal() { - self.build_literal(literal.as_ref()) } else { - Expr::Emit(Box::new(EmitExpr { - value: self.build_non_block_expr(ctx.nonBlockExpr(0).unwrap().as_ref()), - span: self.span_of(ctx), - metadata: (), - })) - } + unreachable!("should cover all productions"); + } + // else if ctx.start().get_token_type() == MINUS { + // let operand = self.build_expr(ctx.expr(0).unwrap().as_ref()); + // Expr::UnaryOp(Box::new(UnaryOpExpr { + // op: UnaryOp::Neg, + // operand, + // span: self.span_of(ctx), + // metadata: (), + // })) + // } else if let Some(rhs) = ctx.expr(1) { + // let left = self.build_expr(ctx.expr(0).unwrap().as_ref()); + // let right = self.build_expr(rhs.as_ref()); + // let span = Span::new(left.span().start(), right.span().end()); + // if let Some(op) = self.single_comparison_op(ctx) { + // Expr::Comparison(Box::new(ComparisonExpr { + // op, + // left, + // right, + // span, + // metadata: (), + // })) + // } else { + // Expr::BinOp(Box::new(BinOpExpr { + // op: self.single_bin_op(ctx), + // left, + // right, + // span, + // metadata: (), + // })) + // } + // } else if let Some(ty) = ctx.tySpec() { + // let value = self.build_expr(ctx.expr(0).unwrap().as_ref()); + // let ty = self.build_ty_spec(ty.as_ref()); + // let span = Span::new(value.span().start(), ty.span.end()); + // Expr::Cast(Box::new(CastExpr { + // value, + // ty, + // span, + // metadata: (), + // })) + // } else if let Some(ident) = ctx.ident() { + // let base = self.build_expr(ctx.expr(0).unwrap().as_ref()); + // Expr::FieldAccess(Box::new(FieldAccessExpr { + // base, + // field: self.build_ident(ident.as_ref()), + // span: self.span_of(ctx), + // metadata: (), + // })) + // } else if let Some(intlit) = ctx.intLiteral() { + // let base = self.build_expr(ctx.expr(0).unwrap().as_ref()); + // Expr::IndexFieldAccess(Box::new(IndexFieldAccessExpr { + // base, + // field: self.build_int_literal(intlit.as_ref()), + // span: self.span_of(ctx), + // metadata: (), + // })) + // } else if let Some(expr) = ctx.expr(0) { + // if let Some(base) = ctx.expr(1) { + // Expr::Index(Box::new(IndexExpr { + // base: self.build_expr(base.as_ref()), + // index: self.build_expr(expr.as_ref()), + // span: self.span_of(ctx), + // metadata: (), + // })) + // } else { + // self.build_expr(expr.as_ref()) + // } + // } else if let Some(nil) = ctx.nilLiteral() { + // Expr::Nil(NilLiteral { + // span: self.span_of(nil.as_ref()), + // }) + // } else if let Some(seq_nil) = ctx.seqNilLiteral() { + // Expr::SeqNil(SeqNilLiteral { + // span: self.span_of(seq_nil.as_ref()), + // }) + // } else if let Some(tuple) = ctx.tupleExpr() { + // Expr::Tuple(self.build_tuple_expr(tuple.as_ref())) + // } else if let Some(if_expr) = ctx.ifExpr() { + // Expr::If(Box::new(self.build_if_expr(if_expr.as_ref()))) + // } else if let Some(match_expr) = ctx.matchExpr() { + // Expr::Match(Box::new(self.build_match_expr(match_expr.as_ref()))) + // } else if let Some(scope) = ctx.scope() { + // Expr::Scope(Box::new(self.build_scope(scope.as_ref()))) + // } else if let Some(call) = ctx.callExpr() { + // Expr::Call(self.build_call_expr(call.as_ref())) + // } else if let Some(path) = ctx.identPath() { + // Expr::IdentPath(self.build_ident_path(path.as_ref())) + // } else if let Some(literal) = ctx.literal() { + // self.build_literal(literal.as_ref()) + // } else { + // Expr::Emit(Box::new(EmitExpr { + // value: self.build_expr(ctx.expr(0).unwrap().as_ref()), + // span: self.span_of(ctx), + // metadata: (), + // })) + // } } fn build_tuple_expr( @@ -811,7 +822,7 @@ impl<'input> AstBuilder<'input> { } } - fn single_comparison_op(&self, ctx: &NonBlockExprContext<'input>) -> Option { + fn single_comparison_op(&self, ctx: &ExprContext<'input>) -> Option { self.terminal_types(ctx) .into_iter() .filter_map(|ttype| match ttype { @@ -826,7 +837,7 @@ impl<'input> AstBuilder<'input> { .next() } - fn single_bin_op(&self, ctx: &NonBlockExprContext<'input>) -> BinOp { + fn single_bin_op(&self, ctx: &ExprContext<'input>) -> BinOp { self.terminal_types(ctx) .into_iter() .find_map(|ttype| match ttype { @@ -837,9 +848,7 @@ impl<'input> AstBuilder<'input> { PERCENT => Some(BinOp::Rem), _ => None, }) - .unwrap_or_else(|| { - unreachable!("binary nonBlockExpr must contain an arithmetic operator") - }) + .unwrap_or_else(|| unreachable!("binary expr must contain an arithmetic operator")) } fn terminal_types(&self, ctx: &T) -> Vec diff --git a/core/compiler/src/lib.rs b/core/compiler/src/lib.rs index 90a3aa7..389a608 100644 --- a/core/compiler/src/lib.rs +++ b/core/compiler/src/lib.rs @@ -72,6 +72,7 @@ mod tests { const ARGON_TUPLE_ANY: &str = concatcp!(EXAMPLES_DIR, "/tuple_any/lib.ar"); const ARGON_FOR_LOOP_BASIC: &str = concatcp!(EXAMPLES_DIR, "/for_loop_basic/lib.ar"); const ARGON_SSE_BASIC: &str = concatcp!(EXAMPLES_DIR, "/sse_basic/lib.ar"); + const ARGON_PRECEDENCE: &str = concatcp!(EXAMPLES_DIR, "/precedence/lib.ar"); #[test] fn argon_scopes() { @@ -1040,6 +1041,37 @@ mod tests { assert_eq!(cell.rowspace_vecs.len(), 1); } + #[test] + fn argon_precedence() { + let o = parse_workspace_with_std(ARGON_PRECEDENCE); + assert!(o.static_errors().is_empty()); + let ast = o.ast(); + let cells = compile( + &ast, + CompileInput { + cell: &["precedence"], + args: Vec::new(), + lyp_file: &PathBuf::from(BASIC_LYP), + }, + ); + println!("{cells:#?}"); + + let cells = cells.unwrap_valid(); + let cell = &cells.cells[&cells.top]; + assert_eq!( + cell.objects + .first() + .unwrap() + .1 + .clone() + .unwrap_rect() + .x0 + .0 + .round() as i64, + -8 + ); + } + #[test] #[ignore = "requires Pegasus"] fn argon_sky130_vco() { diff --git a/examples/precedence/lib.ar b/examples/precedence/lib.ar new file mode 100644 index 0000000..6ad3bab --- /dev/null +++ b/examples/precedence/lib.ar @@ -0,0 +1,4 @@ +cell precedence() { + let x0 = ((-1 - 2) / 3 - (5 + 2)) as Float; + let inner = crect(x0=x0, x1=0., y0=0., y1=5.); +} From fa17f2099889bc7e8628725be9eecffd9e974a53 Mon Sep 17 00:00:00 2001 From: Rohan Kumar Date: Thu, 30 Apr 2026 10:55:52 -0700 Subject: [PATCH 5/6] cleanup and finish fixing parser --- core/compiler/src/antlr.rs | 216 ++++++---------- core/compiler/src/argon.l | 49 ---- core/compiler/src/argon.y | 517 ------------------------------------- 3 files changed, 78 insertions(+), 704 deletions(-) delete mode 100644 core/compiler/src/argon.l delete mode 100644 core/compiler/src/argon.y diff --git a/core/compiler/src/antlr.rs b/core/compiler/src/antlr.rs index 36dbc1d..466ac7d 100644 --- a/core/compiler/src/antlr.rs +++ b/core/compiler/src/antlr.rs @@ -497,7 +497,7 @@ impl<'input> AstBuilder<'input> { }; let operand = self.build_expr(ctx.expr(0).unwrap().as_ref()); Expr::UnaryOp(Box::new(UnaryOpExpr { - op: UnaryOp::Not, + op, operand, span: self.span_of(ctx), metadata: (), @@ -516,104 +516,86 @@ impl<'input> AstBuilder<'input> { span: self.span_of(ctx), metadata: (), })) + } else if let Some(base) = &ctx.indexBase { + Expr::Index(Box::new(IndexExpr { + base: self.build_expr(base), + index: self.build_expr(ctx.expr(1).unwrap().as_ref()), + span: self.span_of(ctx), + metadata: (), + })) + } else if let Some(value) = &ctx.emitValue { + Expr::Emit(Box::new(EmitExpr { + value: self.build_expr(value), + span: self.span_of(ctx), + metadata: (), + })) + } else if let Some(value) = &ctx.castValue { + Expr::Cast(Box::new(CastExpr { + value: self.build_expr(value), + ty: self.build_ty_spec(ctx.tySpec().unwrap().as_ref()), + span: self.span_of(ctx), + metadata: (), + })) + } else if let Some(op) = &ctx.binaryOp { + let op = match op.get_token_type() { + STAR => BinOp::Mul, + SLASH => BinOp::Div, + PERCENT => BinOp::Rem, + PLUS => BinOp::Add, + MINUS => BinOp::Sub, + _ => unreachable!("invalid binary op"), + }; + Expr::BinOp(Box::new(BinOpExpr { + op, + left: self.build_expr(ctx.expr(0).unwrap().as_ref()), + right: self.build_expr(ctx.expr(1).unwrap().as_ref()), + span: self.span_of(ctx), + metadata: (), + })) + } else if let Some(op) = &ctx.comparisonOp { + let op = match op.get_token_type() { + EQEQ => ComparisonOp::Eq, + NEQ => ComparisonOp::Ne, + GEQ => ComparisonOp::Geq, + GT => ComparisonOp::Gt, + LEQ => ComparisonOp::Leq, + LT => ComparisonOp::Lt, + _ => unreachable!("invalid comparison op"), + }; + Expr::Comparison(Box::new(ComparisonExpr { + op, + left: self.build_expr(ctx.expr(0).unwrap().as_ref()), + right: self.build_expr(ctx.expr(1).unwrap().as_ref()), + span: self.span_of(ctx), + metadata: (), + })) + } else if let Some(nil) = ctx.nilLiteral() { + Expr::Nil(NilLiteral { + span: self.span_of(nil.as_ref()), + }) + } else if let Some(seq_nil) = ctx.seqNilLiteral() { + Expr::SeqNil(SeqNilLiteral { + span: self.span_of(seq_nil.as_ref()), + }) + } else if let Some(tuple) = ctx.tupleExpr() { + Expr::Tuple(self.build_tuple_expr(tuple.as_ref())) + } else if let Some(expr) = ctx.expr(0) { + self.build_expr(expr.as_ref()) + } else if let Some(if_expr) = ctx.ifExpr() { + Expr::If(Box::new(self.build_if_expr(if_expr.as_ref()))) + } else if let Some(match_expr) = ctx.matchExpr() { + Expr::Match(Box::new(self.build_match_expr(match_expr.as_ref()))) + } else if let Some(scope) = ctx.scope() { + Expr::Scope(Box::new(self.build_scope(scope.as_ref()))) + } else if let Some(call) = ctx.callExpr() { + Expr::Call(self.build_call_expr(call.as_ref())) + } else if let Some(path) = ctx.identPath() { + Expr::IdentPath(self.build_ident_path(path.as_ref())) + } else if let Some(literal) = ctx.literal() { + self.build_literal(literal.as_ref()) } else { unreachable!("should cover all productions"); } - // else if ctx.start().get_token_type() == MINUS { - // let operand = self.build_expr(ctx.expr(0).unwrap().as_ref()); - // Expr::UnaryOp(Box::new(UnaryOpExpr { - // op: UnaryOp::Neg, - // operand, - // span: self.span_of(ctx), - // metadata: (), - // })) - // } else if let Some(rhs) = ctx.expr(1) { - // let left = self.build_expr(ctx.expr(0).unwrap().as_ref()); - // let right = self.build_expr(rhs.as_ref()); - // let span = Span::new(left.span().start(), right.span().end()); - // if let Some(op) = self.single_comparison_op(ctx) { - // Expr::Comparison(Box::new(ComparisonExpr { - // op, - // left, - // right, - // span, - // metadata: (), - // })) - // } else { - // Expr::BinOp(Box::new(BinOpExpr { - // op: self.single_bin_op(ctx), - // left, - // right, - // span, - // metadata: (), - // })) - // } - // } else if let Some(ty) = ctx.tySpec() { - // let value = self.build_expr(ctx.expr(0).unwrap().as_ref()); - // let ty = self.build_ty_spec(ty.as_ref()); - // let span = Span::new(value.span().start(), ty.span.end()); - // Expr::Cast(Box::new(CastExpr { - // value, - // ty, - // span, - // metadata: (), - // })) - // } else if let Some(ident) = ctx.ident() { - // let base = self.build_expr(ctx.expr(0).unwrap().as_ref()); - // Expr::FieldAccess(Box::new(FieldAccessExpr { - // base, - // field: self.build_ident(ident.as_ref()), - // span: self.span_of(ctx), - // metadata: (), - // })) - // } else if let Some(intlit) = ctx.intLiteral() { - // let base = self.build_expr(ctx.expr(0).unwrap().as_ref()); - // Expr::IndexFieldAccess(Box::new(IndexFieldAccessExpr { - // base, - // field: self.build_int_literal(intlit.as_ref()), - // span: self.span_of(ctx), - // metadata: (), - // })) - // } else if let Some(expr) = ctx.expr(0) { - // if let Some(base) = ctx.expr(1) { - // Expr::Index(Box::new(IndexExpr { - // base: self.build_expr(base.as_ref()), - // index: self.build_expr(expr.as_ref()), - // span: self.span_of(ctx), - // metadata: (), - // })) - // } else { - // self.build_expr(expr.as_ref()) - // } - // } else if let Some(nil) = ctx.nilLiteral() { - // Expr::Nil(NilLiteral { - // span: self.span_of(nil.as_ref()), - // }) - // } else if let Some(seq_nil) = ctx.seqNilLiteral() { - // Expr::SeqNil(SeqNilLiteral { - // span: self.span_of(seq_nil.as_ref()), - // }) - // } else if let Some(tuple) = ctx.tupleExpr() { - // Expr::Tuple(self.build_tuple_expr(tuple.as_ref())) - // } else if let Some(if_expr) = ctx.ifExpr() { - // Expr::If(Box::new(self.build_if_expr(if_expr.as_ref()))) - // } else if let Some(match_expr) = ctx.matchExpr() { - // Expr::Match(Box::new(self.build_match_expr(match_expr.as_ref()))) - // } else if let Some(scope) = ctx.scope() { - // Expr::Scope(Box::new(self.build_scope(scope.as_ref()))) - // } else if let Some(call) = ctx.callExpr() { - // Expr::Call(self.build_call_expr(call.as_ref())) - // } else if let Some(path) = ctx.identPath() { - // Expr::IdentPath(self.build_ident_path(path.as_ref())) - // } else if let Some(literal) = ctx.literal() { - // self.build_literal(literal.as_ref()) - // } else { - // Expr::Emit(Box::new(EmitExpr { - // value: self.build_expr(ctx.expr(0).unwrap().as_ref()), - // span: self.span_of(ctx), - // metadata: (), - // })) - // } } fn build_tuple_expr( @@ -822,48 +804,6 @@ impl<'input> AstBuilder<'input> { } } - fn single_comparison_op(&self, ctx: &ExprContext<'input>) -> Option { - self.terminal_types(ctx) - .into_iter() - .filter_map(|ttype| match ttype { - EQEQ => Some(ComparisonOp::Eq), - NEQ => Some(ComparisonOp::Ne), - GEQ => Some(ComparisonOp::Geq), - GT => Some(ComparisonOp::Gt), - LEQ => Some(ComparisonOp::Leq), - LT => Some(ComparisonOp::Lt), - _ => None, - }) - .next() - } - - fn single_bin_op(&self, ctx: &ExprContext<'input>) -> BinOp { - self.terminal_types(ctx) - .into_iter() - .find_map(|ttype| match ttype { - PLUS => Some(BinOp::Add), - MINUS => Some(BinOp::Sub), - STAR => Some(BinOp::Mul), - SLASH => Some(BinOp::Div), - PERCENT => Some(BinOp::Rem), - _ => None, - }) - .unwrap_or_else(|| unreachable!("binary expr must contain an arithmetic operator")) - } - - fn terminal_types(&self, ctx: &T) -> Vec - where - T: ParserRuleContext<'input, Ctx = ArgonParserContextType>, - { - let mut tokens = Vec::new(); - for child in ctx.get_children() { - if let Ok(tok) = child.downcast_rc::>() { - tokens.push(tok.symbol.get_token_type()); - } - } - tokens - } - fn span_of(&self, ctx: &T) -> Span where T: ParserRuleContext<'input, Ctx = ArgonParserContextType>, diff --git a/core/compiler/src/argon.l b/core/compiler/src/argon.l deleted file mode 100644 index 2bb316a..0000000 --- a/core/compiler/src/argon.l +++ /dev/null @@ -1,49 +0,0 @@ -%% - -enum "ENUM" -struct "STRUCT" -match "MATCH" -const "CONST" -cell "CELL" -mod "MOD" -if "IF" -fn "FN" -else "ELSE" -let "LET" -for "FOR" -in "IN" -as "AS" -true "TRUE" -false "FALSE" -#[_a-zA-Z][_a-zA-Z0-9]* "ANNOTATION" -[_a-zA-Z][_a-zA-Z0-9]* "IDENT" -[0-9]+ "INTLIT" -"[^"]*" "STRLIT" -//[^\r\n]* ; -\+ "+" -\* "*" -% "%" -- "-" -\/ "/" -\( "(" -\) ")" -\{ "{" -\} "}" -\[ "[" -\] "]" -\. "." -:: "::" -: ":" -; ";" -, "," -=> '=>' -== "==" -!= "!=" -\>= ">=" -\> ">" -\< "<" -\<= "<=" -= "=" -\! "!" --\> "->" -[\t \r\n]+ ; diff --git a/core/compiler/src/argon.y b/core/compiler/src/argon.y deleted file mode 100644 index 40415e2..0000000 --- a/core/compiler/src/argon.y +++ /dev/null @@ -1,517 +0,0 @@ -%start Ast -%% -Ast -> Result, ()>: - Decls { - Ok(Ast { - decls: $1?, - span: $span, - }) - }; - -Decls -> Result>, ()>: - Decls Decl { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - | { Ok(Vec::new()) } - ; - -Decl -> Result, ()> - : EnumDecl { Ok(Decl::Enum($1?)) } - | StructDecl { Ok(Decl::Struct($1?)) } - | CellDecl { Ok(Decl::Cell($1?)) } - | FnDecl { Ok(Decl::Fn($1?)) } - | ConstantDecl { Ok(Decl::Constant($1?)) } - | ModDecl { Ok(Decl::Mod($1?)) } - ; - -Ident -> Result, ()> - : 'IDENT' { - let _ = $1.map_err(|_| ())?; - Ok(Ident { span: $span, name: $lexer.span_str($span), metadata: () }) - } - ; - -IdentPath -> Result, ()> - : Ident { Ok(IdentPath { path: vec![$1?], metadata: (), span: $span }) } - | Ident '::' IdentPath { - let mut path = vec![$1?]; - path.extend($3?.path); - Ok(IdentPath { path, metadata: (), span: $span }) - } - ; - -NilLiteral -> Result - : '(' ')' { - Ok(NilLiteral { span: $span, }) } - ; - -SeqNilLiteral -> Result - : '[' ']' { - Ok(SeqNilLiteral { span: $span, }) } - ; - -FloatLiteral -> Result - : 'INTLIT' '.' { - let v = $1.map_err(|_| ())?; - Ok(FloatLiteral { span: $span, value: parse_float($lexer.span_str(v.span()))?, }) - } - | 'INTLIT' '.' 'INTLIT' { - Ok(FloatLiteral { span: $span, value: parse_float($lexer.span_str($span))?, }) - } - ; - -IntLiteral -> Result - : 'INTLIT' { - let v = $1.map_err(|_| ())?; - Ok(IntLiteral { span: v.span(), value: parse_int($lexer.span_str(v.span()))?, }) } - ; - -StringLiteral -> Result, ()> - : 'STRLIT' { - let v = $1.map_err(|_| ())?; - Ok(StringLiteral { span: v.span(), value: $lexer.span_str(v.span()).trim_matches('"'), }) } - ; - -BoolLiteral -> Result - : 'TRUE' { - let v = $1.map_err(|_| ())?; - Ok(BoolLiteral { span: v.span(), value: true, }) - } - | 'FALSE' { - let v = $1.map_err(|_| ())?; - Ok(BoolLiteral { span: v.span(), value: false, }) - } - ; - -EnumDecl -> Result, ()> - : 'ENUM' Ident '{' EnumVariants '}' - { - Ok(EnumDecl { - name: $2?, - variants: $4?, - metadata: (), - }) - } - ; - -StructDecl -> Result, ()> - : 'STRUCT' Ident '{' StructFields '}' - { - Ok(StructDecl { - name: $2?, - fields: $4?, - span: $span, - metadata: (), - }) - } - ; - -ConstantDecl -> Result, ()> - : 'CONST' Ident ':' Ident '=' Expr ';' - { - Ok(ConstantDecl { - name: $2?, - ty: $4?, - value: $6?, - metadata: (), - }) - } - ; - -ModDecl -> Result, ()> - : 'MOD' Ident ';' - { - Ok(ModDecl { - ident: $2?, - span: $span, - }) - } - ; - -EnumVariants -> Result>, ()>: - EnumVariants Ident ',' { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - | { Ok(Vec::new()) } - ; - -StructFields -> Result>, ()>: - StructFields StructField ',' { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - | { Ok(Vec::new()) } - ; - -StructField -> Result, ()> - : Ident ':' Ident - { - Ok(StructField { - name: $1?, - ty: $3?, - span: $span, - metadata: (), - }) - } - ; - -CellDecl -> Result, ()> - : 'CELL' Ident '(' ArgDecls ')' Scope - { - Ok(CellDecl { - name: $2?, - args: $4?, - scope: $6?, - span: $span, - metadata: (), - }) - } - ; - -FnDecl -> Result, ()> - : 'FN' Ident '(' ArgDecls ')' '->' TySpec Scope - { - Ok(FnDecl { - name: $2?, - args: $4?, - scope: $8?, - return_ty: Some($7?), - span: $span, - metadata: (), - }) - } - | 'FN' Ident '(' ArgDecls ')' Scope - { - Ok(FnDecl { - name: $2?, - args: $4?, - scope: $6?, - return_ty: None, - span: $span, - metadata: (), - }) - } - ; - -Statements -> Result>, ()>: - Statements Statement { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - | { Ok(Vec::new()) } - ; - -Statement -> Result, ()> - : Expr ';' - { - Ok(Statement::Expr { value: $1?, semicolon: true, }) - } - | 'LET' Ident '=' Expr ';' - { - Ok(Statement::LetBinding(LetBinding { - name: $2?, - value: $4?, - span: $span, - metadata: (), - })) - } - | BlockExpr - { - Ok(Statement::Expr { value: $1?, semicolon: false, }) - } - | 'FOR' Ident 'IN' Expr Scope - { - Ok(Statement::ForLoop(ForLoop { - var: $2?, - seq: $4?, - body: $5?, - span: $span, - metadata: (), - })) - } - ; - -ScopeAnnotation -> Result, ()> - : 'ANNOTATION' - { - Ok(Ident { - span: cfgrammar::Span::new( - $span.start() + 1, - $span.end(), - ), - name: &$lexer.span_str($span)[1..], - metadata: () - }) - } - ; - -UnannotatedScope -> Result, ()> - : '{' Statements '}' - { - let mut __stmts = $2?; - if let Some(Statement::Expr { value, semicolon }) = __stmts.last().cloned() && !semicolon { - __stmts.pop().unwrap(); - return Ok(Scope { - scope_annotation: None, - span: $span, - stmts: __stmts, - tail: Some(value), - metadata: (), - }) - } - Ok(Scope { - scope_annotation: None, - span: $span, - stmts: __stmts, - tail: None, - metadata: (), - }) - } - | '{' Statements NonBlockExpr '}' - { - Ok(Scope { - scope_annotation: None, - span: $span, - stmts: $2?, - tail: Some($3?), - metadata: (), - }) - } - ; - -Scope -> Result, ()> - : ScopeAnnotation UnannotatedScope - { - Ok(Scope { - scope_annotation: Some($1?), - ..$2? - }) - } - | UnannotatedScope - { - $1 - } - ; - -Expr -> Result, ()> - : NonBlockExpr { $1 } - | BlockExpr { $1 } - ; - -BlockExpr -> Result, ()> - : 'IF' Expr Scope 'ELSE' Scope { Ok(Expr::If(Box::new(IfExpr { scope_annotation: None, cond: $2?, then: $3?, else_: $5?, span: $span, metadata: (), }))) } - | ScopeAnnotation 'IF' Expr Scope 'ELSE' Scope { Ok(Expr::If(Box::new(IfExpr { scope_annotation: Some($1?), cond: $3?, then: $4?, else_: $6?, span: $span, metadata: (), }))) } - | MatchExpr { Ok(Expr::Match(Box::new($1?))) } - | Scope { Ok(Expr::Scope(Box::new($1?))) } - ; - -MatchExpr -> Result, ()> - : 'MATCH' Expr '{' MatchArms '}' { Ok(MatchExpr { scrutinee: $2?, arms: $4?, span: $span, metadata: () }) } - ; - -MatchArms -> Result>, ()> - : MatchArm { Ok(vec![$1?]) } - | MatchArms MatchArm { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - ; - -MatchArm -> Result, ()> - : IdentPath '=>' Expr ',' { Ok(MatchArm { pattern: $1?, expr: $3?, span: $span, }) } - ; - -NonBlockExpr -> Result, ()> - : NonBlockExpr '==' NonComparisonExpr { Ok(Expr::Comparison(Box::new(ComparisonExpr { op: ComparisonOp::Eq, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | NonBlockExpr '!=' NonComparisonExpr { Ok(Expr::Comparison(Box::new(ComparisonExpr { op: ComparisonOp::Ne, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | NonBlockExpr '>=' NonComparisonExpr { Ok(Expr::Comparison(Box::new(ComparisonExpr { op: ComparisonOp::Geq, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | NonBlockExpr '>' NonComparisonExpr { Ok(Expr::Comparison(Box::new(ComparisonExpr { op: ComparisonOp::Gt, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | NonBlockExpr '<=' NonComparisonExpr { Ok(Expr::Comparison(Box::new(ComparisonExpr { op: ComparisonOp::Leq, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | NonBlockExpr '<' NonComparisonExpr { Ok(Expr::Comparison(Box::new(ComparisonExpr { op: ComparisonOp::Lt, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | NonComparisonExpr { $1 } - ; - -NonComparisonExpr -> Result, ()> - : NonComparisonExpr '+' Term { Ok(Expr::BinOp(Box::new(BinOpExpr { op: BinOp::Add, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | NonComparisonExpr '-' Term { Ok(Expr::BinOp(Box::new(BinOpExpr { op: BinOp::Sub, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | Term { $1 } - ; - -Term -> Result, ()> - : Term '*' Factor { Ok(Expr::BinOp(Box::new(BinOpExpr { op: BinOp::Mul, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | Term '/' Factor { Ok(Expr::BinOp(Box::new(BinOpExpr { op: BinOp::Div, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | Term '%' Factor { Ok(Expr::BinOp(Box::new(BinOpExpr { op: BinOp::Rem, left: $1?, right: $3?, span: $span, metadata: (), }))) } - | Factor { $1 } - ; - -Factor -> Result, ()> - : '!' Factor { Ok(Expr::UnaryOp(Box::new(UnaryOpExpr { op: UnaryOp::Not, operand: $2?, span: $span, metadata: () }))) } - | '-' Factor { Ok(Expr::UnaryOp(Box::new(UnaryOpExpr { op: UnaryOp::Neg, operand: $2?, span: $span, metadata: () }))) } - | SubFactor { $1 } - ; - -SubFactor -> Result, ()> - : IntLiteral { Ok(Expr::IntLiteral($1?)) } - | FloatLiteral { Ok(Expr::FloatLiteral($1?)) } - | StringLiteral { Ok(Expr::StringLiteral($1?)) } - | BoolLiteral { Ok(Expr::BoolLiteral($1?)) } - | NilLiteral { Ok(Expr::Nil($1?)) } - | SeqNilLiteral { Ok(Expr::SeqNil($1?)) } - | SubFactor 'AS' TySpec { Ok(Expr::Cast(Box::new(CastExpr { value: $1?, ty: $3?, span: $span, metadata: (), }))) } - | ObjExpr { $1 } - ; - -ObjExpr -> Result, ()> - : '(' Expr ')' { $2 } - | TupleExpr { Ok(Expr::Tuple($1?)) } - | CallExpr { Ok(Expr::Call($1?)) } - | ObjExpr '.' Ident { Ok(Expr::FieldAccess(Box::new(FieldAccessExpr { base: $1?, field: $3?, span: $span, metadata: (), }))) } - | ObjExpr '.' IntLiteral { Ok(Expr::IndexFieldAccess(Box::new(IndexFieldAccessExpr { base: $1?, field: $3?, span: $span, metadata: (), }))) } - | SubFactor '[' Expr ']' { Ok(Expr::Index(Box::new(IndexExpr { base: $1?, index: $3?, span: $span, metadata: () }))) } - | SubFactor '!' { Ok(Expr::Emit(Box::new(EmitExpr { value: $1?, span: $span, metadata: (), }))) } - | IdentPath { Ok(Expr::IdentPath($1?)) } - ; - -TupleExpr -> Result, ()> - : '(' TupleExprList ')' { Ok(TupleExpr { items: $2?, span: $span, metadata: () }) } - ; - -TupleExprList -> Result>, ()> - : Expr ',' { Ok(vec![$1?]) } - | TupleExprList Expr ',' { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - ; - -CallExpr -> Result, ()> - : ScopeAnnotation IdentPath '(' Args ')' - { - Ok(CallExpr { - scope_annotation: Some($1?), - func: $2?, - args: $4?, - span: $span, - metadata: (), - }) - } - | IdentPath '(' Args ')' - { - Ok(CallExpr { - scope_annotation: None, - func: $1?, - args: $3?, - span: $span, - metadata: (), - }) - } - ; - -ArgDecls -> Result>, ()> - : { Ok(Vec::new()) } - | ArgDecls1 { $1 } - | ArgDecls1 ',' { $1 } - ; - -ArgDecls1 -> Result>, ()> - : ArgDecls1 ',' ArgDecl { flatten($1, $3) } - | ArgDecl { Ok(vec![$1?]) } - ; - -ArgDecl -> Result, ()> - : Ident ':' TySpec { Ok(ArgDecl { name: $1?, ty: $3?, metadata: () }) } - ; - -TySpec -> Result, ()> - : Ident { Ok(TySpec { kind: TySpecKind::Ident($1?), span: $span, }) } - | '[' TySpec ']' { Ok(TySpec { kind: TySpecKind::Seq(Box::new($2?)), span: $span, }) } - | '(' TySpecList ')' { Ok(TySpec { kind: TySpecKind::Tuple($2?), span: $span, }) } - ; - -TySpecList -> Result>, ()> - : TySpec { Ok(vec![$1?]) } - | TySpecList ',' TySpec { - let mut __tmp = $1?; - __tmp.push($3?); - Ok(__tmp) - } - ; - -Args -> Result, ()> - : PosArgsTrailingComma KwArgs { Ok(Args { posargs: $1?, kwargs: $2?, span: $span, metadata: (), }) } - | KwArgs { Ok(Args { posargs: Vec::new(), kwargs: $1?, span: $span, metadata: (), }) } - | PosArgs { Ok(Args { posargs: $1?, kwargs: Vec::new(), span: $span, metadata: (), }) } - ; - -KwArgValue -> Result, ()> - : Ident '=' Expr - { - Ok(KwArgValue { - name: $1?, - value: $3?, - span: $span, - metadata: () - }) - } - ; - -KwArgs -> Result>, ()> - : KwArgsTrailingComma { $1 } - | KwArgsNoComma { $1 } - ; - -KwArgsTrailingComma -> Result>, ()> - : KwArgValue ',' { Ok(vec![$1?]) } - | KwArgsTrailingComma KwArgValue ',' { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - ; - -KwArgsNoComma -> Result>, ()> - : KwArgValue { Ok(vec![$1?]) } - | KwArgsTrailingComma KwArgValue { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - ; - - -PosArgs -> Result>, ()> - : PosArgsTrailingComma { $1 } - | PosArgsNoComma { $1 } - ; - -PosArgsTrailingComma -> Result>, ()> - : Expr ',' { Ok(vec![$1?]) } - | PosArgsTrailingComma Expr ',' { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - ; - -PosArgsNoComma -> Result>, ()> - : { Ok(Vec::new()) } - | Expr { Ok(vec![$1?]) } - | PosArgsTrailingComma Expr - { - let mut __tmp = $1?; - __tmp.push($2?); - Ok(__tmp) - } - ; -%% - -use crate::ast::*; -use crate::parse::ParseMetadata; From 81af64bcf90ab48e4a0b0e54ed46da1ac212428a Mon Sep 17 00:00:00 2001 From: Rohan Kumar Date: Thu, 30 Apr 2026 11:00:26 -0700 Subject: [PATCH 6/6] fix clippy --- core/compiler/src/antlr.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/core/compiler/src/antlr.rs b/core/compiler/src/antlr.rs index 466ac7d..738e47f 100644 --- a/core/compiler/src/antlr.rs +++ b/core/compiler/src/antlr.rs @@ -2,7 +2,6 @@ use std::cell::RefCell; use std::path::PathBuf; use std::rc::Rc; -use antlr_rust::TidExt; use antlr_rust::common_token_stream::CommonTokenStream; use antlr_rust::error_listener::ErrorListener; use antlr_rust::parser_rule_context::ParserRuleContext;