Expand the no-return diagnostic

Turn on the noreturn diagnostic for cases where a reachable unreachable
could be encountered.  Previously, the diagnostic would not fire if the
function was marked noreturn and any of its reachable unreachable calls
were around.  While this makes sense from a SILGen perspective (it Just
Crashes tm), it is still wrong.  We need to diagnose *everything* that
has reachable unreachables.

Author: CodaFi

include/swift/AST/DiagnosticsSIL.def

@@ -179,7 +179,11 @@ ERROR(assignment_to_immutable_value,none,
 ERROR(missing_return,none,
       "missing return in a %select{function|closure}1 expected to return %0",
       (Type, unsigned))
-ERROR(non_exhaustive_switch,none, 
+ERROR(missing_never_call,none,
+      "%select{function|closure}1 with uninhabited return type %0 is missing "
+      "call to another never-returning function on all paths",
+      (Type, unsigned))
+ERROR(non_exhaustive_switch,none,
       "switch must be exhaustive, consider adding a default clause", ())
 ERROR(guard_body_must_not_fallthrough,none,
       "'guard' body may not fall through, consider using 'return' or 'break'"

include/swift/AST/Types.h

@@ -393,8 +393,8 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// semantics?
   bool hasReferenceSemantics();
 
-  /// Is this 'Never'?
-  bool isNever();
+  /// Is this an uninhabited type, such as 'Never'?
+  bool isUninhabited();
 
   /// Is this the 'Any' type?
   bool isAny();

lib/AST/Type.cpp

@@ -89,10 +89,11 @@ bool TypeBase::hasReferenceSemantics() {
   return getCanonicalType().hasReferenceSemantics();
 }
 
-bool TypeBase::isNever() {
+bool TypeBase::isUninhabited() {
   if (auto nominalDecl = getAnyNominal())
     if (auto enumDecl = dyn_cast<EnumDecl>(nominalDecl))
-      return enumDecl == getASTContext().getNeverDecl();
+      if (enumDecl->getAllElements().empty())
+        return true;
   return false;
 }
 

lib/IRGen/GenClangType.cpp

@@ -493,7 +493,7 @@ GenClangType::visitBoundGenericType(CanBoundGenericType type) {
 clang::CanQualType GenClangType::visitEnumType(CanEnumType type) {
   // Special case: Uninhabited enums are not @objc, so we don't
   // know what to do below, but we can just convert to 'void'.
-  if (type->getDecl()->getAllElements().empty())
+  if (type->isUninhabited())
     return Converter.convert(IGM, IGM.Context.TheEmptyTupleType);
 
   assert(type->getDecl()->isObjC() && "not an @objc enum?!");

lib/SIL/SILType.cpp

@@ -72,7 +72,7 @@ bool SILType::isReferenceCounted(SILModule &M) const {
 
 bool SILType::isNoReturnFunction() const {
   if (auto funcTy = dyn_cast<SILFunctionType>(getSwiftRValueType()))
-    return funcTy->getSILResult().getSwiftRValueType()->isNever();
+    return funcTy->getSILResult().getSwiftRValueType()->isUninhabited();
 
   return false;
 }

lib/SILOptimizer/Mandatory/DataflowDiagnostics.cpp

@@ -46,16 +46,13 @@ static void diagnoseMissingReturn(const UnreachableInst *UI,
     llvm_unreachable("unhandled case in MissingReturn");
   }
 
-  // No action required if the function returns 'Void' or that the
-  // function is marked 'noreturn'.
-  if (ResTy->isVoid() || F->isNoReturnFunction())
-    return;
-
   SILLocation L = UI->getLoc();
   assert(L && ResTy);
+  auto diagID = F->isNoReturnFunction() ? diag::missing_never_call
+                                        : diag::missing_return;
   diagnose(Context,
            L.getEndSourceLoc(),
-           diag::missing_return, ResTy,
+           diagID, ResTy,
            FLoc.isASTNode<ClosureExpr>() ? 1 : 0);
 }
 

lib/Sema/TypeCheckStmt.cpp

@@ -1005,7 +1005,7 @@ bool TypeChecker::typeCheckCatchPattern(CatchStmt *S, DeclContext *DC) {
 
 static bool isDiscardableType(Type type) {
   return (type->is<ErrorType>() ||
-          type->isNever() ||
+          type->isUninhabited() ||
           type->lookThroughAllAnyOptionalTypes()->isVoid());
 }
 

test/IRGen/dllexport.swift

@@ -20,7 +20,7 @@ public var ci : c = c()
 
 open class d {
   private func m() -> Never {
-    return fatalError()
+    fatalError()
   }
 }
 

test/SILOptimizer/return.swift

@@ -12,7 +12,28 @@ func singleBlock2() -> Int {
 enum NoCasesButNotNever {}
 
 func diagnoseNoCaseEnumMissingReturn() -> NoCasesButNotNever {
-} // expected-error {{missing return in a function expected to return 'NoCasesButNotNever'}}
+} // expected-error {{function with uninhabited return type 'NoCasesButNotNever' is missing call to another never-returning function on all paths}} 
+
+func diagnoseNeverMissingBody() -> Never {
+} // expected-error {{function with uninhabited return type 'Never' is missing call to another never-returning function on all paths}} 
+
+_ = { () -> Never in
+}() // expected-error {{closure with uninhabited return type 'Never' is missing call to another never-returning function on all paths}}-
+
+func diagnoseNeverWithBody(i : Int) -> Never {
+  if (i == -1) {
+    print("Oh no!")
+  } else {
+    switch i {
+    case 0:
+      exit()
+    case 1:
+      fatalError()
+    default:
+      repeat { } while true 
+    } 
+  }
+} // expected-error {{function with uninhabited return type 'Never' is missing call to another never-returning function on all paths}}
 
 class MyClassWithClosure {
   var f : (_ s: String) -> String = { (_ s: String) -> String in } // expected-error {{missing return in a closure expected to return 'String'}}