[AST] NFC: Refactor ExprPattern construction

Introduce 3 separate factory constructors, and
remove the ability to specify the match expr and
var, as those should be synthesized on-demand.

Author: hamishknight

include/swift/AST/Pattern.h

@@ -639,7 +639,6 @@ class OptionalSomePattern : public Pattern {
   }
 };
 
-
 /// A pattern which matches a value obtained by evaluating an expression.
 /// The match will be tested using user-defined '~=' operator function lookup;
 /// the match succeeds if 'patternValue ~= matchedValue' produces a true value.
@@ -649,24 +648,24 @@ class ExprPattern : public Pattern {
   /// An expression constructed during type-checking that produces a call to the
   /// '~=' operator comparing the match expression on the left to the matched
   /// value on the right.
-  Expr *MatchExpr;
+  Expr *MatchExpr = nullptr;
 
   /// An implicit variable used to represent the RHS value of the match.
-  VarDecl *MatchVar;
+  VarDecl *MatchVar = nullptr;
+
+  ExprPattern(Expr *E, bool isResolved)
+      : Pattern(PatternKind::Expr), SubExprAndIsResolved(E, isResolved) {}
 
 public:
-  /// Construct an ExprPattern.
-  ExprPattern(Expr *e, bool isResolved, Expr *matchExpr, VarDecl *matchVar);
-
-  /// Construct an unresolved ExprPattern.
-  ExprPattern(Expr *e)
-    : ExprPattern(e, false, nullptr, nullptr)
-  {}
-
-  /// Construct a resolved ExprPattern.
-  ExprPattern(Expr *e, Expr *matchExpr, VarDecl *matchVar)
-    : ExprPattern(e, true, matchExpr, matchVar)
-  {}
+  /// Create a new parsed unresolved ExprPattern.
+  static ExprPattern *createParsed(ASTContext &ctx, Expr *E);
+
+  /// Create a new resolved ExprPattern. This should be used in cases
+  /// where a user-written expression should be treated as an ExprPattern.
+  static ExprPattern *createResolved(ASTContext &ctx, Expr *E);
+
+  /// Create a new implicit resolved ExprPattern.
+  static ExprPattern *createImplicit(ASTContext &ctx, Expr *E);
 
   Expr *getSubExpr() const { return SubExprAndIsResolved.getPointer(); }
   void setSubExpr(Expr *e) { SubExprAndIsResolved.setPointer(e); }

lib/AST/Pattern.cpp

@@ -501,12 +501,18 @@ void IsPattern::setCastType(Type type) {
 
 TypeRepr *IsPattern::getCastTypeRepr() const { return CastType->getTypeRepr(); }
 
-/// Construct an ExprPattern.
-ExprPattern::ExprPattern(Expr *e, bool isResolved, Expr *matchExpr,
-                         VarDecl *matchVar)
-  : Pattern(PatternKind::Expr), SubExprAndIsResolved(e, isResolved),
-    MatchExpr(matchExpr), MatchVar(matchVar) {
-  assert(!matchExpr || e->isImplicit() == matchExpr->isImplicit());
+ExprPattern *ExprPattern::createParsed(ASTContext &ctx, Expr *E) {
+  return new (ctx) ExprPattern(E, /*isResolved*/ false);
+}
+
+ExprPattern *ExprPattern::createResolved(ASTContext &ctx, Expr *E) {
+  return new (ctx) ExprPattern(E, /*isResolved*/ true);
+}
+
+ExprPattern *ExprPattern::createImplicit(ASTContext &ctx, Expr *E) {
+  auto *EP = ExprPattern::createResolved(ctx, E);
+  EP->setImplicit();
+  return EP;
 }
 
 SourceLoc EnumElementPattern::getStartLoc() const {

lib/Parse/ParsePattern.cpp

@@ -1314,8 +1314,9 @@ ParserResult<Pattern> Parser::parseMatchingPattern(bool isExprBasic) {
   // UnresolvedPatternExpr.  Transform this now to simplify later code.
   if (auto *UPE = dyn_cast<UnresolvedPatternExpr>(subExpr.get()))
     return makeParserResult(status, UPE->getSubPattern());
-  
-  return makeParserResult(status, new (Context) ExprPattern(subExpr.get()));
+
+  auto *EP = ExprPattern::createParsed(Context, subExpr.get());
+  return makeParserResult(status, EP);
 }
 
 ParserResult<Pattern> Parser::parseMatchingPatternAsLetOrVar(bool isLet,

lib/Parse/ParseStmt.cpp

@@ -1061,7 +1061,7 @@ static void parseGuardedPattern(Parser &P, GuardedPattern &result,
   // Do some special-case code completion for the start of the pattern.
   if (P.Tok.is(tok::code_complete)) {
     auto CCE = new (P.Context) CodeCompletionExpr(P.Tok.getLoc());
-    result.ThePattern = new (P.Context) ExprPattern(CCE);
+    result.ThePattern = ExprPattern::createParsed(P.Context, CCE);
     if (P.IDECallbacks) {
       switch (parsingContext) {
       case GuardedPatternContext::Case:

lib/Sema/CSSimplify.cpp

@@ -9847,8 +9847,8 @@ static bool inferEnumMemberThroughTildeEqualsOperator(
 
   // Slots for expression and variable are going to be filled via
   // synthesizing ~= operator application.
-  auto *EP = new (ctx) ExprPattern(pattern->getUnresolvedOriginalExpr(),
-                                   /*matchExpr=*/nullptr, /*matchVar=*/nullptr);
+  auto *EP =
+      ExprPattern::createResolved(ctx, pattern->getUnresolvedOriginalExpr());
 
   auto tildeEqualsApplication =
       TypeChecker::synthesizeTildeEqualsOperatorApplication(EP, DC, enumTy);

lib/Sema/DerivedConformanceCodingKey.cpp

@@ -277,9 +277,7 @@ deriveBodyCodingKey_init_stringValue(AbstractFunctionDecl *initDecl, void *) {
   for (auto *elt : elements) {
     auto *litExpr = new (C) StringLiteralExpr(elt->getNameStr(), SourceRange(),
                                               /*Implicit=*/true);
-    auto *litPat = new (C) ExprPattern(litExpr, /*IsResolved=*/true, nullptr,
-                                       nullptr);
-    litPat->setImplicit();
+    auto *litPat = ExprPattern::createImplicit(C, litExpr);
 
     auto labelItem = CaseLabelItem(litPat);
 

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -323,9 +323,7 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
       stringExprs.push_back(litExpr);
       litExpr = IntegerLiteralExpr::createFromUnsigned(C, Idx, SourceLoc()); 
     }
-    auto litPat = new (C) ExprPattern(litExpr, /*isResolved*/ true,
-                                      nullptr, nullptr);
-    litPat->setImplicit();
+    auto *litPat = ExprPattern::createImplicit(C, litExpr);
 
     /// Statements in the body of this case.
     SmallVector<ASTNode, 2> stmts;

lib/Sema/TypeCheckPattern.cpp

@@ -244,7 +244,7 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     if (Pattern *p = visit(E))
       return p;
 
-    return new (Context) ExprPattern(E, nullptr, nullptr);
+    return ExprPattern::createResolved(Context, E);
   }
 
   /// Turn an argument list into a matching tuple or paren pattern.
@@ -1427,8 +1427,8 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
             // If we have the original expression parse tree, try reinterpreting
             // it as an expr-pattern if enum element lookup failed, since `.foo`
             // could also refer to a static member of the context type.
-            P = new (Context) ExprPattern(EEP->getUnresolvedOriginalExpr(),
-                                          nullptr, nullptr);
+            P = ExprPattern::createResolved(Context,
+                                            EEP->getUnresolvedOriginalExpr());
             return coercePatternToType(
                 pattern.forSubPattern(P, /*retainTopLevel=*/true), type,
                 options);