feat: type checker without satisfies implemented

Co-Authored-By: jt2622
2025-02-06 20:26:15 +00:00
parent 88ec08a023
commit 6548d895d5
4 changed files with 277 additions and 121 deletions
--- a/src/main/wacc/ast.scala
+++ b/src/main/wacc/ast.scala
@@ -9,7 +9,9 @@ import cats.data.NonEmptyList

 object ast {
  // Expressions
-  sealed trait Expr extends RValue
+  sealed trait Expr extends RValue {
+    val pos: Position
+  }
  sealed trait Expr1 extends Expr
  sealed trait Expr2 extends Expr1
  sealed trait Expr3 extends Expr2
@@ -18,43 +20,43 @@ object ast {
  sealed trait Expr6 extends Expr5

  // Atoms
-  case class IntLiter(v: Int)(pos: Position) extends Expr6
+  case class IntLiter(v: Int)(val pos: Position) extends Expr6
  object IntLiter extends ParserBridgePos1[Int, IntLiter]
-  case class BoolLiter(v: Boolean)(pos: Position) extends Expr6
+  case class BoolLiter(v: Boolean)(val pos: Position) extends Expr6
  object BoolLiter extends ParserBridgePos1[Boolean, BoolLiter]
-  case class CharLiter(v: Char)(pos: Position) extends Expr6
+  case class CharLiter(v: Char)(val pos: Position) extends Expr6
  object CharLiter extends ParserBridgePos1[Char, CharLiter]
-  case class StrLiter(v: String)(pos: Position) extends Expr6
+  case class StrLiter(v: String)(val pos: Position) extends Expr6
  object StrLiter extends ParserBridgePos1[String, StrLiter]
-  case class PairLiter()(pos: Position) extends Expr6
+  case class PairLiter()(val pos: Position) extends Expr6
  object PairLiter extends ParserBridgePos0[PairLiter]
-  case class Ident(v: String, var uid: Int = -1)(pos: Position) extends Expr6 with LValue
+  case class Ident(v: String, var uid: Int = -1)(val pos: Position) extends Expr6 with LValue
  object Ident extends ParserBridgePos1[String, Ident] {
    def apply(v: String)(pos: Position): Ident = new Ident(v)(pos)
  }
-  case class ArrayElem(name: Ident, indices: NonEmptyList[Expr])(pos: Position)
+  case class ArrayElem(name: Ident, indices: NonEmptyList[Expr])(val pos: Position)
      extends Expr6
      with LValue
  object ArrayElem extends ParserBridgePos1[NonEmptyList[Expr], Ident => ArrayElem] {
    def apply(a: NonEmptyList[Expr])(pos: Position): Ident => ArrayElem =
      name => ArrayElem(name, a)(pos)
  }
-  case class Parens(expr: Expr)(pos: Position) extends Expr6
+  case class Parens(expr: Expr)(val pos: Position) extends Expr6
  object Parens extends ParserBridgePos1[Expr, Parens]

  // Unary operators
  sealed trait UnaryOp extends Expr {
    val x: Expr
  }
-  case class Negate(x: Expr6)(pos: Position) extends Expr6 with UnaryOp
+  case class Negate(x: Expr6)(val pos: Position) extends Expr6 with UnaryOp
  object Negate extends ParserBridgePos1[Expr6, Negate]
-  case class Not(x: Expr6)(pos: Position) extends Expr6 with UnaryOp
+  case class Not(x: Expr6)(val pos: Position) extends Expr6 with UnaryOp
  object Not extends ParserBridgePos1[Expr6, Not]
-  case class Len(x: Expr6)(pos: Position) extends Expr6 with UnaryOp
+  case class Len(x: Expr6)(val pos: Position) extends Expr6 with UnaryOp
  object Len extends ParserBridgePos1[Expr6, Len]
-  case class Ord(x: Expr6)(pos: Position) extends Expr6 with UnaryOp
+  case class Ord(x: Expr6)(val pos: Position) extends Expr6 with UnaryOp
  object Ord extends ParserBridgePos1[Expr6, Ord]
-  case class Chr(x: Expr6)(pos: Position) extends Expr6 with UnaryOp
+  case class Chr(x: Expr6)(val pos: Position) extends Expr6 with UnaryOp
  object Chr extends ParserBridgePos1[Expr6, Chr]

  // Binary operators
@@ -62,59 +64,59 @@ object ast {
    val x: Expr
    val y: Expr
  }
-  case class Add(x: Expr4, y: Expr5)(pos: Position) extends Expr4 with BinaryOp
+  case class Add(x: Expr4, y: Expr5)(val pos: Position) extends Expr4 with BinaryOp
  object Add extends ParserBridgePos2[Expr4, Expr5, Add]
-  case class Sub(x: Expr4, y: Expr5)(pos: Position) extends Expr4 with BinaryOp
+  case class Sub(x: Expr4, y: Expr5)(val pos: Position) extends Expr4 with BinaryOp
  object Sub extends ParserBridgePos2[Expr4, Expr5, Sub]
-  case class Mul(x: Expr5, y: Expr6)(pos: Position) extends Expr5 with BinaryOp
+  case class Mul(x: Expr5, y: Expr6)(val pos: Position) extends Expr5 with BinaryOp
  object Mul extends ParserBridgePos2[Expr5, Expr6, Mul]
-  case class Div(x: Expr5, y: Expr6)(pos: Position) extends Expr5 with BinaryOp
+  case class Div(x: Expr5, y: Expr6)(val pos: Position) extends Expr5 with BinaryOp
  object Div extends ParserBridgePos2[Expr5, Expr6, Div]
-  case class Mod(x: Expr5, y: Expr6)(pos: Position) extends Expr5 with BinaryOp
+  case class Mod(x: Expr5, y: Expr6)(val pos: Position) extends Expr5 with BinaryOp
  object Mod extends ParserBridgePos2[Expr5, Expr6, Mod]
-  case class Greater(x: Expr4, y: Expr4)(pos: Position) extends Expr3 with BinaryOp
+  case class Greater(x: Expr4, y: Expr4)(val pos: Position) extends Expr3 with BinaryOp
  object Greater extends ParserBridgePos2[Expr4, Expr4, Greater]
-  case class GreaterEq(x: Expr4, y: Expr4)(pos: Position) extends Expr3 with BinaryOp
+  case class GreaterEq(x: Expr4, y: Expr4)(val pos: Position) extends Expr3 with BinaryOp
  object GreaterEq extends ParserBridgePos2[Expr4, Expr4, GreaterEq]
-  case class Less(x: Expr4, y: Expr4)(pos: Position) extends Expr3 with BinaryOp
+  case class Less(x: Expr4, y: Expr4)(val pos: Position) extends Expr3 with BinaryOp
  object Less extends ParserBridgePos2[Expr4, Expr4, Less]
-  case class LessEq(x: Expr4, y: Expr4)(pos: Position) extends Expr3 with BinaryOp
+  case class LessEq(x: Expr4, y: Expr4)(val pos: Position) extends Expr3 with BinaryOp
  object LessEq extends ParserBridgePos2[Expr4, Expr4, LessEq]
-  case class Eq(x: Expr3, y: Expr3)(pos: Position) extends Expr2 with BinaryOp
+  case class Eq(x: Expr3, y: Expr3)(val pos: Position) extends Expr2 with BinaryOp
  object Eq extends ParserBridgePos2[Expr3, Expr3, Eq]
-  case class Neq(x: Expr3, y: Expr3)(pos: Position) extends Expr2 with BinaryOp
+  case class Neq(x: Expr3, y: Expr3)(val pos: Position) extends Expr2 with BinaryOp
  object Neq extends ParserBridgePos2[Expr3, Expr3, Neq]
-  case class And(x: Expr2, y: Expr1)(pos: Position) extends Expr1 with BinaryOp
+  case class And(x: Expr2, y: Expr1)(val pos: Position) extends Expr1 with BinaryOp
  object And extends ParserBridgePos2[Expr2, Expr1, And]
-  case class Or(x: Expr1, y: Expr)(pos: Position) extends Expr with BinaryOp
+  case class Or(x: Expr1, y: Expr)(val pos: Position) extends Expr with BinaryOp
  object Or extends ParserBridgePos2[Expr1, Expr, Or]

  // Types
  sealed trait Type
  sealed trait BaseType extends Type with PairElemType
-  case class IntType()(pos: Position) extends BaseType
+  case class IntType()(val pos: Position) extends BaseType
  object IntType extends ParserBridgePos0[IntType]
-  case class BoolType()(pos: Position) extends BaseType
+  case class BoolType()(val pos: Position) extends BaseType
  object BoolType extends ParserBridgePos0[BoolType]
-  case class CharType()(pos: Position) extends BaseType
+  case class CharType()(val pos: Position) extends BaseType
  object CharType extends ParserBridgePos0[CharType]
-  case class StringType()(pos: Position) extends BaseType
+  case class StringType()(val pos: Position) extends BaseType
  object StringType extends ParserBridgePos0[StringType]
-  case class ArrayType(elemType: Type, dimensions: Int)(pos: Position)
+  case class ArrayType(elemType: Type, dimensions: Int)(val pos: Position)
      extends Type
      with PairElemType
  object ArrayType extends ParserBridgePos1[Int, Type => ArrayType] {
    def apply(a: Int)(pos: Position): Type => ArrayType = elemType => ArrayType(elemType, a)(pos)
  }
-  case class PairType(fst: PairElemType, snd: PairElemType)(pos: Position) extends Type
+  case class PairType(fst: PairElemType, snd: PairElemType)(val pos: Position) extends Type
  object PairType extends ParserBridgePos2[PairElemType, PairElemType, PairType]

  sealed trait PairElemType
-  case class UntypedPairType()(pos: Position) extends PairElemType
+  case class UntypedPairType()(val pos: Position) extends PairElemType
  object UntypedPairType extends ParserBridgePos0[UntypedPairType]

  // waccadoodledo
-  case class Program(funcs: List[FuncDecl], main: NonEmptyList[Stmt])(pos: Position)
+  case class Program(funcs: List[FuncDecl], main: NonEmptyList[Stmt])(val pos: Position)
  object Program extends ParserBridgePos2[List[FuncDecl], NonEmptyList[Stmt], Program]

  // Function Definitions
@@ -123,7 +125,7 @@ object ast {
      name: Ident,
      params: List[Param],
      body: NonEmptyList[Stmt]
-  )(pos: Position)
+  )(val pos: Position)
  object FuncDecl
      extends ParserBridgePos2[
        List[Param],
@@ -136,50 +138,52 @@ object ast {
      (returnType, name) => FuncDecl(returnType, name, params, body)(pos)
  }

-  case class Param(paramType: Type, name: Ident)(pos: Position)
+  case class Param(paramType: Type, name: Ident)(val pos: Position)
  object Param extends ParserBridgePos2[Type, Ident, Param]

  // Statements
  sealed trait Stmt
-  case class Skip()(pos: Position) extends Stmt
+  case class Skip()(val pos: Position) extends Stmt
  object Skip extends ParserBridgePos0[Skip]
-  case class VarDecl(varType: Type, name: Ident, value: RValue)(pos: Position) extends Stmt
+  case class VarDecl(varType: Type, name: Ident, value: RValue)(val pos: Position) extends Stmt
  object VarDecl extends ParserBridgePos3[Type, Ident, RValue, VarDecl]
-  case class Assign(lhs: LValue, value: RValue)(pos: Position) extends Stmt
+  case class Assign(lhs: LValue, value: RValue)(val pos: Position) extends Stmt
  object Assign extends ParserBridgePos2[LValue, RValue, Assign]
-  case class Read(lhs: LValue)(pos: Position) extends Stmt
+  case class Read(lhs: LValue)(val pos: Position) extends Stmt
  object Read extends ParserBridgePos1[LValue, Read]
-  case class Free(expr: Expr)(pos: Position) extends Stmt
+  case class Free(expr: Expr)(val pos: Position) extends Stmt
  object Free extends ParserBridgePos1[Expr, Free]
-  case class Return(expr: Expr)(pos: Position) extends Stmt
+  case class Return(expr: Expr)(val pos: Position) extends Stmt
  object Return extends ParserBridgePos1[Expr, Return]
-  case class Exit(expr: Expr)(pos: Position) extends Stmt
+  case class Exit(expr: Expr)(val pos: Position) extends Stmt
  object Exit extends ParserBridgePos1[Expr, Exit]
-  case class Print(expr: Expr, newline: Boolean)(pos: Position) extends Stmt
+  case class Print(expr: Expr, newline: Boolean)(val pos: Position) extends Stmt
  object Print extends ParserBridgePos2[Expr, Boolean, Print]
  case class If(cond: Expr, thenStmt: NonEmptyList[Stmt], elseStmt: NonEmptyList[Stmt])(
-      pos: Position
+      val pos: Position
  ) extends Stmt
  object If extends ParserBridgePos3[Expr, NonEmptyList[Stmt], NonEmptyList[Stmt], If]
-  case class While(cond: Expr, body: NonEmptyList[Stmt])(pos: Position) extends Stmt
+  case class While(cond: Expr, body: NonEmptyList[Stmt])(val pos: Position) extends Stmt
  object While extends ParserBridgePos2[Expr, NonEmptyList[Stmt], While]
-  case class Block(stmt: NonEmptyList[Stmt])(pos: Position) extends Stmt
+  case class Block(stmt: NonEmptyList[Stmt])(val pos: Position) extends Stmt
  object Block extends ParserBridgePos1[NonEmptyList[Stmt], Block]

-  sealed trait LValue
+  sealed trait LValue {
+    val pos: Position
+  }

  sealed trait RValue
-  case class ArrayLiter(elems: List[Expr])(pos: Position) extends RValue
+  case class ArrayLiter(elems: List[Expr])(val pos: Position) extends RValue
  object ArrayLiter extends ParserBridgePos1[List[Expr], ArrayLiter]
-  case class NewPair(fst: Expr, snd: Expr)(pos: Position) extends RValue
+  case class NewPair(fst: Expr, snd: Expr)(val pos: Position) extends RValue
  object NewPair extends ParserBridgePos2[Expr, Expr, NewPair]
-  case class Call(name: Ident, args: List[Expr])(pos: Position) extends RValue
+  case class Call(name: Ident, args: List[Expr])(val pos: Position) extends RValue
  object Call extends ParserBridgePos2[Ident, List[Expr], Call]

  sealed trait PairElem extends LValue with RValue
-  case class Fst(elem: LValue)(pos: Position) extends PairElem
+  case class Fst(elem: LValue)(val pos: Position) extends PairElem
  object Fst extends ParserBridgePos1[LValue, Fst]
-  case class Snd(elem: LValue)(pos: Position) extends PairElem
+  case class Snd(elem: LValue)(val pos: Position) extends PairElem
  object Snd extends ParserBridgePos1[LValue, Snd]

  // Parser bridges