Eliminated conversion from uninhabited.

nate-chandler · nate-chandler · commit b2ad56223f7d · 2019-04-24T10:09:17.000-07:00
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -4677,16 +4677,6 @@ class LazyInitializerExpr : public Expr {
   }
 };
 
-class UninhabitedUpcastExpr : public ImplicitConversionExpr {
-public:
-  UninhabitedUpcastExpr(Expr *subExpr, Type ty)
-    : ImplicitConversionExpr(ExprKind::UninhabitedUpcast, subExpr, ty) {}
-
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::UninhabitedUpcast;
-  }
-};
-
 /// Produces the Objective-C selector of the referenced method.
 ///
 /// \code
diff --git a/include/swift/AST/ExprNodes.def b/include/swift/AST/ExprNodes.def
@@ -169,7 +169,6 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(StringToPointer, ImplicitConversionExpr)
   EXPR(PointerToPointer, ImplicitConversionExpr)
   EXPR(ForeignObjectConversion, ImplicitConversionExpr)
-  EXPR(UninhabitedUpcast, ImplicitConversionExpr)
   EXPR(UnevaluatedInstance, ImplicitConversionExpr)
   EXPR(UnderlyingToOpaque, ImplicitConversionExpr)
   EXPR_RANGE(ImplicitConversion, Load, UnderlyingToOpaque)
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -2293,11 +2293,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
-  void visitUninhabitedUpcastExpr(UninhabitedUpcastExpr *E) {
-    printCommon(E, "uninhabited_upcast_expr") << '\n';
-    printRec(E->getSubExpr());
-    PrintWithColorRAII(OS, ParenthesisColor) << ')';
-  }
   void visitInjectIntoOptionalExpr(InjectIntoOptionalExpr *E) {
     printCommon(E, "inject_into_optional") << '\n';
     printRec(E->getSubExpr());
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -351,7 +351,6 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
   PASS_THROUGH_REFERENCE(BridgeFromObjC, getSubExpr);
   PASS_THROUGH_REFERENCE(ConditionalBridgeFromObjC, getSubExpr);
   PASS_THROUGH_REFERENCE(UnderlyingToOpaque, getSubExpr);
-  PASS_THROUGH_REFERENCE(UninhabitedUpcast, getSubExpr);
   NO_REFERENCE(Coerce);
   NO_REFERENCE(ForcedCheckedCast);
   NO_REFERENCE(ConditionalCheckedCast);
@@ -670,7 +669,6 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::BridgeFromObjC:
   case ExprKind::BridgeToObjC:
   case ExprKind::UnderlyingToOpaque:
-  case ExprKind::UninhabitedUpcast:
     // Implicit conversion nodes have no syntax of their own; defer to the
     // subexpression.
     return cast<ImplicitConversionExpr>(this)->getSubExpr()
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -416,7 +416,6 @@ namespace {
              SGFContext C);
     RValue visitBridgeToObjCExpr(BridgeToObjCExpr *E, SGFContext C);
     RValue visitBridgeFromObjCExpr(BridgeFromObjCExpr *E, SGFContext C);
-    RValue visitUninhabitedUpcastExpr(UninhabitedUpcastExpr *E, SGFContext C);
     RValue visitConditionalBridgeFromObjCExpr(ConditionalBridgeFromObjCExpr *E,
                                               SGFContext C);
     RValue visitArchetypeToSuperExpr(ArchetypeToSuperExpr *E, SGFContext C);
@@ -1406,15 +1405,6 @@ RValueEmitter::visitBridgeFromObjCExpr(BridgeFromObjCExpr *E, SGFContext C) {
   return RValue(SGF, E, result);
 }
 
-RValue 
-RValueEmitter::visitUninhabitedUpcastExpr(UninhabitedUpcastExpr *E, 
-                                          SGFContext C) {
-  // Emit code which force casts the expr of uninhabited type to the right type.
-  // TODO: Emit something more appropriate.
-  return emitUnconditionalCheckedCast(SGF, E, E->getSubExpr(), E->getType(),
-                                      CheckedCastKind::ValueCast, C);
-}
-
 RValue
 RValueEmitter::visitBridgeToObjCExpr(BridgeToObjCExpr *E, SGFContext C) {
   if (tryPeepholeBridgingConversion(SGF, Conversion::BridgeToObjC, E, C))
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -390,9 +390,6 @@ namespace {
     Expr *coerceSuperclass(Expr *expr, Type toType,
                            ConstraintLocatorBuilder locator);
 
-    Expr *coerceUninhabited(Expr *expr, Type toType,
-                            ConstraintLocatorBuilder locator);
-
     /// Coerce the given value to existential type.
     ///
     /// The following conversions are supported:
@@ -5257,13 +5254,6 @@ Expr *ExprRewriter::coerceSuperclass(Expr *expr, Type toType,
     new (tc.Context) DerivedToBaseExpr(expr, toType));
 }
 
-Expr *ExprRewriter::coerceUninhabited(Expr *expr, Type toType,
-                                      ConstraintLocatorBuilder locator) {
-  auto &tc = cs.getTypeChecker();
-  return cs.cacheType(
-    new (tc.Context) UninhabitedUpcastExpr(expr, toType));
-}
-
 /// Collect the conformances for all the protocols of an existential type.
 /// If the source type is also existential, we don't want to check conformance
 /// because most protocols do not conform to themselves -- however we still
@@ -6325,8 +6315,6 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     case ConversionRestrictionKind::Superclass:
     case ConversionRestrictionKind::ExistentialMetatypeToMetatype:
       return coerceSuperclass(expr, toType, locator);
-    case ConversionRestrictionKind::UninhabitedUpcast:
-      return coerceUninhabited(expr, toType, locator);
 
     case ConversionRestrictionKind::Existential:
     case ConversionRestrictionKind::MetatypeToExistentialMetatype:
diff --git a/lib/Sema/CSBindings.cpp b/lib/Sema/CSBindings.cpp
@@ -407,8 +407,7 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) {
     case ConstraintKind::Conversion:
     case ConstraintKind::ArgumentConversion:
     case ConstraintKind::OperatorArgumentConversion:
-    case ConstraintKind::OptionalObject: 
-    case ConstraintKind::SingleExpressionFunctionReturnConversion: {
+    case ConstraintKind::OptionalObject: {
       // If there is a `bind param` constraint associated with
       // current type variable, result should be aware of that
       // fact. Binding set might be incomplete until
diff --git a/lib/Sema/CSRanking.cpp b/lib/Sema/CSRanking.cpp
@@ -77,9 +77,6 @@ void ConstraintSystem::increaseScore(ScoreKind kind, unsigned value) {
     case SK_KeyPathSubscript:
       log << "key path subscript";
       break;
-    case SK_UninhabitedUpcast:
-      log << "uninhabited upcast conversion";
-      break;
     case SK_ValueToPointerConversion:
       log << "value-to-pointer conversion";
       break;
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -1079,7 +1079,6 @@ ConstraintSystem::matchTupleTypes(TupleType *tuple1, TupleType *tuple2,
   case ConstraintKind::OperatorArgumentConversion:
   case ConstraintKind::ArgumentConversion:
   case ConstraintKind::Conversion:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
     subKind = ConstraintKind::Conversion;
     break;
 
@@ -1171,7 +1170,6 @@ static bool matchFunctionRepresentations(FunctionTypeRepresentation rep1,
   case ConstraintKind::ValueMember:
   case ConstraintKind::FunctionInput:
   case ConstraintKind::FunctionResult:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
     return false;
   }
 
@@ -1318,7 +1316,6 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
   case ConstraintKind::ArgumentConversion:
   case ConstraintKind::OperatorArgumentConversion:
   case ConstraintKind::OpaqueUnderlyingType:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
     subKind = ConstraintKind::Subtype;
     break;
 
@@ -1593,18 +1590,6 @@ matchDeepTypeArguments(ConstraintSystem &cs,
   return cs.getTypeMatchSuccess();
 }
 
-ConstraintSystem::TypeMatchResult
-ConstraintSystem::matchUninhabitedUpcastTypes(Type type1, Type type2,
-                                              TypeMatchOptions flags,
-                                              ConstraintLocatorBuilder locator) {
-  if (type1->isUninhabited()) {
-    increaseScore(SK_UninhabitedUpcast);
-    return getTypeMatchSuccess();
-  }
-
-  return getTypeMatchFailure(locator);
-}
-
 ConstraintSystem::TypeMatchResult
 ConstraintSystem::matchDeepEqualityTypes(Type type1, Type type2,
                                          ConstraintLocatorBuilder locator) {
@@ -2241,7 +2226,6 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
     case ConstraintKind::Conversion:
     case ConstraintKind::ArgumentConversion:
     case ConstraintKind::OperatorArgumentConversion:
-    case ConstraintKind::SingleExpressionFunctionReturnConversion: 
       return formUnsolvedResult();
 
     case ConstraintKind::OpaqueUnderlyingType:
@@ -2498,12 +2482,6 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
     }
   }
 
-  if (kind == ConstraintKind::SingleExpressionFunctionReturnConversion) {
-    if (type1->isUninhabited()) {
-      conversionsOrFixes.push_back(ConversionRestrictionKind::UninhabitedUpcast);
-    }
-  }
-
   if (kind >= ConstraintKind::Subtype) {
     // Subclass-to-superclass conversion.
     if (type1->mayHaveSuperclass() &&
@@ -6008,10 +5986,6 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
     addContextualScore();
     return matchSuperclassTypes(type1, type2, subflags, locator);
 
-  case ConversionRestrictionKind::UninhabitedUpcast:
-    addContextualScore();
-    return matchUninhabitedUpcastTypes(type1, type2, subflags, locator);
-
   // for $< in { <, <c, <oc }:
   //   T $< U, U : P_i ===> T $< protocol<P_i...>
   case ConversionRestrictionKind::Existential:
@@ -6513,7 +6487,6 @@ ConstraintSystem::addConstraintImpl(ConstraintKind kind, Type first,
   case ConstraintKind::Conversion:
   case ConstraintKind::ArgumentConversion:
   case ConstraintKind::OperatorArgumentConversion:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
     return matchTypes(first, second, kind, subflags, locator);
 
   case ConstraintKind::OpaqueUnderlyingType:
@@ -6773,8 +6746,7 @@ ConstraintSystem::simplifyConstraint(const Constraint &constraint) {
   case ConstraintKind::Conversion:
   case ConstraintKind::ArgumentConversion:
   case ConstraintKind::OperatorArgumentConversion:
-  case ConstraintKind::OpaqueUnderlyingType:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion: {
+  case ConstraintKind::OpaqueUnderlyingType: {
     // Relational constraints.
     auto matchKind = constraint.getKind();
 
diff --git a/lib/Sema/CSSolver.cpp b/lib/Sema/CSSolver.cpp
@@ -1558,8 +1558,7 @@ void ConstraintSystem::ArgumentInfoCollector::walk(Type argType) {
       case ConstraintKind::Conversion:
       case ConstraintKind::BridgingConversion:
       case ConstraintKind::BindParam:
-      case ConstraintKind::OpaqueUnderlyingType:
-      case ConstraintKind::SingleExpressionFunctionReturnConversion: {
+      case ConstraintKind::OpaqueUnderlyingType: {
         auto secondTy = constraint->getSecondType();
         if (secondTy->is<TypeVariableType>()) {
           auto otherRep =
diff --git a/lib/Sema/Constraint.cpp b/lib/Sema/Constraint.cpp
@@ -66,7 +66,6 @@ Constraint::Constraint(ConstraintKind Kind, Type First, Type Second,
   case ConstraintKind::FunctionInput:
   case ConstraintKind::FunctionResult:
   case ConstraintKind::OpaqueUnderlyingType:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
     assert(!First.isNull());
     assert(!Second.isNull());
     break;
@@ -135,7 +134,6 @@ Constraint::Constraint(ConstraintKind Kind, Type First, Type Second, Type Third,
   case ConstraintKind::FunctionInput:
   case ConstraintKind::FunctionResult:
   case ConstraintKind::OpaqueUnderlyingType:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
     llvm_unreachable("Wrong constructor");
 
   case ConstraintKind::KeyPath:
@@ -239,7 +237,6 @@ Constraint *Constraint::clone(ConstraintSystem &cs) const {
   case ConstraintKind::FunctionInput:
   case ConstraintKind::FunctionResult:
   case ConstraintKind::OpaqueUnderlyingType:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
     return create(cs, getKind(), getFirstType(), getSecondType(), getLocator());
 
   case ConstraintKind::BindOverload:
@@ -333,8 +330,6 @@ void Constraint::print(llvm::raw_ostream &Out, SourceManager *sm) const {
     Out << " bind function input of "; break;
   case ConstraintKind::FunctionResult:
     Out << " bind function result of "; break;
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
-    Out << " single expression function return of "; break;
   case ConstraintKind::BindOverload: {
     Out << " bound to ";
     auto overload = getOverloadChoice();
@@ -442,8 +437,6 @@ StringRef swift::constraints::getName(ConversionRestrictionKind kind) {
     return "[deep equality]";
   case ConversionRestrictionKind::Superclass:
     return "[superclass]";
-  case ConversionRestrictionKind::UninhabitedUpcast:
-    return "[uninhabited-upcast]";
   case ConversionRestrictionKind::Existential:
     return "[existential]";
   case ConversionRestrictionKind::MetatypeToExistentialMetatype:
@@ -524,7 +517,6 @@ gatherReferencedTypeVars(Constraint *constraint,
   case ConstraintKind::FunctionInput:
   case ConstraintKind::FunctionResult:
   case ConstraintKind::OpaqueUnderlyingType:
-  case ConstraintKind::SingleExpressionFunctionReturnConversion:
     constraint->getFirstType()->getTypeVariables(typeVars);
     constraint->getSecondType()->getTypeVariables(typeVars);
     break;
diff --git a/lib/Sema/Constraint.h b/lib/Sema/Constraint.h
@@ -150,9 +150,6 @@ enum class ConstraintKind : char {
   /// The first type is a type that's a candidate to be the underlying type of
   /// the second opaque archetype.
   OpaqueUnderlyingType,
-  /// The first type is being implicitly returned from a function, the second is
-  /// the function's result type.
-  SingleExpressionFunctionReturnConversion,
 };
 
 /// Classification of the different kinds of constraints.
@@ -184,8 +181,6 @@ enum class ConversionRestrictionKind {
   DeepEquality,
   /// Subclass-to-superclass conversion.
   Superclass,
-  /// Uninhabited-to-any conversion.
-  UninhabitedUpcast,
   /// Class metatype to AnyObject conversion.
   ClassMetatypeToAnyObject,
   /// Existential metatype to AnyObject conversion.
@@ -494,7 +489,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::BindOverload:
     case ConstraintKind::OptionalObject:
     case ConstraintKind::OpaqueUnderlyingType:
-    case ConstraintKind::SingleExpressionFunctionReturnConversion:
       return ConstraintClassification::Relational;
 
     case ConstraintKind::ValueMember:
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
@@ -470,8 +470,6 @@ enum ScoreKind {
   SK_Fix,
   /// A reference to an @unavailable declaration.
   SK_Unavailable,
-  /// An implicit upcast from uninhabited to some type.
-  SK_UninhabitedUpcast,
   /// An implicit force of an implicitly unwrapped optional value.
   SK_ForceUnchecked,
   /// A user-defined conversion.
@@ -2653,12 +2651,6 @@ class ConstraintSystem {
   TypeMatchResult matchSuperclassTypes(Type type1, Type type2,
                                        TypeMatchOptions flags,
                                        ConstraintLocatorBuilder locator);
-  
-  /// Subroutine of \c matchTypes(), which matches up an uninhabited 
-  /// value to anything.
-  TypeMatchResult matchUninhabitedUpcastTypes(Type type1, Type type2,
-                                              TypeMatchOptions flags,
-                                              ConstraintLocatorBuilder locator);
 
   /// Subroutine of \c matchTypes(), which matches up two types that
   /// refer to the same declaration via their generic arguments.
