[CS] NFC: Simplify SyntacticElementTarget construction for ExprPattern

Author: hamishknight

Diff for: include/swift/Sema/SyntacticElementTarget.h

@@ -190,13 +190,6 @@ class SyntacticElementTarget {
                          ConstraintLocator *convertTypeLocator,
                          bool isDiscarded);
 
-  SyntacticElementTarget(Expr *expr, DeclContext *dc, ExprPattern *pattern,
-                         Type patternType)
-      : SyntacticElementTarget(expr, dc, CTP_ExprPattern, patternType,
-                               /*isDiscarded=*/false) {
-    setPattern(pattern);
-  }
-
   SyntacticElementTarget(ClosureExpr *closure, Type convertType) {
     kind = Kind::closure;
     this->closure.closure = closure;
@@ -296,11 +289,8 @@ class SyntacticElementTarget {
   forPropertyWrapperInitializer(VarDecl *wrappedVar, DeclContext *dc,
                                 Expr *initializer);
 
-  static SyntacticElementTarget forExprPattern(Expr *expr, DeclContext *dc,
-                                               ExprPattern *pattern,
-                                               Type patternTy) {
-    return {expr, dc, pattern, patternTy};
-  }
+  /// Form a target for the match expression of an ExprPattern.
+  static SyntacticElementTarget forExprPattern(ExprPattern *pattern);
 
   /// This is useful for code completion.
   ASTNode getAsASTNode() const {

Diff for: lib/Sema/CSSimplify.cpp

@@ -9957,17 +9957,13 @@ static bool inferEnumMemberThroughTildeEqualsOperator(
   if (!pattern->hasUnresolvedOriginalExpr())
     return true;
 
-  auto *DC = pattern->getDeclContext();
   auto &ctx = cs.getASTContext();
 
   // Retrieve a corresponding ExprPattern which we can solve with ~=.
   auto *EP =
       llvm::cantFail(ctx.evaluator(EnumElementExprPatternRequest{pattern}));
 
-  // result of ~= operator is always a `Bool`.
-  auto *matchCall = EP->getMatchExpr();
-  auto target = SyntacticElementTarget::forExprPattern(
-      matchCall, DC, EP, ctx.getBoolDecl()->getDeclaredInterfaceType());
+  auto target = SyntacticElementTarget::forExprPattern(EP);
 
   DiagnosticTransaction diagnostics(ctx.Diags);
   {

Diff for: lib/Sema/SyntacticElementTarget.cpp

@@ -202,6 +202,18 @@ SyntacticElementTarget SyntacticElementTarget::forPropertyWrapperInitializer(
   return target;
 }
 
+SyntacticElementTarget
+SyntacticElementTarget::forExprPattern(ExprPattern *pattern) {
+  auto *DC = pattern->getDeclContext();
+  auto &ctx = DC->getASTContext();
+
+  // Result of ~= operator is always a `Bool`.
+  SyntacticElementTarget target(pattern->getMatchExpr(), DC, CTP_ExprPattern,
+                                ctx.getBoolType(), /*isDiscarded*/ false);
+  target.setPattern(pattern);
+  return target;
+}
+
 ContextualPattern SyntacticElementTarget::getContextualPattern() const {
   if (kind == Kind::uninitializedVar) {
     assert(patternBinding);

Diff for: lib/Sema/TypeCheckConstraints.cpp

@@ -919,7 +919,7 @@ bool TypeChecker::typeCheckCondition(Expr *&expr, DeclContext *dc) {
   return !resultTy;
 }
 
-/// Find the '~=` operator that can compare an expression inside a pattern to a
+/// Find the `~=` operator that can compare an expression inside a pattern to a
 /// value of a given type.
 bool TypeChecker::typeCheckExprPattern(ExprPattern *EP, DeclContext *DC,
                                        Type rhsType) {
@@ -930,13 +930,8 @@ bool TypeChecker::typeCheckExprPattern(ExprPattern *EP, DeclContext *DC,
 
   EP->getMatchVar()->setInterfaceType(rhsType->mapTypeOutOfContext());
 
-  // Result of `~=` should always be a boolean.
-  auto *matchCall = EP->getMatchExpr();
-  auto contextualTy = Context.getBoolDecl()->getDeclaredInterfaceType();
-  auto target =
-      SyntacticElementTarget::forExprPattern(matchCall, DC, EP, contextualTy);
-
   // Check the expression as a condition.
+  auto target = SyntacticElementTarget::forExprPattern(EP);
   auto result = typeCheckExpression(target);
   if (!result)
     return true;