[AST] Remove ReifyPackExpr.

Author: hborla

include/swift/AST/Expr.h

@@ -3399,18 +3399,6 @@ class BridgeToObjCExpr : public ImplicitConversionExpr {
   }
 };
 
-/// ReifyPackExpr - Drop the pack structure and reify it either as a tuple or
-/// single value.
-class ReifyPackExpr : public ImplicitConversionExpr {
-public:
-  ReifyPackExpr(Expr *subExpr, Type type)
-    : ImplicitConversionExpr(ExprKind::ReifyPack, subExpr, type) {}
-
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::ReifyPack;
-  }
-};
-
 /// UnresolvedSpecializeExpr - Represents an explicit specialization using
 /// a type parameter list (e.g. "Vector<Int>") that has not been resolved.
 class UnresolvedSpecializeExpr final : public Expr,
@@ -5926,8 +5914,7 @@ class OneWayExpr : public Expr {
 ///
 /// There is no user-visible way to spell a pack expression, they are always
 /// implicitly created at applies. As such, any appearance of pack types outside
-/// of applies are illegal. In general, packs appearing in such positions should
-/// have a \c ReifyPackExpr to convert them to a user-available AST type.
+/// of applies are illegal.
 class PackExpr final : public Expr,
     private llvm::TrailingObjects<PackExpr, Expr *> {
   friend TrailingObjects;

include/swift/AST/ExprNodes.def

@@ -184,8 +184,7 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(DifferentiableFunctionExtractOriginal, ImplicitConversionExpr)
   EXPR(LinearFunctionExtractOriginal, ImplicitConversionExpr)
   EXPR(LinearToDifferentiableFunction, ImplicitConversionExpr)
-  EXPR(ReifyPack, ImplicitConversionExpr)
-  EXPR_RANGE(ImplicitConversion, Load, ReifyPack)
+  EXPR_RANGE(ImplicitConversion, Load, LinearToDifferentiableFunction)
 ABSTRACT_EXPR(ExplicitCast, Expr)
   ABSTRACT_EXPR(CheckedCast, ExplicitCastExpr)
     EXPR(ForcedCheckedCast, CheckedCastExpr)

include/swift/Sema/Constraint.h

@@ -307,10 +307,6 @@ enum class ConversionRestrictionKind {
   ///    - Unsafe[Mutable]RawPointer -> Unsafe[Mutable]Pointer<[U]Int>
   ///    - Unsafe[Mutable]Pointer<Int{8, 16, ...}> <-> Unsafe[Mutable]Pointer<UInt{8, 16, ...}>
   PointerToCPointer,
-  // Convert a pack into a type with an equivalent arity.
-  // - If the arity of the pack is 1, drops the pack structure <T> => T
-  // - If the arity of the pack is n >= 1, converts the pack structure into a tuple <T, U, V> => (T, U, V)
-  ReifyPackToType,
 };
 
 /// Specifies whether a given conversion requires the creation of a temporary

lib/AST/ASTDumper.cpp

@@ -2295,11 +2295,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
-  void visitReifyPackExpr(ReifyPackExpr *E) {
-    printCommon(E, "reify_pack") << '\n';
-    printRec(E->getSubExpr());
-    PrintWithColorRAII(OS, ParenthesisColor) << ')';
-  }
   void visitLoadExpr(LoadExpr *E) {
     printCommon(E, "load_expr") << '\n';
     printRec(E->getSubExpr());

lib/AST/ASTPrinter.cpp

@@ -4587,9 +4587,6 @@ void PrintAST::visitTupleExpr(TupleExpr *expr) {
 void PrintAST::visitPackExpr(PackExpr *expr) {
 }
 
-void PrintAST::visitReifyPackExpr(ReifyPackExpr *expr) {
-}
-
 void PrintAST::visitTypeJoinExpr(TypeJoinExpr *expr) {
 }
 

lib/AST/Expr.cpp

@@ -444,7 +444,6 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   PASS_THROUGH_REFERENCE(BridgeFromObjC, getSubExpr);
   PASS_THROUGH_REFERENCE(ConditionalBridgeFromObjC, getSubExpr);
   PASS_THROUGH_REFERENCE(UnderlyingToOpaque, getSubExpr);
-  PASS_THROUGH_REFERENCE(ReifyPack, getSubExpr);
   NO_REFERENCE(Coerce);
   NO_REFERENCE(ForcedCheckedCast);
   NO_REFERENCE(ConditionalCheckedCast);
@@ -794,7 +793,6 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::BridgeFromObjC:
   case ExprKind::BridgeToObjC:
   case ExprKind::UnderlyingToOpaque:
-  case ExprKind::ReifyPack:
     // Implicit conversion nodes have no syntax of their own; defer to the
     // subexpression.
     return cast<ImplicitConversionExpr>(this)->getSubExpr()
@@ -983,7 +981,6 @@ bool Expr::isValidParentOfTypeExpr(Expr *typeExpr) const {
   case ExprKind::KeyPathDot:
   case ExprKind::OneWay:
   case ExprKind::Tap:
-  case ExprKind::ReifyPack:
   case ExprKind::Pack:
   case ExprKind::TypeJoin:
     return false;

lib/SILGen/SILGenExpr.cpp

@@ -446,7 +446,6 @@ namespace {
              CollectionUpcastConversionExpr *E,
              SGFContext C);
     RValue visitBridgeToObjCExpr(BridgeToObjCExpr *E, SGFContext C);
-    RValue visitReifyPackExpr(ReifyPackExpr *E, SGFContext C);
     RValue visitPackExpansionExpr(PackExpansionExpr *E, SGFContext C);
     RValue visitBridgeFromObjCExpr(BridgeFromObjCExpr *E, SGFContext C);
     RValue visitConditionalBridgeFromObjCExpr(ConditionalBridgeFromObjCExpr *E,
@@ -1513,11 +1512,6 @@ RValueEmitter::visitBridgeToObjCExpr(BridgeToObjCExpr *E, SGFContext C) {
   return RValue(SGF, E, result);
 }
 
-RValue
-RValueEmitter::visitReifyPackExpr(ReifyPackExpr *E, SGFContext C) {
-  llvm_unreachable("Unimplemented!");
-}
-
 RValue
 RValueEmitter::visitPackExpansionExpr(PackExpansionExpr *E,
                                       SGFContext C) {

lib/Sema/CSApply.cpp

@@ -7011,11 +7011,6 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       finishApply(implicitInit, toType, callLocator, callLocator);
       return implicitInit;
     }
-    case ConversionRestrictionKind::ReifyPackToType: {
-      auto reifyPack =
-          cs.cacheType(new (ctx) ReifyPackExpr(expr, toType));
-      return coerceToType(reifyPack, toType, locator);
-    }
     }
   }
 

lib/Sema/CSDiagnostics.cpp

@@ -7174,7 +7174,6 @@ void NonEphemeralConversionFailure::emitSuggestionNotes() const {
   case ConversionRestrictionKind::ObjCTollFreeBridgeToCF:
   case ConversionRestrictionKind::CGFloatToDouble:
   case ConversionRestrictionKind::DoubleToCGFloat:
-  case ConversionRestrictionKind::ReifyPackToType:
     llvm_unreachable("Expected an ephemeral conversion!");
   }
 }

lib/Sema/CSSimplify.cpp

@@ -6834,15 +6834,6 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
         }
       }
     }
