Introduce ExprPatternMatchRequest

This replaces `synthesizeTildeEqualsOperatorApplication`,
and synthesizes the match expression and var
on-demand.

Author: hamishknight

include/swift/AST/Pattern.h

@@ -647,43 +647,49 @@ class OptionalSomePattern : public Pattern {
 class ExprPattern : public Pattern {
   llvm::PointerIntPair<Expr *, 1, bool> SubExprAndIsResolved;
 
+  DeclContext *DC;
+
   /// 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 = nullptr;
+  mutable Expr *MatchExpr = nullptr;
 
   /// An implicit variable used to represent the RHS value of the match.
-  VarDecl *MatchVar = nullptr;
+  mutable VarDecl *MatchVar = nullptr;
+
+  ExprPattern(Expr *E, DeclContext *DC, bool isResolved)
+      : Pattern(PatternKind::Expr), SubExprAndIsResolved(E, isResolved),
+        DC(DC) {}
 
-  ExprPattern(Expr *E, bool isResolved)
-      : Pattern(PatternKind::Expr), SubExprAndIsResolved(E, isResolved) {}
+  friend class ExprPatternMatchRequest;
 
 public:
   /// Create a new parsed unresolved ExprPattern.
-  static ExprPattern *createParsed(ASTContext &ctx, Expr *E);
+  static ExprPattern *createParsed(ASTContext &ctx, Expr *E, DeclContext *DC);
 
   /// 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);
+  static ExprPattern *createResolved(ASTContext &ctx, Expr *E, DeclContext *DC);
 
   /// Create a new implicit resolved ExprPattern.
-  static ExprPattern *createImplicit(ASTContext &ctx, Expr *E);
+  static ExprPattern *createImplicit(ASTContext &ctx, Expr *E, DeclContext *DC);
 
   Expr *getSubExpr() const { return SubExprAndIsResolved.getPointer(); }
   void setSubExpr(Expr *e) { SubExprAndIsResolved.setPointer(e); }
 
-  Expr *getMatchExpr() const { return MatchExpr; }
+  DeclContext *getDeclContext() const { return DC; }
+
+  Expr *getCachedMatchExpr() const { return MatchExpr; }
+  VarDecl *getCachedMatchVar() const { return MatchVar; }
+
+  Expr *getMatchExpr() const;
+  VarDecl *getMatchVar() const;
+
   void setMatchExpr(Expr *e) {
-    assert(isResolved() && "cannot set match fn for unresolved expr patter");
+    assert(MatchExpr && "Should only update an existing MatchExpr");
     MatchExpr = e;
   }
 
-  VarDecl *getMatchVar() const { return MatchVar; }
-  void setMatchVar(VarDecl *v) {
-    assert(isResolved() && "cannot set match var for unresolved expr patter");
-    MatchVar = v;
-  }
-
   SourceLoc getLoc() const;
   SourceRange getSourceRange() const;
 
@@ -851,6 +857,9 @@ class ContextualPattern {
 };
 
 void simple_display(llvm::raw_ostream &out, const ContextualPattern &pattern);
+void simple_display(llvm::raw_ostream &out, const Pattern *pattern);
+
+SourceLoc extractNearestSourceLoc(const Pattern *pattern);
 
 } // end namespace swift
 

include/swift/AST/TypeCheckRequests.h

@@ -2219,6 +2219,52 @@ class NamingPatternRequest
   void cacheResult(NamedPattern *P) const;
 };
 
