[AST] Introduce UnreachableExpr

This models the conversion from an uninhabited
value to any type, and allows us to get rid of
a couple of places where we'd attempt to drop
the return statement instead.

Author: hamishknight

include/swift/AST/Expr.h

@@ -3591,6 +3591,22 @@ class ArchetypeToSuperExpr : public ImplicitConversionExpr {
   }
 };
 
+/// An expression that models an implicit conversion from an uninhabited value
+/// to any type. It cannot be evaluated.
+class UnreachableExpr : public ImplicitConversionExpr {
+  UnreachableExpr(Expr *subExpr, Type ty)
+      : ImplicitConversionExpr(ExprKind::Unreachable, subExpr, ty) {}
+
+public:
+  static UnreachableExpr *create(ASTContext &ctx, Expr *subExpr, Type ty) {
+    return new (ctx) UnreachableExpr(subExpr, ty);
+  }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::Unreachable;
+  }
+};
+
 /// The builtin unary '&' operator, which converts the
 /// given lvalue into an 'inout' argument value.
 class InOutExpr : public Expr {

include/swift/AST/ExprNodes.def

@@ -183,6 +183,7 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(ForeignObjectConversion, ImplicitConversionExpr)
   EXPR(UnevaluatedInstance, ImplicitConversionExpr)
   EXPR(UnderlyingToOpaque, ImplicitConversionExpr)
+  EXPR(Unreachable, ImplicitConversionExpr)
   EXPR(DifferentiableFunction, ImplicitConversionExpr)
   EXPR(LinearFunction, ImplicitConversionExpr)
   EXPR(DifferentiableFunctionExtractOriginal, ImplicitConversionExpr)

lib/AST/ASTDumper.cpp

@@ -2653,6 +2653,11 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
     printRec(E->getSubExpr());
     printFoot();
   }