-
-    // A Pack of (Ts...) is convertible to a tuple (X, Y, Z) as long as there
-    // is an element-wise match.
-    if (auto *expansionTy = type1->getAs<PackType>()) {
-      if (!type2->isTypeVariableOrMember()) {
-        conversionsOrFixes.push_back(
-            ConversionRestrictionKind::ReifyPackToType);
-      }
-    }
   }
 
   if (kind >= ConstraintKind::OperatorArgumentConversion) {
@@ -12679,22 +12670,6 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
         {getConstraintLocator(locator), restriction});
     return SolutionKind::Solved;
   }
-  case ConversionRestrictionKind::ReifyPackToType: {
-    type1 = simplifyType(type1);
-    auto *PET = type1->castTo<PackType>();
-    if (auto *TT = type2->getAs<TupleType>()) {
-      llvm::SmallVector<TupleTypeElt, 8> elts;
-      for (Type elt : PET->getElementTypes()) {
-        elts.push_back(elt);
-      }
-      Type tupleType1 = TupleType::get(elts, getASTContext());
-      return matchTypes(tupleType1, TT, ConstraintKind::Bind, subflags,
-                        locator);
-    } else {
-      return matchTypes(PET->getElementType(0), type2, ConstraintKind::Bind,
-                        subflags, locator);
-    }
-  }
   }
 
   llvm_unreachable("bad conversion restriction");