+class ExprPatternMatchResult {
+  VarDecl *MatchVar;
+  Expr *MatchExpr;
+
+  friend class ExprPattern;
+
+  // Should only be used as the default value for the request, as the caching
+  // logic assumes the request always produces a non-null result.
+  ExprPatternMatchResult(llvm::NoneType)
+      : MatchVar(nullptr), MatchExpr(nullptr) {}
+
+public:
+  ExprPatternMatchResult(VarDecl *matchVar, Expr *matchExpr)
+      : MatchVar(matchVar), MatchExpr(matchExpr) {
+    // Note the caching logic currently requires the request to produce a
+    // non-null result.
+    assert(matchVar && matchExpr);
+  }
+
+  VarDecl *getMatchVar() const { return MatchVar; }
+  Expr *getMatchExpr() const { return MatchExpr; }
+};
+
+/// Compute the match VarDecl and expression for an ExprPattern, which applies
+/// the \c ~= operator.
+class ExprPatternMatchRequest
+    : public SimpleRequest<ExprPatternMatchRequest,
+                           ExprPatternMatchResult(const ExprPattern *),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ExprPatternMatchResult evaluate(Evaluator &evaluator,
+                                  const ExprPattern *EP) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<ExprPatternMatchResult> getCachedResult() const;
+  void cacheResult(ExprPatternMatchResult result) const;
+};
+
 class InterfaceTypeRequest :
     public SimpleRequest<InterfaceTypeRequest,
                          Type (ValueDecl *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -228,6 +228,9 @@ SWIFT_REQUEST(TypeChecker, ModuleImplicitImportsRequest,
               ImplicitImportList(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, NamingPatternRequest,
               NamedPattern *(VarDecl *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ExprPatternMatchRequest,
+              ExprPatternMatchResult(const ExprPattern *),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, OpaqueReadOwnershipRequest,
               OpaqueReadOwnership(AbstractStorageDecl *), SeparatelyCached,
               NoLocationInfo)

lib/AST/ASTDumper.cpp

@@ -472,7 +472,7 @@ namespace {
     void visitExprPattern(ExprPattern *P) {
       printCommon(P, "pattern_expr");
       OS << '\n';
-      if (auto m = P->getMatchExpr())
+      if (auto m = P->getCachedMatchExpr())
         printRec(m);
       else
         printRec(P->getSubExpr());

lib/AST/ASTWalker.cpp

@@ -1964,8 +1964,8 @@ Pattern *Traversal::visitEnumElementPattern(EnumElementPattern *P) {
 Pattern *Traversal::visitExprPattern(ExprPattern *P) {
   // If the pattern has been type-checked, walk the match expression, which
   // includes the explicit subexpression.
-  if (P->getMatchExpr()) {
-    if (Expr *newMatch = doIt(P->getMatchExpr())) {
+  if (auto *match = P->getCachedMatchExpr()) {
+    if (Expr *newMatch = doIt(match)) {
       P->setMatchExpr(newMatch);
       return P;
     }

lib/AST/Pattern.cpp

@@ -19,6 +19,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeLoc.h"
 #include "swift/AST/TypeRepr.h"
 #include "swift/Basic/Statistic.h"
@@ -333,9 +334,8 @@ EnumElementDecl *OptionalSomePattern::getElementDecl() const {
 /// Return true if this is a non-resolved ExprPattern which is syntactically
 /// irrefutable.
 static bool isIrrefutableExprPattern(const ExprPattern *EP) {
-  // If the pattern has a registered match expression, it's
-  // a type-checked ExprPattern.
-  if (EP->getMatchExpr()) return false;
+  // If the pattern is resolved, it must be irrefutable.
+  if (EP->isResolved()) return false;
 
   auto expr = EP->getSubExpr();
   while (true) {
@@ -501,20 +501,35 @@ void IsPattern::setCastType(Type type) {
 
 TypeRepr *IsPattern::getCastTypeRepr() const { return CastType->getTypeRepr(); }
 
-ExprPattern *ExprPattern::createParsed(ASTContext &ctx, Expr *E) {
-  return new (ctx) ExprPattern(E, /*isResolved*/ false);
+ExprPattern *ExprPattern::createParsed(ASTContext &ctx, Expr *E,
+                                       DeclContext *DC) {
+  return new (ctx) ExprPattern(E, DC, /*isResolved*/ false);
 }
 
-ExprPattern *ExprPattern::createResolved(ASTContext &ctx, Expr *E) {
-  return new (ctx) ExprPattern(E, /*isResolved*/ true);
+ExprPattern *ExprPattern::createResolved(ASTContext &ctx, Expr *E,
+                                         DeclContext *DC) {
+  return new (ctx) ExprPattern(E, DC, /*isResolved*/ true);
 }
 
-ExprPattern *ExprPattern::createImplicit(ASTContext &ctx, Expr *E) {
-  auto *EP = ExprPattern::createResolved(ctx, E);
+ExprPattern *ExprPattern::createImplicit(ASTContext &ctx, Expr *E,
+                                         DeclContext *DC) {
+  auto *EP = ExprPattern::createResolved(ctx, E, DC);
   EP->setImplicit();
   return EP;
 }
 
+Expr *ExprPattern::getMatchExpr() const {
+  auto &eval = DC->getASTContext().evaluator;
+  return evaluateOrDefault(eval, ExprPatternMatchRequest{this}, None)
+      .getMatchExpr();
+}
+
+VarDecl *ExprPattern::getMatchVar() const {
+  auto &eval = DC->getASTContext().evaluator;
+  return evaluateOrDefault(eval, ExprPatternMatchRequest{this}, None)
+      .getMatchVar();
+}
+
 SourceLoc EnumElementPattern::getStartLoc() const {
   return (ParentType && !ParentType->isImplicit())
              ? ParentType->getSourceRange().Start
@@ -616,5 +631,13 @@ bool ContextualPattern::allowsInference() const {
 
 void swift::simple_display(llvm::raw_ostream &out,
                            const ContextualPattern &pattern) {
-  out << "(pattern @ " << pattern.getPattern() << ")";
+  simple_display(out, pattern.getPattern());
+}
+
+void swift::simple_display(llvm::raw_ostream &out, const Pattern *pattern) {
+  out << "(pattern @ " << pattern << ")";
+}
+
+SourceLoc swift::extractNearestSourceLoc(const Pattern *pattern) {
+  return pattern->getLoc();
 }

lib/AST/TypeCheckRequests.cpp

@@ -1011,6 +1011,25 @@ void NamingPatternRequest::cacheResult(NamedPattern *value) const {
   VD->NamingPattern = value;
 }
 
+//----------------------------------------------------------------------------//
+// ExprPatternMatchRequest caching.
+//----------------------------------------------------------------------------//
+
+Optional<ExprPatternMatchResult>
+ExprPatternMatchRequest::getCachedResult() const {
+  auto *EP = std::get<0>(getStorage());
+  if (!EP->MatchVar)
+    return None;
+
+  return ExprPatternMatchResult(EP->MatchVar, EP->MatchExpr);
+}
+
+void ExprPatternMatchRequest::cacheResult(ExprPatternMatchResult result) const {
+  auto *EP = std::get<0>(getStorage());
+  EP->MatchVar = result.getMatchVar();
+  EP->MatchExpr = result.getMatchExpr();
+}
+
 //----------------------------------------------------------------------------//
 // InterfaceTypeRequest computation.
 //----------------------------------------------------------------------------//

lib/IDE/ExprContextAnalysis.cpp

@@ -1185,11 +1185,15 @@ class ExprContextAnalyzer {
     switch (P->getKind()) {
     case PatternKind::Expr: {
       auto ExprPat = cast<ExprPattern>(P);
-      if (auto D = ExprPat->getMatchVar()) {
-        if (D->hasInterfaceType())
-          recordPossibleType(
-              D->getDeclContext()->mapTypeIntoContext(D->getInterfaceType()));
-      }
+      if (!ExprPat->isResolved())
+        break;
+
+      auto D = ExprPat->getMatchVar();
+      if (!D || !D->hasInterfaceType())
+        break;
+
+      auto *DC = D->getDeclContext();
+      recordPossibleType(DC->mapTypeIntoContext(D->getInterfaceType()));
       break;
     }
     default:

lib/Parse/ParsePattern.cpp

@@ -1321,7 +1321,7 @@ ParserResult<Pattern> Parser::parseMatchingPattern(bool isExprBasic) {
   if (auto *UPE = dyn_cast<UnresolvedPatternExpr>(subExpr.get()))
     return makeParserResult(status, UPE->getSubPattern());
 
-  auto *EP = ExprPattern::createParsed(Context, subExpr.get());
+  auto *EP = ExprPattern::createParsed(Context, subExpr.get(), CurDeclContext);
   return makeParserResult(status, EP);
 }
 

lib/Parse/ParseStmt.cpp

@@ -1095,7 +1095,8 @@ 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 = ExprPattern::createParsed(P.Context, CCE);
+    result.ThePattern =
+        ExprPattern::createParsed(P.Context, CCE, P.CurDeclContext);
     if (P.IDECallbacks) {
       switch (parsingContext) {
       case GuardedPatternContext::Case:

lib/Sema/CSSimplify.cpp

@@ -9850,24 +9850,11 @@ static bool inferEnumMemberThroughTildeEqualsOperator(
 
   // Slots for expression and variable are going to be filled via
   // synthesizing ~= operator application.
-  auto *EP =
-      ExprPattern::createResolved(ctx, pattern->getUnresolvedOriginalExpr());
-
-  auto tildeEqualsApplication =
-      TypeChecker::synthesizeTildeEqualsOperatorApplication(EP, DC, enumTy);
-
-  if (!tildeEqualsApplication)
-    return true;
-
-  VarDecl *matchVar;
-  Expr *matchCall;
-
-  std::tie(matchVar, matchCall) = *tildeEqualsApplication;
-
-  cs.setType(matchVar, enumTy);
-  cs.setType(EP, enumTy);
+  auto *EP = ExprPattern::createResolved(
+      ctx, pattern->getUnresolvedOriginalExpr(), DC);
 
   // result of ~= operator is always a `Bool`.
+  auto *matchCall = EP->getMatchExpr();
   auto target = SolutionApplicationTarget::forExprPattern(
       matchCall, DC, EP, ctx.getBoolDecl()->getDeclaredInterfaceType());
 
@@ -9884,6 +9871,8 @@ static bool inferEnumMemberThroughTildeEqualsOperator(
       return true;
     }
   }
+  cs.setType(EP->getMatchVar(), enumTy);
+  cs.setType(EP, enumTy);
 
   if (cs.generateConstraints(target))
     return true;
@@ -9893,10 +9882,6 @@ static bool inferEnumMemberThroughTildeEqualsOperator(
   cs.addConstraint(ConstraintKind::Conversion, cs.getType(EP->getSubExpr()),
                    elementTy, cs.getConstraintLocator(EP));
 
-  // Store the $match variable and binary expression for solution application.
-  EP->setMatchVar(matchVar);
-  EP->setMatchExpr(matchCall);
-
   cs.setSolutionApplicationTarget(pattern, target);
 
   return false;

lib/Sema/DerivedConformanceCodingKey.cpp

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

lib/Sema/DerivedConformanceRawRepresentable.cpp

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