From 292551aca0b290c7457e4b97723753ad7d0f9e90 Mon Sep 17 00:00:00 2001 From: Gleb Koval Date: Fri, 31 Jan 2025 20:01:44 +0000 Subject: [PATCH] refactor: format AST to follow BNF order --- src/main/wacc/ast.scala | 110 ++++++++++++++++------------------------ 1 file changed, 45 insertions(+), 65 deletions(-) diff --git a/src/main/wacc/ast.scala b/src/main/wacc/ast.scala index 1e85989..8538e81 100644 --- a/src/main/wacc/ast.scala +++ b/src/main/wacc/ast.scala @@ -2,15 +2,7 @@ package wacc import parsley.generic._ -// TODO - Note that I have opted for object Add extends ParserBridge2[Expr5, Expr6, Add] instead of object Add extends ParserBridge2[Expr5, Expr6, Expr5] -// Reason: Better type safety / pattern matching ? We can change this at any time. -// For consistency in case objects you may see I extended the parser bridge pattern with ".type" -// Personally I am not a fan - -// TODO - Obviously layout issues, could follow Haskell interlude style - object ast { - // Expressions sealed trait Expr extends RValue sealed trait Expr1 extends Expr @@ -20,42 +12,24 @@ object ast { sealed trait Expr5 extends Expr4 sealed trait Expr6 extends Expr5 - case class Parens(expr: Expr) extends Expr6 - object Parens extends ParserBridge1[Expr, Parens] - + // Atoms case class IntLiter(v: Int) extends Expr6 object IntLiter extends ParserBridge1[Int, IntLiter] - case class BoolLiter(v: Boolean) extends Expr6 object BoolLiter extends ParserBridge1[Boolean, BoolLiter] - case class CharLiter(v: Char) extends Expr6 object CharLiter extends ParserBridge1[Char, CharLiter] - case class StrLiter(v: String) extends Expr6 object StrLiter extends ParserBridge1[String, StrLiter] - case object PairLiter extends Expr6 with ParserBridge0[PairLiter.type] - case class Ident(v: String) extends Expr6 with LValue object Ident extends ParserBridge1[String, Ident] - case class ArrayElem(name: Ident, indices: List[Expr]) extends Expr6 with LValue object ArrayElem extends ParserBridge2[Ident, List[Expr], ArrayElem] - - // R values - sealed trait RValue - - case class ArrayLiter(elems: List[Expr]) extends RValue - object ArrayLiter extends ParserBridge1[List[Expr], ArrayLiter] - - case class NewPair(fst: Expr, snd: Expr) extends RValue - object NewPair extends ParserBridge2[Expr, Expr, NewPair] - - case class Call(name: Ident, args: List[Expr]) extends RValue - object Call extends ParserBridge2[Ident, List[Expr], Call] + case class Parens(expr: Expr) extends Expr6 + object Parens extends ParserBridge1[Expr, Parens] // Unary operators case class Negate(x: Expr6) extends Expr6 @@ -97,6 +71,40 @@ object ast { case class Or(x: Expr1, y: Expr1) extends Expr object Or extends ParserBridge2[Expr1, Expr1, Or] + // Types + sealed trait Type + sealed trait BaseType extends Type with PairElemType + case object IntType extends BaseType with ParserBridge0[IntType.type] + case object BoolType extends BaseType with ParserBridge0[BoolType.type] + case object CharType extends BaseType with ParserBridge0[CharType.type] + case object StringType extends BaseType with ParserBridge0[StringType.type] + case class ArrayType(elemType: Type) extends Type with PairElemType + object ArrayType extends ParserBridge1[Type, ArrayType] + case class PairType(fst: PairElemType, snd: PairElemType) extends Type + object PairType extends ParserBridge2[PairElemType, PairElemType, PairType] + + sealed trait PairElemType + case object UntypedPairType + extends PairElemType + with ParserBridge0[UntypedPairType.type] + + // waccadoodledo + case class Program(funcs: List[FuncDecl], main: Stmt) + object Program extends ParserBridge2[List[FuncDecl], Stmt, Program] + + // Function Definitions + case class FuncDecl( + returnType: Type, + name: Ident, + params: List[Param], + body: Stmt + ) + object FuncDecl + extends ParserBridge4[Type, Ident, List[Param], Stmt, FuncDecl] + + case class Param(paramType: Type, name: Ident) + object Param extends ParserBridge2[Type, Ident, Param] + // Statements sealed trait Stmt case object Skip extends Stmt with ParserBridge0[Skip.type] @@ -121,47 +129,19 @@ object ast { case class SeqStmt(stmt1: Stmt, stmt2: Stmt) extends Stmt object SeqStmt extends ParserBridge2[Stmt, Stmt, SeqStmt] - // LValues sealed trait LValue - // Pair Elements + sealed trait RValue + case class ArrayLiter(elems: List[Expr]) extends RValue + object ArrayLiter extends ParserBridge1[List[Expr], ArrayLiter] + case class NewPair(fst: Expr, snd: Expr) extends RValue + object NewPair extends ParserBridge2[Expr, Expr, NewPair] + case class Call(name: Ident, args: List[Expr]) extends RValue + object Call extends ParserBridge2[Ident, List[Expr], Call] + sealed trait PairElem extends LValue with RValue case class Fst(elem: LValue) extends PairElem object Fst extends ParserBridge1[LValue, Fst] case class Snd(elem: LValue) extends PairElem object Snd extends ParserBridge1[LValue, Snd] - - // Function Defns - case class FuncDecl( - returnType: Type, - name: Ident, - params: List[Param], - body: Stmt - ) - object FuncDecl - extends ParserBridge4[Type, Ident, List[Param], Stmt, FuncDecl] - - case class Param(paramType: Type, name: Ident) - object Param extends ParserBridge2[Type, Ident, Param] - - // waccadoodledo - case class Program(funcs: List[FuncDecl], main: Stmt) - object Program extends ParserBridge2[List[FuncDecl], Stmt, Program] - - // Types - sealed trait Type - sealed trait BaseType extends Type with PairElemType - case object IntType extends BaseType with ParserBridge0[IntType.type] - case object BoolType extends BaseType with ParserBridge0[BoolType.type] - case object CharType extends BaseType with ParserBridge0[CharType.type] - case object StringType extends BaseType with ParserBridge0[StringType.type] - case class ArrayType(elemType: Type) extends Type with PairElemType - object ArrayType extends ParserBridge1[Type, ArrayType] - case class PairType(fst: PairElemType, snd: PairElemType) extends Type - object PairType extends ParserBridge2[PairElemType, PairElemType, PairType] - - sealed trait PairElemType - case object UntypedPairType - extends PairElemType - with ParserBridge0[UntypedPairType.type] }