update namer and typer to match the new testcases

Author: paulzfm

src/main/scala/decaf/annot/Flag.scala

@@ -1,5 +1,7 @@
 package decaf.annot
 
+import decaf.parsing.Pos
+
 import scala.collection.mutable
 
 /**
@@ -15,6 +17,8 @@ sealed trait Scope extends Annot {
 
   var owner: Owner = _
 
+  def isEmpty: Boolean = symbols.isEmpty
+
   def values: List[Item] = symbols.values.toList.sortBy(_.pos)
 
   def flatMap[T <: Item](p: Item => Option[T]): List[T] = symbols.values.flatMap(p).toList
@@ -33,6 +37,7 @@ sealed trait Scope extends Annot {
 
   def declare(symbol: Item): Unit = {
     symbols(symbol.name) = symbol
+    symbol.domain = this
   }
 
   def isLocalOrFormal: Boolean = false
@@ -76,6 +81,23 @@ class LocalScope extends Scope {
   val nestedScopes: mutable.ArrayBuffer[LocalScope] = new mutable.ArrayBuffer[LocalScope]
 }
 
+/**
+  * A symbol table, which is organized as a stack of scopes, maintained by {@link decaf.frontend.typecheck.Namer}.
+  * A typical full scope stack looks like the following:
+  * {{{
+  *     LocalScope   --- stack top (current scope)
+  *     ...          --- many nested local scopes
+  *     LocalScope
+  *     FormalScope
+  *     ClassScope
+  *     ...          --- many parent class scopes
+  *     ClassScope
+  *     GlobalScope  --- stack bottom
+  * }}}
+  * Make sure the global scope is always at the bottom, and NO class scope appears in neither formal nor local scope.
+  *
+  * @see Scope
+  */
 class ScopeContext private(global: GlobalScope, private val scopes: List[Scope], val currentScope: Scope,
                            val currentClass: ClassSymbol, val currentMethod: MethodSymbol) {
 
@@ -91,34 +113,46 @@ class ScopeContext private(global: GlobalScope, private val scopes: List[Scope],
   }
 
   /**
-    * Find a symbol by key. Search in all possible scopes while the predicate `p` holds, and returns the innermost
-    * result.
+    * Find a symbol by key. Search in all possible scopes while the predicate `cond` holds, and the found symbols
+    * satisfies `p`. Returns the innermost result.
     *
     * @param key    the key
-    * @param p      the predicate over the currently seeing scope
+    * @param cond   the predicate over the currently seeing scope
+    * @param p      the predicate over the suspect symbol
     * @param scopes all remaining scopes to be searched
     * @return innermost found symbol (if any)
     */
   @scala.annotation.tailrec
-  private def findWhile(key: String, p: Scope => Boolean, scopes: List[Scope] = scopes :+ global): Option[Symbol] =
+  private def findWhile(key: String, cond: Scope => Boolean = _ => true, p: Symbol => Boolean = _ => true,
+                        scopes: List[Scope] = scopes :+ global): Option[Symbol] =
     scopes match {
-      case Nil => if (!p(global)) None else global.find(key)
+      case Nil => None
       case s :: ss =>
-        if (!p(s)) None
+        if (!cond(s)) None
         else s.find(key) match {
-          case Some(symbol) => Some(symbol)
-          case None => findWhile(key, p, ss)
+          case Some(symbol) if p(symbol) => Some(symbol)
+          case _ => findWhile(key, cond, p, ss)
         }
     }
 
   /**
     * Lookup a symbol by key. By saying "lookup", the user expects that the symbol is found.
     * In this way, we will always search in all possible scopes and returns the innermost result.
     *
-    * @param key the key
+    * @param key symbol's name
     * @return innermost found symbol (if any)
     */
-  def lookup(key: String): Option[Symbol] = findWhile(key, _ => true)
+  def lookup(key: String): Option[Symbol] = findWhile(key)
+
+  /**
+    * Same with {@link #lookup} but we restrict the symbol's position to be before the given `pos`.
+    *
+    * @param key symbol's name
+    * @param pos position
+    * @return innermost found symbol before `pos` (if any)
+    */
+  def lookupBefore(key: String, pos: Pos): Option[Symbol] = findWhile(key, _ => true,
+    s => !(s.domain.isLocalOrFormal && s.pos >= pos))
 
   /**
     * Find if `key` conflicts with some already defined symbol. Rules:

src/main/scala/decaf/annot/Scope.scala

@@ -24,6 +24,8 @@ sealed trait Symbol extends Annot {
 
   def str: String
 
+  var domain: Scope = _
+
   override def toString: String = s"(${ pos.line },${ pos.column }) -> " + str
 }
 
@@ -76,7 +78,8 @@ class MethodSymbol(tree: SyntaxTree.MethodDef, val typ: FunType, val scope: Form
 
   override def pos: Pos = tree.pos
 
-  override def str: String = (if (isStatic) "static " else "") + s"function $name : " + typ.toString
+  override def str: String =
+    (if (tree.modifiers.isEmpty) "" else s"${ tree.modifiers } ") + s"function $name : " + typ.toString
 
   scope.owner = this
 

src/main/scala/decaf/annot/Symbol.scala

@@ -35,6 +35,8 @@ sealed trait Type extends Annot {
   def isVoidType: Boolean = false
 
   def isBaseType: Boolean = false
+
+  def isFuncType: Boolean = false
 }
 
 class BaseType extends Type {
@@ -92,7 +94,7 @@ case class ClassType(name: String, parent: Option[ClassType] = None) extends Typ
 
   override def isClassType: Boolean = true
 
-  override def toString: String = s"class : $name"
+  override def toString: String = s"class $name"
 }
 
 case class ArrayType(elemType: Type) extends Type {
@@ -106,7 +108,14 @@ case class ArrayType(elemType: Type) extends Type {
     case _ => false
   }
 
-  override def toString: String = s"$elemType[]"
+  override def toString: String = {
+    if (elemType.isFuncType) {
+      // NOTE: [] has higher priority than functions, so we must add extra parenthesis, e.g.
+      // `(int => int)[]` means an array of functions from integers to integers, but
+      // `int => int[]` means a function from integers to integer arrays
+      s"($elemType)[]"
+    } else s"$elemType[]"
+  }
 }
 
 case class FunType(params: List[Type], ret: Type) extends Type {
@@ -124,13 +133,15 @@ case class FunType(params: List[Type], ret: Type) extends Type {
     case _ => false
   }
 
+  override def isFuncType: Boolean = true
+
   override def toString: String = {
     val ps = params match {
       case Nil => "()"
       case t :: Nil => t.toString
       case ts => s"(${ ts.mkString(", ") })"
     }
-    s"$ps -> $ret"
+    s"$ps => $ret"
   }
 }
 

src/main/scala/decaf/annot/Type.scala

@@ -171,8 +171,7 @@ class Parser extends Phase[InputStream, Tree]("parser") {
       if (ctx.expr == null) theVar
       else {
         val init = ctx.expr.accept(ExprVisitor)
-        val ret = LocalVarDef(theVar.typeLit, theVar.id, Some(init)).setPos(theVar.pos)
-        ret.assignPos = getPos(ctx.ASSIGN.getSymbol)
+        val ret = LocalVarDef(theVar.typeLit, theVar.id, Some(init), getPos(ctx.ASSIGN.getSymbol)).setPos(theVar.pos)
         ret
       }
     }

src/main/scala/decaf/parsing/Parser.scala

@@ -10,13 +10,15 @@ object PrettyScope {
     case s: GlobalScope =>
       printer.writeln("GLOBAL SCOPE:")
       printer.withIndent {
-        s.values.foreach { symbol => printer.writeln(symbol.toString) }
+        if (s.isEmpty) printer.writeln("<empty>")
+        else s.values.foreach { symbol => printer.writeln(symbol.toString) }
         s.values.foreach { symbol => pretty(symbol.scope) }
       }
     case s: ClassScope =>
       printer.writeln(s"CLASS SCOPE OF '${ s.owner.name }':")
       printer.withIndent {
-        s.values.foreach { symbol => printer.writeln(symbol.toString) }
+        if (s.isEmpty) printer.writeln("<empty>")
+        else s.values.foreach { symbol => printer.writeln(symbol.toString) }
         s.values.foreach {
           case m: MethodSymbol => pretty(m.scope)
           case _ => // do not print
@@ -25,13 +27,15 @@ object PrettyScope {
     case s: FormalScope =>
       printer.writeln(s"FORMAL SCOPE OF '${ s.owner.name }':")
       printer.withIndent {
-        s.values.foreach { symbol => printer.writeln(symbol.toString) }
+        if (s.isEmpty) printer.writeln("<empty>")
+        else s.values.foreach { symbol => printer.writeln(symbol.toString) }
         pretty(s.nestedScope)
       }
     case s: LocalScope =>
       printer.writeln(s"LOCAL SCOPE:")
       printer.withIndent {
-        s.values.foreach { symbol => printer.writeln(symbol.toString) }
+        if (s.isEmpty) printer.writeln("<empty>")
+        else s.values.foreach { symbol => printer.writeln(symbol.toString) }
         s.nestedScopes.foreach(pretty)
       }
   }

src/main/scala/decaf/printing/PrettyScope.scala

@@ -183,6 +183,8 @@ object TreeNode {
   class Modifiers(val code: Int = 0, val pos: Pos = NoPos) {
     def isStatic: Boolean = (code & 1) == 1
 
+    def isEmpty: Boolean = code == 0
+
     private lazy val flags = if (isStatic) List("STATIC") else Nil
 
     override def toString: String = flags.mkString(" ")

src/main/scala/decaf/tree/TreeNode.scala

@@ -160,30 +160,31 @@ trait TreeTmpl {
     * }}}
     * Initialization is not supported.
     */
-  case class LocalVarDef(typeLit: TypeLit, id: Id, init: Option[Expr] = None)(implicit val annot: LocalVarAnnot)
+  case class LocalVarDef(typeLit: TypeLit, id: Id, init: Option[Expr] = None, assignPos: Pos = NoPos)
+                        (implicit val annot: LocalVarAnnot)
     extends Stmt with Var with Annotated[LocalVarAnnot] {
     type TypeLitType = TypeLit
 
-    var assignPos: Pos = NoPos
+    override def productArity: Int = 3
   }
 
-  /**
-    * Normal control flow statements.
-    *
-    * They should have the same type of annotation in a specialized tree.
-    */
-  trait ControlFlowStmt extends Stmt with Annotated[StmtAnnot]
-
   /**
     * Statement block:
     * {{{
     *   { <stmt1> <stmt2> ... }
     * }}}
     */
-  case class Block(stmts: List[Stmt] = Nil)(implicit val annot: StmtAnnot) extends ControlFlowStmt {
+  case class Block(stmts: List[Stmt] = Nil)(implicit val annot: BlockAnnot) extends Stmt with Annotated[BlockAnnot] {
     override def isEmpty: Boolean = stmts.isEmpty
   }
 
+  /**
+    * Normal control flow statements.
+    *
+    * They should have the same type of annotation in a specialized tree.
+    */
+  trait ControlFlowStmt extends Stmt with Annotated[StmtAnnot]
+
   /**
     * Assignment:
     * {{{
@@ -414,4 +415,5 @@ trait TreeTmpl {
     * Cast the given object `obj` into class type `to`.
     */
   case class ClassCast(obj: Expr, to: ClassRef)(implicit val annot: ExprAnnot) extends Expr
+
 }

src/main/scala/decaf/tree/TreeTmpl.scala

@@ -18,7 +18,7 @@ object TypedTree extends TreeTmpl {
   type LocalVarAnnot = LocalVarSymbol
   type MethodAnnot = MethodSymbol
   type TypeLitAnnot = Type
-  type StmtAnnot = Flag
+  type StmtAnnot = SyntaxTree.No
   type BlockAnnot = LocalScope
   type ExprAnnot = Type