impl check missing return statement in block

Author: paulzfm

TestCases/S2/result/returnerror.result

@@ -0,0 +1,3 @@
+*** Error at (2,16): missing return statement: control reaches end of non-void block
+*** Error at (4,21): missing return statement: control reaches end of non-void block
+*** Error at (10,24): missing return statement: control reaches end of non-void block

TestCases/S2/returnerror.decaf

@@ -0,0 +1,19 @@
+class Main {
+    int fun1() { }
+
+    int fun2(int x) {
+        while (true) {
+            if (x == 1) return 3;
+        }
+    }
+
+    int abs_fun(int x) {
+        if (x < 0)
+            return -x;
+        else if (x >= 0)
+            return x;
+    }
+
+    static void main() {
+    }
+}

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

@@ -0,0 +1,25 @@
+package decaf.annot
+
+sealed trait Flag extends Annot
+
+case object Yes extends Flag
+
+case object No extends Flag
+
+object FlagImplicit {
+
+  implicit class FlagAnnotatedHasFlag(self: Annotated[Flag]) {
+    def flag: Flag = self.annot
+
+    def yes: Boolean = self.annot match {
+      case Yes => true
+      case No => false
+    }
+
+    def no: Boolean = self.annot match {
+      case Yes => false
+      case No => true
+    }
+  }
+
+}

src/main/scala/decaf/error/Errors.scala

@@ -69,6 +69,9 @@ class BadPrintArgError(k: Int, actual: Type, pos: Pos)
 class BadReturnTypeError(expected: Type, actual: Type, pos: Pos)
   extends Error(s"incompatible return: $actual given, $expected expected", pos)
 
+class MissingReturnError(pos: Pos)
+  extends Error("missing return statement: control reaches end of non-void block", pos)
+
 class IncompatUnOpError(op: String, exprType: Type, pos: Pos)
   extends Error(s"incompatible operand: $op $exprType", pos)
 

src/main/scala/decaf/tree/TypedTree.scala

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

src/main/scala/decaf/typecheck/Namer.scala

@@ -177,7 +177,7 @@ class Namer extends Phase[Tree, Typed.Tree]("namer") with Util {
                 if (!isStatic) formalCtx.declare(LocalVarSymbol.thisVar(ctx.currentClass.typ, id.pos))
                 val typedParams = params.flatMap { resolveLocalVarDef(_)(formalCtx, true) }
                 val funType = FunType(typedParams.map(_.typeLit.typ), retType)
-                if (funType <= suspect.typ) { // override success TODO check spec
+                if (funType <= suspect.typ) { // override success
                   val symbol = new MethodSymbol(m, funType, formalScope, ctx.currentClass, Some(suspect))
                   ctx.declare(symbol)
                   val block = resolveBlock(body)(formalCtx)
@@ -223,6 +223,8 @@ class Namer extends Phase[Tree, Typed.Tree]("namer") with Util {
     resolved.map(_.setPos(field.pos))
   }
 
+  implicit val noReturn: Flag = No
+
   def resolveBlock(block: Block)(implicit ctx: ScopeContext): Typed.Block = {
     val local = ctx.open(new LocalScope)
     val ss = block.stmts.map { resolveStmt(_)(local) }

src/main/scala/decaf/typecheck/Typer.scala

@@ -3,6 +3,7 @@ package decaf.typecheck
 import decaf.annot.ScopeImplicit._
 import decaf.annot.SymbolImplicit._
 import decaf.annot.TypeImplicit._
+import decaf.annot.FlagImplicit._
 import decaf.annot._
 import decaf.driver.{Config, Phase}
 import decaf.error._
@@ -61,11 +62,13 @@ class Typer extends Phase[Tree, Tree]("typer") with Util {
         val ctx = global.open(symbol.scope)
         val checkedFields = fields.map {
           case v: VarDef => v
-          case f @ MethodDef(id, params, returnType, body, isStatic) =>
-            val formalCtx = ctx.open(f.symbol.scope)
+          case m @ MethodDef(id, params, returnType, body, isStatic) =>
+            val formalCtx = ctx.open(m.symbol.scope)
             val checkedBody = checkBlock(body)(formalCtx)
-            // FIXME check every path is returned, if its return type is not void
-            MethodDef(id, params, returnType, checkedBody, isStatic)(f.symbol).setPos(f.pos)
+            // Check if the body always returns a value, when the method is non-void
+            if (!m.symbol.returnType.isVoidType && checkedBody.no)
+              issue(new MissingReturnError(checkedBody.pos))
+            MethodDef(id, params, returnType, checkedBody, isStatic)(m.symbol).setPos(m.pos)
         }
         ClassDef(id, parent, checkedFields)(symbol).setPos(clazz.pos)
     }
@@ -96,10 +99,17 @@ class Typer extends Phase[Tree, Tree]("typer") with Util {
     }
     val local = ctx.open(scope)
     val ss = block.stmts.map { checkStmt(_)(local, insideLoop) }
-    Block(ss).setPos(block.pos)
+    val ret = if (ss.isEmpty) No else ss.last match {
+      case c: ControlFlowStmt => c.flag // a block returns a value if its last statement does so
+      case _ => No
+    }
+
+    Block(ss)(ret).setPos(block.pos)
   }
 
   def checkStmt(stmt: Stmt)(implicit ctx: ScopeContext, insideLoop: Boolean): Stmt = {
+    implicit val noReturn: Flag = No
+
     val checked = stmt match {
       case block: Block => checkBlock(block)
 
@@ -126,7 +136,9 @@ class Typer extends Phase[Tree, Tree]("typer") with Util {
         val c = checkTestExpr(cond)
         val t = checkBlock(trueBranch)
         val f = falseBranch.map(checkBlock)
-        If(c, t, f)
+        // if-stmt returns a value if both branches return
+        val ret = if (t.yes && f.isDefined && f.get.yes) Yes else No
+        If(c, t, f)(ret)
 
       case While(cond, body) =>
         val c = checkTestExpr(cond)
@@ -152,7 +164,7 @@ class Typer extends Phase[Tree, Tree]("typer") with Util {
         }
         val actual = e.map(_.typ).getOrElse(VoidType)
         if (actual.noError && !(actual <= expected)) issue(new BadReturnTypeError(expected, actual, stmt.pos))
-        Return(e)
+        Return(e)(Yes) // returned
 
       case Print(exprs) =>
         val es = exprs.zipWithIndex.map {
@@ -315,7 +327,6 @@ class Typer extends Phase[Tree, Tree]("typer") with Util {
               if (ctx.currentMethod.isStatic) // member vars cannot be accessed in a static method
                 issue(new RefNonStaticError(id, ctx.currentMethod.name, expr.pos))
               MemberVar(This(), v)(v.typ)
-            // TODO report error: method and types are not allowed here
             case _ => issue(new UndeclVarError(id, expr.pos)); err
           }
           case None => issue(new UndeclVarError(id, expr.pos)); err
@@ -337,7 +348,6 @@ class Typer extends Phase[Tree, Tree]("typer") with Util {
                   if (!(ctx.currentClass.typ <= t)) // member vars are protected
                     issue(new FieldNotAccessError(id, t, expr.pos))
                   MemberVar(r, v)(v.typ)
-                // case m: MethodSymbol => TODO report error: method and types are not allowed here
                 case _ => issue(new FieldNotFoundError(id, t, expr.pos)); err
               }
               case None => issue(new FieldNotFoundError(id, t, expr.pos)); err