refactor: format AST to follow BNF order

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
+  // Atoms
-  object Parens extends ParserBridge1[Expr, Parens]
-
   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]
-
+  case class Parens(expr: Expr) extends Expr6
-  // R values
+  object Parens extends ParserBridge1[Expr, Parens]
-  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]
 
   // 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]
 }