AST/SIL: Add a new Never type, and a TypeBase::isNever() check

Mostly NFC, this is just plumbing for the next patch.
Note that isNever() returns true for any uninhabited
enum.

It should be generalized so that stuff like (Never, Int)
is also known to be uninhabited, or even to support
generic substitutions that yield uninhabited types,
but for now I really see no reason to go that far, and
the current check for an enum with no cases seems
perfectly adequate.

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -440,11 +440,15 @@ class ASTContext {
   /// Retrieve the declaration of the "pointee" property of a pointer type.
   VarDecl *getPointerPointeePropertyDecl(PointerTypeKind ptrKind) const;
 
+  /// Retrieve the declaration of Swift.Never.
+  NominalTypeDecl *getNeverDecl() const;
+  CanType getNeverType() const;
+
   /// Retrieve the declaration of Swift.Void.
   TypeAliasDecl *getVoidDecl() const;
 
   /// Retrieve the declaration of ObjectiveC.ObjCBool.
-  StructDecl *getObjCBoolDecl();
+  StructDecl *getObjCBoolDecl() const;
 
   /// Retrieve the declaration of Foundation.NSError.
   ClassDecl *getNSErrorDecl() const;
@@ -491,7 +495,7 @@ class ASTContext {
   FuncDecl *getIsOSVersionAtLeastDecl(LazyResolver *resolver) const;
 
   /// Look for the declaration with the given name within the
-  /// swift module.
+  /// Swift module.
   void lookupInSwiftModule(StringRef name,
                            SmallVectorImpl<ValueDecl *> &results) const;
 

include/swift/AST/Types.h

@@ -392,7 +392,10 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// hasReferenceSemantics() - Do objects of this type have reference
   /// semantics?
   bool hasReferenceSemantics();
-  
+
+  /// Is this an uninhabited type, such as 'Never'?
+  bool isNever();
+
   /// Is this the 'Any' type?
   bool isAny();
 

include/swift/SIL/SILFunction.h

@@ -215,6 +215,8 @@ class SILFunction
     return LoweredType;
   }
 
+  bool isNoReturnFunction() const;
+
   /// Unsafely rewrite the lowered type of this function.
   ///
   /// This routine does not touch the entry block arguments

include/swift/SIL/SILInstruction.h

@@ -1002,6 +1002,10 @@ class ApplyInstBase<Impl, Base, false> : public Base {
     return SubstCalleeType;
   }
 
+  bool isCalleeNoReturn() const {
+    return getSubstCalleeSILType().isNoReturnFunction();
+  }
+
   bool isCalleeThin() const {
     auto Rep = getSubstCalleeType()->getRepresentation();
     return Rep == FunctionType::Representation::Thin;
@@ -5077,6 +5081,11 @@ class ApplySite {
     FOREACH_IMPL_RETURN(getSubstCalleeSILType());
   }
 
+  /// Check if this is a call of a never-returning function.
+  bool isCalleeNoReturn() const {
+    FOREACH_IMPL_RETURN(isCalleeNoReturn());
+  }
+
   bool isCalleeThin() const {
     switch (getSubstCalleeType()->getRepresentation()) {
     case SILFunctionTypeRepresentation::CFunctionPointer:

include/swift/SIL/SILType.h

@@ -285,7 +285,11 @@ class SILType {
   /// True if the type, or the referenced type of an address type, is a
   /// scalar reference-counted type.
   bool isReferenceCounted(SILModule &M) const;
-  
+
+  /// Returns true if the referenced type is a function type that never
+  /// returns.
+  bool isNoReturnFunction() const;
+
   /// Returns true if the referenced type has reference semantics.
   bool hasReferenceSemantics() const {
     return getSwiftRValueType().hasReferenceSemantics();

lib/AST/ASTContext.cpp

@@ -155,6 +155,9 @@ struct ASTContext::Implementation {
   /// The declaration of Swift.Unmanaged<T>
   NominalTypeDecl *UnmanagedDecl = nullptr;
 
+  /// The declaration of Swift.Never.
+  NominalTypeDecl *NeverDecl = nullptr;
+
   /// The declaration of Swift.Void.
   TypeAliasDecl *VoidDecl = nullptr;
 
@@ -710,7 +713,7 @@ NominalTypeDecl *ASTContext::getUnsafeMutablePointerDecl() const {
 NominalTypeDecl *ASTContext::getOpaquePointerDecl() const {
   if (!Impl.OpaquePointerDecl)
     Impl.OpaquePointerDecl
-    = findStdlibType(*this, "OpaquePointer", 0);
+      = findStdlibType(*this, "OpaquePointer", 0);
 
   return Impl.OpaquePointerDecl;
 }
@@ -784,6 +787,17 @@ ASTContext::getPointerPointeePropertyDecl(PointerTypeKind ptrKind) const {
   llvm_unreachable("bad pointer kind");
 }
 
+NominalTypeDecl *ASTContext::getNeverDecl() const {
+  if (!Impl.NeverDecl)
+    Impl.NeverDecl = findStdlibType(*this, "Never", 0);
+  
+  return Impl.NeverDecl;
+}
+
+CanType ASTContext::getNeverType() const {
+  return getNeverDecl()->getDeclaredType()->getCanonicalType();
+}
+
 TypeAliasDecl *ASTContext::getVoidDecl() const {
   if (Impl.VoidDecl) {
     return Impl.VoidDecl;
@@ -802,10 +816,11 @@ TypeAliasDecl *ASTContext::getVoidDecl() const {
   return Impl.VoidDecl;
 }
 
-StructDecl *ASTContext::getObjCBoolDecl() {
+StructDecl *ASTContext::getObjCBoolDecl() const {
   if (!Impl.ObjCBoolDecl) {
     SmallVector<ValueDecl *, 1> results;
-    if (Module *M = getModuleByName(Id_ObjectiveC.str())) {
+    auto *Context = const_cast<ASTContext *>(this);
+    if (Module *M = Context->getModuleByName(Id_ObjectiveC.str())) {
       M->lookupValue({ }, getIdentifier("ObjCBool"), NLKind::UnqualifiedLookup,
                      results);
       for (auto result : results) {

lib/AST/Type.cpp

@@ -89,6 +89,15 @@ bool TypeBase::hasReferenceSemantics() {
   return getCanonicalType().hasReferenceSemantics();
 }
 
+bool TypeBase::isNever() {
+  if (auto nominalDecl = getAnyNominal())
+    if (auto enumDecl = dyn_cast<EnumDecl>(nominalDecl))
+      if (enumDecl->getAllElements().empty())
+        return true;
+
+  return false;
+}
+
 bool TypeBase::isAny() {
   return isEqual(getASTContext().TheAnyType);
 }

lib/IRGen/GenClangType.cpp

@@ -489,6 +489,11 @@ 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->isNever())
+    return Converter.convert(IGM, IGM.Context.TheEmptyTupleType);
+
   assert(type->getDecl()->isObjC() && "not an @objc enum?!");
 
   // @objc enums lower to their raw types.

lib/SIL/SILFunction.cpp

@@ -294,6 +294,11 @@ Type SILFunction::mapTypeOutOfContext(Type type) const {
                                                type);
 }
 
+bool SILFunction::isNoReturnFunction() const {
+  return SILType::getPrimitiveObjectType(getLoweredFunctionType())
+      .isNoReturnFunction();
+}
+
 SILBasicBlock *SILFunction::createBasicBlock() {
   return new (getModule()) SILBasicBlock(this);
 }

lib/SIL/SILType.cpp

@@ -70,6 +70,17 @@ bool SILType::isReferenceCounted(SILModule &M) const {
   return M.getTypeLowering(*this).isReferenceCounted();
 }
 
+bool SILType::isNoReturnFunction() const {
+  if (auto funcTy = dyn_cast<SILFunctionType>(getSwiftRValueType())) {
+    if (funcTy->isNoReturn())
+      return true;
+
+    return funcTy->getSILResult().getSwiftRValueType()->isNever();
+  }
+
+  return false;
+}
+
 std::string SILType::getAsString() const {
   std::string Result;
   llvm::raw_string_ostream OS(Result);

lib/Sema/TypeCheckStmt.cpp

@@ -998,7 +998,13 @@ bool TypeChecker::typeCheckCatchPattern(CatchStmt *S, DeclContext *DC) {
   }
   return false;
 }
-  
+
+static bool isDiscardableType(Type type) {
+  return (type->is<ErrorType>() ||
+          type->isNever() ||
+          type->lookThroughAllAnyOptionalTypes()->isVoid());
+}
+
 void TypeChecker::checkIgnoredExpr(Expr *E) {
   // For parity with C, several places in the grammar accept multiple
   // comma-separated expressions and then bind them together as an implicit
@@ -1041,10 +1047,10 @@ void TypeChecker::checkIgnoredExpr(Expr *E) {
     return;
   }
 
-  // If the result of this expression is of type "()" potentially wrapped in
-  // optionals, then it is safe to ignore.
-  if (valueE->getType()->lookThroughAllAnyOptionalTypes()->isVoid() ||
-      valueE->getType()->is<ErrorType>())
+  // If the result of this expression is of type "Never" or "()"
+  // (the latter potentially wrapped in optionals) then it is
+  // safe to ignore.
+  if (isDiscardableType(valueE->getType()))
     return;
 
   // Complain about '#selector'.

stdlib/public/core/Policy.swift

@@ -12,6 +12,23 @@
 // Swift Standard Prolog Library.
 //===----------------------------------------------------------------------===//
 
+//===----------------------------------------------------------------------===//
+// Standardized uninhabited type
+//===----------------------------------------------------------------------===//
+/// The return type of functions that do not return normally; a type with no
+/// values.
+///
+/// Use `Never` as the return type when declarting a closure, function, or
+/// method that unconditionally throws an error, traps, or otherwise does
+/// not terminate.
+///
+///     func crashAndBurn() -> Never {
+///         fatalError("Something very, very bad happened")
+///     }
+
+@_fixed_layout
+public enum Never {}
+
 //===----------------------------------------------------------------------===//
 // Standardized aliases
 //===----------------------------------------------------------------------===//