+  void visitUnreachableExpr(UnreachableExpr *E, StringRef label) {
+    printCommon(E, "unreachable", label);
+    printRec(E->getSubExpr());
+    printFoot();
+  }
   void visitDifferentiableFunctionExpr(DifferentiableFunctionExpr *E, StringRef label) {
     printCommon(E, "differentiable_function", label);
     printRec(E->getSubExpr());

lib/AST/ASTPrinter.cpp

@@ -5965,6 +5965,10 @@ void PrintAST::visitPropertyWrapperValuePlaceholderExpr(swift::PropertyWrapperVa
 void PrintAST::visitDifferentiableFunctionExtractOriginalExpr(swift::DifferentiableFunctionExtractOriginalExpr *expr) {
 }
 
+void PrintAST::visitUnreachableExpr(UnreachableExpr *E) {
+  visit(E->getSubExpr());
+}
+
 void PrintAST::visitMacroExpansionExpr(MacroExpansionExpr *expr) {
 }
 

lib/AST/ASTVerifier.cpp

@@ -1784,6 +1784,14 @@ class Verifier : public ASTWalker {
       verifyCheckedBase(E);
     }
 
+    void verifyChecked(UnreachableExpr *E) {
+      if (!E->getSubExpr()->getType()->isStructurallyUninhabited()) {
+        Out << "UnreachableExpr must have an uninhabited sub-expression: ";
+        E->getSubExpr()->dump(Out);
+        abort();
+      }
+    }
+
     void verifyChecked(TupleElementExpr *E) {
       PrettyStackTraceExpr debugStack(Ctx, "verifying TupleElementExpr", E);
 

lib/AST/Expr.cpp

@@ -455,6 +455,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   PASS_THROUGH_REFERENCE(BridgeFromObjC, getSubExpr);
   PASS_THROUGH_REFERENCE(ConditionalBridgeFromObjC, getSubExpr);
   PASS_THROUGH_REFERENCE(UnderlyingToOpaque, getSubExpr);
+  PASS_THROUGH_REFERENCE(Unreachable, getSubExpr);
   NO_REFERENCE(Coerce);
   NO_REFERENCE(ForcedCheckedCast);
   NO_REFERENCE(ConditionalCheckedCast);
@@ -820,6 +821,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::BridgeFromObjC:
   case ExprKind::BridgeToObjC:
   case ExprKind::UnderlyingToOpaque:
+  case ExprKind::Unreachable:
     // Implicit conversion nodes have no syntax of their own; defer to the
     // subexpression.
     return cast<ImplicitConversionExpr>(this)->getSubExpr()
@@ -1000,6 +1002,7 @@ bool Expr::isValidParentOfTypeExpr(Expr *typeExpr) const {
   case ExprKind::ForeignObjectConversion:
   case ExprKind::UnevaluatedInstance:
   case ExprKind::UnderlyingToOpaque:
+  case ExprKind::Unreachable:
   case ExprKind::DifferentiableFunction:
   case ExprKind::LinearFunction:
   case ExprKind::DifferentiableFunctionExtractOriginal:

lib/SILGen/SILGenExpr.cpp

@@ -499,6 +499,7 @@ namespace {
     RValue visitIsExpr(IsExpr *E, SGFContext C);
     RValue visitCoerceExpr(CoerceExpr *E, SGFContext C);
     RValue visitUnderlyingToOpaqueExpr(UnderlyingToOpaqueExpr *E, SGFContext C);
+    RValue visitUnreachableExpr(UnreachableExpr *E, SGFContext C);
     RValue visitTupleExpr(TupleExpr *E, SGFContext C);
     RValue visitMemberRefExpr(MemberRefExpr *E, SGFContext C);
     RValue visitDynamicMemberRefExpr(DynamicMemberRefExpr *E, SGFContext C);
@@ -2395,6 +2396,22 @@ RValue RValueEmitter::visitUnderlyingToOpaqueExpr(UnderlyingToOpaqueExpr *E,
   return RValue(SGF, E, cast);
 }
 
+RValue RValueEmitter::visitUnreachableExpr(UnreachableExpr *E, SGFContext C) {
+  // Emit the expression, followed by an unreachable. To produce a value of
+  // arbitrary type, we emit a temporary allocation, with the use of the
+  // allocation in the unreachable block. The SILOptimizer will eliminate both
+  // the unreachable block and unused allocation.
+  SGF.emitIgnoredExpr(E->getSubExpr());
+
+  auto &lowering = SGF.getTypeLowering(E->getType());
+  auto resultAddr = SGF.emitTemporaryAllocation(E, lowering.getLoweredType());
+
+  SGF.B.createUnreachable(E);
+  SGF.B.emitBlock(SGF.createBasicBlock());
+
+  return RValue(SGF, E, SGF.emitManagedRValueWithCleanup(resultAddr));
+}
+
 VarargsInfo Lowering::emitBeginVarargs(SILGenFunction &SGF, SILLocation loc,
                                        CanType baseTy, CanType arrayTy,
                                        unsigned numElements) {

lib/SILGen/SILGenStmt.cpp

@@ -840,15 +840,6 @@ void StmtEmitter::visitYieldStmt(YieldStmt *S) {
 void StmtEmitter::visitThenStmt(ThenStmt *S) {
   auto *E = S->getResult();
 
-  // If we have an uninhabited type, we may not be able to use it for
-  // initialization, since we allow the conversion of Never to any other type.
-  // Instead, emit an ignored expression with an unreachable.
-  if (E->getType()->isUninhabited()) {
-    SGF.emitIgnoredExpr(E);
-    SGF.B.createUnreachable(E);
-    return;
-  }
-
   // Retrieve the initialization for the parent SingleValueStmtExpr. If we don't
   // have an init, we don't care about the result, emit an ignored expr. This is
   // the case if e.g the result is being converted to Void.

lib/Sema/CSApply.cpp

@@ -7491,6 +7491,10 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     break;
   }
 
+  // Uninhabited types can be coerced to any other type via an UnreachableExpr.
+  if (fromType->isUninhabited())
+    return cs.cacheType(UnreachableExpr::create(ctx, expr, toType));
+
   // "Catch all" coercions.
   auto desugaredToType = toType->getDesugaredType();
   switch (desugaredToType->getKind()) {
@@ -9574,8 +9578,7 @@ ExprWalker::rewriteTarget(SyntacticElementTarget target) {
       if (target.isOptionalSomePatternInit())
         return false;
 
-      if (solution.getResolvedType(resultExpr)->isUninhabited() ||
-          solution.simplifyType(convertType)->isVoid()) {
+      if (solution.simplifyType(convertType)->isVoid()) {
         auto contextPurpose = cs.getContextualTypePurpose(target.getAsExpr());
         if (contextPurpose == CTP_ImpliedReturnStmt ||
             contextPurpose == CTP_SingleValueStmtBranch) {

lib/Sema/CSSyntacticElement.cpp

@@ -2139,23 +2139,18 @@ class SyntacticElementSolutionApplication
 
     enum {
       convertToResult,
-      coerceToVoid,
-      coerceFromNever,
+      coerceToVoid
     } mode;
 
     auto resultExprType =
         solution.simplifyType(solution.getType(resultExpr))->getRValueType();
     // A closure with a non-void return expression can coerce to a closure
     // that returns Void.
+    // TODO: We probably ought to introduce an implicit conversion expr to Void
+    // and eliminate this case.
     if (resultType->isVoid() && !resultExprType->isVoid()) {
       mode = coerceToVoid;
 
-      // A single-expression closure with a Never expression type
-      // coerces to any other function type.
-    } else if (context.isSingleExpressionClosure(cs) &&
-               resultExprType->isUninhabited()) {
-      mode = coerceFromNever;
-
       // Normal rule is to coerce to the return expression to the closure type.
     } else {
       mode = convertToResult;
@@ -2206,12 +2201,6 @@ class SyntacticElementSolutionApplication
                                elements, returnStmt->getEndLoc(),
                                /*implicit*/ true);
     }
-
-    case coerceFromNever:
-      // Replace the return statement with its expression, so that the
-      // expression is evaluated directly. This only works because coercion
-      // from never is limited to single-expression closures.
-      return resultExpr;
     }
 
     return returnStmt;