Modified type of return for better programmer experience (#827)

* Modified return's type for better programmer experience

* Loosened rules for Bottom type.

* Fixed problem in test case

* Actually include new test

* Improve error reporting when matching on Nothing or null

Author: supercooldave

src/tests/encore/match/nothing.enc

@@ -0,0 +1,9 @@
+active class Main
+  def main(args : [String]) : unit
+    match Nothing with
+      case Nothing =>
+        println("Until the typechecker gets clever enough, this won't compile")
+      end
+    end
+  end
+end

src/tests/encore/match/nothing.fail

@@ -0,0 +1 @@
+Not enough information to infer the type.

src/tests/encore/return/return.enc

@@ -9,7 +9,7 @@ active class Main
   end
   def c() : unit
     let
-      x = return(())
+      x : unit = return(())
     in
       ()
     end

src/tests/encore/return/return2.enc

@@ -0,0 +1,31 @@
+
+read class Config
+  def notbroke() : int
+    if true then
+      return 10
+    else
+      return 11
+    end
+  end
+  
+  def fixed() : int
+    match Nothing : Maybe[int] with
+      case Nothing => return 10
+      case Just(ice) => return 11
+    end
+  end
+
+  -- works
+  def other(x : bool) : int
+    match x with
+      case true => return 10
+      case false => return 11
+    end
+  end
+end
+
+active class Main
+  def main() : unit
+    println("{}",(new Config).notbroke())
+  end
+end

src/tests/encore/return/return2.out

@@ -0,0 +1 @@
+10

src/tests/encore/return/return3.enc

@@ -0,0 +1,32 @@
+
+active class Main
+  def skip() : unit
+    println("skip")
+  end
+
+  def baz() : int
+    if false then
+      return 10
+    else
+      this.skip()
+    end
+    10
+  end
+  
+  def main() : unit
+    println("{}", this.baz())
+  end
+  
+  def bar() : String
+    "bar"
+  end
+
+  def foo() : Maybe[int]
+    if true then
+      return Nothing : Maybe[int]
+    else
+      this.bar()
+    end
+    Just(11)
+  end
+end

src/tests/encore/return/return3.out

@@ -0,0 +1,2 @@
+skip
+10

src/tests/encore/return/return4.enc

@@ -0,0 +1,32 @@
+
+active class Main
+  def skip() : unit
+    println("skip")
+  end
+
+  def baz() : int
+    if false then
+      return 10
+    else
+      this.skip()
+    end
+    10
+  end
+  
+  def main() : unit
+    println("{}", this.baz())
+  end
+  
+  def bar() : String
+    "bar"
+  end
+
+  def foo() : Maybe[int]
+    if true then
+      return Nothing
+    else
+      this.bar()
+    end
+    Just(11)
+  end
+end

src/tests/encore/return/return4.out

@@ -0,0 +1,2 @@
+skip
+10

src/types/Typechecker/TypeError.hs

@@ -511,7 +511,8 @@ instance Show Error where
         printf "Unbound function variable '%s'" (show name)
     show (NonFunctionTypeError ty) =
         printf "Cannot use value of type '%s' as a function" (show ty)
-    show BottomTypeInferenceError = "Cannot infer type of 'Nothing'"
+    show BottomTypeInferenceError = "Not enough information to infer the type.\n" ++ 
+        "Try adding more type information."
     show IfInferenceError = "Cannot infer result type of if-statement"
     show (IfBranchMismatchError ty1 ty2) =
         "Type mismatch in different branches of if-statement:\n" ++

src/types/Typechecker/Typechecker.hs

@@ -1016,10 +1016,9 @@ instance Checkable Expr where
         when (null clauses) $
           tcError EmptyMatchClauseError
         eArg <- typecheck arg
+        checkMatchArgument eArg
         let argType = AST.getType eArg
-        when (isActiveSingleType argType) $
-          unless (isThisAccess arg) $
-            tcError ActiveMatchError
+
         eClauses <- mapM (checkClause argType) clauses
         checkForPrivateExtractors eArg (map mcpattern eClauses)
         resultType <- checkAllHandlersSameType eClauses
@@ -1028,6 +1027,16 @@ instance Checkable Expr where
             eClauses' = map updateClauseType eClauses
         return $ setType resultType match {arg = eArg, clauses = eClauses'}
       where
+        checkMatchArgument arg = do
+          let argType = AST.getType arg
+          when (isActiveSingleType argType) $
+            unless (isThisAccess arg) $
+              tcError ActiveMatchError
+          when (any isBottomType (typeComponents argType)) $
+               pushError arg BottomTypeInferenceError
+          when (any isNullType (typeComponents argType)) $
+               pushError arg NullTypeInferenceError
+
         checkForPrivateExtractors arg = mapM (checkForPrivateExtractor arg)
 
         checkForPrivateExtractor matchArg p@ExtractorPattern{name, arg} = do
@@ -1288,7 +1297,7 @@ instance Checkable Expr where
     --  E |- expr : t
     --  E |- currentMethod : _ -> t
     -- -----------------------------
-    --  E |- return expr : t
+    --  E |- return expr : _|_
     doTypecheck ret@(Return {val}) =
         do eVal <- typecheck val
            context <- asks currentExecutionContext
@@ -1302,7 +1311,7 @@ instance Checkable Expr where
            unlessM (eType `subtypeOf` ty) $
              pushError ret $ ExpectingOtherTypeError
                 (show ty ++ " (type of the enclosing method or function)") eType
-           return $ setType eType ret {val = eVal}
+           return $ setType bottomType ret {val = eVal}
 
     --  isStreaming(currentMethod)
     -- ----------------------------
@@ -2009,10 +2018,7 @@ coercedInto actual expected
       unless (canBeNull expected) $
         tcError $ CannotBeNullError expected
       return expected
-  | isBottomType actual = do
-      when (any isBottomType $ typeComponents expected) $
-        tcError BottomTypeInferenceError
-      return expected
+  | isBottomType actual = return expected
   | isBottomType expected =
       tcError BottomTypeInferenceError
   | otherwise = do

src/types/Typechecker/Util.hs

@@ -554,7 +554,7 @@ isUnifiableWith ty types
         tyUniable <- typeIsUnifiable ty
         tysUniable <- allM typeIsUnifiable types
         return $ tyUniable && tysUniable &&
-                 not (isNullType ty) && not (isBottomType ty)
+                 not (isNullType ty)
 
 unifyTypes :: [Type] -> TypecheckM (Maybe Type)
 unifyTypes tys = do
@@ -611,6 +611,7 @@ doUnifyTypes inter args@(ty:tys)
 
 uniquifyTypeVars :: [Type] -> Type -> TypecheckM Type
 uniquifyTypeVars params = typeMapM (uniquifyTypeVar params)
+
 uniquifyTypeVar :: [Type] -> Type -> TypecheckM Type
 uniquifyTypeVar params ty
   | isTypeVar ty = do