Sema: Support optional promotion of tuple patterns in closure contexts

Author: AnthonyLatsis

include/swift/Sema/SyntacticElementTarget.h

@@ -55,7 +55,7 @@ class SyntacticElementTarget {
     closure,
     function,
     stmtCondition,
-    caseLabelItem,
+    caseStmt,
     patternBinding,
     uninitializedVar,
     forEachStmt,
@@ -139,9 +139,14 @@ class SyntacticElementTarget {
     } stmtCondition;
 
     struct {
-      CaseLabelItem *caseLabelItem;
+      CaseStmt *caseStmt;
+
+      /// The type to which the patterns in case label items should
+      /// be converted.
+      Type convertType;
+
       DeclContext *dc;
-    } caseLabelItem;
+    } caseStmt;
 
     struct {
       PatternBindingDecl *binding;
@@ -218,10 +223,12 @@ class SyntacticElementTarget {
     function.body = body;
   }
 
-  SyntacticElementTarget(CaseLabelItem *caseLabelItem, DeclContext *dc) {
-    kind = Kind::caseLabelItem;
-    this->caseLabelItem.caseLabelItem = caseLabelItem;
-    this->caseLabelItem.dc = dc;
+  SyntacticElementTarget(CaseStmt *caseStmt, Type convertType,
+                         DeclContext *dc) {
+    kind = Kind::caseStmt;
+    this->caseStmt.caseStmt = caseStmt;
+    this->caseStmt.convertType = convertType;
+    this->caseStmt.dc = dc;
   }
 
   SyntacticElementTarget(PatternBindingDecl *patternBinding) {
@@ -324,8 +331,8 @@ class SyntacticElementTarget {
     case Kind::stmtCondition:
       return ASTNode();
 
-    case Kind::caseLabelItem:
-      return *getAsCaseLabelItem();
+    case Kind::caseStmt:
+      return getAsCaseStmt();
 
     case Kind::patternBinding:
       return getAsPatternBinding();
@@ -343,7 +350,7 @@ class SyntacticElementTarget {
     case Kind::closure:
     case Kind::function:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::uninitializedVar:
     case Kind::forEachStmt:
@@ -366,8 +373,8 @@ class SyntacticElementTarget {
     case Kind::stmtCondition:
       return stmtCondition.dc;
 
-    case Kind::caseLabelItem:
-      return caseLabelItem.dc;
+    case Kind::caseStmt:
+      return caseStmt.dc;
 
     case Kind::patternBinding:
       return patternBinding->getDeclContext();
@@ -598,7 +605,7 @@ class SyntacticElementTarget {
     case Kind::expression:
     case Kind::closure:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::uninitializedVar:
     case Kind::forEachStmt:
@@ -615,7 +622,7 @@ class SyntacticElementTarget {
     case Kind::expression:
     case Kind::closure:
     case Kind::function:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::uninitializedVar:
     case Kind::forEachStmt:
@@ -627,7 +634,13 @@ class SyntacticElementTarget {
     llvm_unreachable("invalid statement kind");
   }
 
-  Optional<CaseLabelItem *> getAsCaseLabelItem() const {
+  /// Get the type to which patterns in the \c CaseStmt should be converted.
+  Type getCaseStmtContextualType() const {
+    assert(kind == Kind::caseStmt);
+    return caseStmt.convertType;
+  }
+
+  CaseStmt *getAsCaseStmt() const {
     switch (kind) {
     case Kind::expression:
     case Kind::closure:
@@ -636,10 +649,10 @@ class SyntacticElementTarget {
     case Kind::patternBinding:
     case Kind::uninitializedVar:
     case Kind::forEachStmt:
-      return None;
+      return nullptr;
 
-    case Kind::caseLabelItem:
-      return caseLabelItem.caseLabelItem;
+    case Kind::caseStmt:
+      return caseStmt.caseStmt;
     }
     llvm_unreachable("invalid case label type");
   }
@@ -650,7 +663,7 @@ class SyntacticElementTarget {
     case Kind::closure:
     case Kind::function:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::uninitializedVar:
     case Kind::forEachStmt:
       return nullptr;
@@ -667,7 +680,7 @@ class SyntacticElementTarget {
     case Kind::closure:
     case Kind::function:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::forEachStmt:
       return nullptr;
@@ -684,7 +697,7 @@ class SyntacticElementTarget {
     case Kind::closure:
     case Kind::function:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::forEachStmt:
       return nullptr;
@@ -701,7 +714,7 @@ class SyntacticElementTarget {
     case Kind::closure:
     case Kind::function:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::uninitializedVar:
       return nullptr;
@@ -718,7 +731,7 @@ class SyntacticElementTarget {
     case Kind::closure:
     case Kind::function:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::forEachStmt:
       return nullptr;
@@ -735,7 +748,7 @@ class SyntacticElementTarget {
     case Kind::closure:
     case Kind::function:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::forEachStmt:
       return nullptr;
@@ -752,7 +765,7 @@ class SyntacticElementTarget {
     case Kind::closure:
     case Kind::function:
     case Kind::stmtCondition:
-    case Kind::caseLabelItem:
+    case Kind::caseStmt:
     case Kind::patternBinding:
     case Kind::forEachStmt:
       return 0;
@@ -801,8 +814,8 @@ class SyntacticElementTarget {
       return SourceRange(stmtCondition.stmtCondition.front().getStartLoc(),
                          stmtCondition.stmtCondition.back().getEndLoc());
 
-    case Kind::caseLabelItem:
-      return caseLabelItem.caseLabelItem->getSourceRange();
+    case Kind::caseStmt:
+      return caseStmt.caseStmt->getLabelItemsRange();
 
     case Kind::patternBinding:
       return patternBinding->getSourceRange();
@@ -845,8 +858,8 @@ class SyntacticElementTarget {
     case Kind::stmtCondition:
       return stmtCondition.stmtCondition.front().getStartLoc();
 
-    case Kind::caseLabelItem:
-      return caseLabelItem.caseLabelItem->getStartLoc();
+    case Kind::caseStmt:
+      return caseStmt.caseStmt->getStartLoc();
 
     case Kind::patternBinding:
       return patternBinding->getLoc();

lib/Sema/BuilderTransform.cpp

@@ -766,6 +766,9 @@ class BuilderClosureVisitor
           subjectExpr, LocatorPathElt::ContextualType(CTP_CaseStmt));
       Type subjectType = cs->getType(subjectExpr);
 
+      cs->setTargetFor(caseStmt,
+                       SyntacticElementTarget(caseStmt, subjectType, dc));
+
       if (cs->generateConstraints(caseStmt, dc, subjectType, locator)) {
         hadError = true;
         return nullptr;
@@ -2102,11 +2105,9 @@ class BuilderClosureRewriter
   NullablePtr<Stmt> visitCaseStmt(CaseStmt *caseStmt,
                                   ResultBuilderTarget target) {
     // Translate the patterns and guard expressions for each case label item.
-    for (auto &caseLabelItem : caseStmt->getMutableCaseLabelItems()) {
-      SyntacticElementTarget caseLabelTarget(&caseLabelItem, dc);
-      if (!rewriteTarget(caseLabelTarget))
-        return nullptr;
-    }
+    const auto &cs = solution.getConstraintSystem();
+    if (!rewriteTarget(*cs.getTargetFor(caseStmt)))
+      return nullptr;
 
     // Setup the types of our case body var decls.
     for (auto *expected : caseStmt->getCaseBodyVariablesOrEmptyArray()) {

lib/Sema/CSApply.cpp

@@ -9218,60 +9218,65 @@ ExprWalker::rewriteTarget(SyntacticElementTarget target) {
     }
 
     return target;
-  } else if (auto caseLabelItem = target.getAsCaseLabelItem()) {
+  } else if (auto *caseStmt = target.getAsCaseStmt()) {
     ConstraintSystem &cs = solution.getConstraintSystem();
-    auto info = *cs.getCaseLabelItemInfo(*caseLabelItem);
 
-    // Figure out the pattern type.
-    Type patternType = solution.simplifyType(solution.getType(info.pattern));
-    patternType = patternType->reconstituteSugar(/*recursive=*/false);
+    // Figure out the contextual type for patterns.
+    const Type contextualTy =
+        solution.simplifyType(target.getCaseStmtContextualType())
+            ->reconstituteSugar(/*recursive=*/false)
+            ->getRValueType();
 
-    // Check whether this enum element is resolved via ~= application.
-    if (auto *enumElement = dyn_cast<EnumElementPattern>(info.pattern)) {
-      if (auto target = cs.getTargetFor(enumElement)) {
-        auto *EP = target->getExprPattern();
-        auto enumType = solution.getResolvedType(EP);
+    // Rewrite each case label item.
+    for (auto &item : caseStmt->getMutableCaseLabelItems()) {
+      auto info = *cs.getCaseLabelItemInfo(&item);
 
-        auto *matchCall = target->getAsExpr();
+      // Check whether this enum element is resolved via ~= application.
+      if (auto *enumElement = dyn_cast<EnumElementPattern>(info.pattern)) {
+        if (auto target = cs.getTargetFor(enumElement)) {
+          auto *EP = target->getExprPattern();
+          auto enumType = solution.getResolvedType(EP);
 
-        auto *result = matchCall->walk(*this);
-        if (!result)
-          return None;
+          auto *matchCall = target->getAsExpr();
 
-        {
-          auto *matchVar = EP->getMatchVar();
-          matchVar->setInterfaceType(enumType->mapTypeOutOfContext());
-        }
+          auto *result = matchCall->walk(*this);
+          if (!result)
+            return None;
 
-        EP->setMatchExpr(result);
-        EP->setType(enumType);
+          {
+            auto *matchVar = EP->getMatchVar();
+            matchVar->setInterfaceType(enumType->mapTypeOutOfContext());
+          }
 
-        (*caseLabelItem)->setPattern(EP, /*resolved=*/true);
-        return target;
-      }
-    }
+          EP->setMatchExpr(result);
+          EP->setType(enumType);
 
-    // Coerce the pattern to its appropriate type.
-    TypeResolutionOptions patternOptions(TypeResolverContext::InExpression);
-    patternOptions |= TypeResolutionFlags::OverrideType;
-    auto contextualPattern =
-        ContextualPattern::forRawPattern(info.pattern,
-                                         target.getDeclContext());
-    if (auto coercedPattern = TypeChecker::coercePatternToType(
-            contextualPattern, patternType, patternOptions)) {
-      (*caseLabelItem)->setPattern(coercedPattern, /*resolved=*/true);
-    } else {
-      return None;
-    }
+          item.setPattern(EP, /*resolved=*/true);
+          return target;
+        }
+      }
 
-    // If there is a guard expression, coerce that.
-    if (auto *guardExpr = info.guardExpr) {
-      auto target = *cs.getTargetFor(guardExpr);
-      auto resultTarget = rewriteTarget(target);
-      if (!resultTarget)
+      // Coerce the pattern to its appropriate type.
+      TypeResolutionOptions patternOptions(TypeResolverContext::InExpression);
+      patternOptions |= TypeResolutionFlags::OverrideType;
+      auto contextualPattern = ContextualPattern::forRawPattern(
+          info.pattern, target.getDeclContext());
+      if (auto coercedPattern = TypeChecker::coercePatternToType(
+              contextualPattern, contextualTy, patternOptions)) {
+        item.setPattern(coercedPattern, /*resolved=*/true);
+      } else {
         return None;
+      }
+
+      // If there is a guard expression, coerce that.
+      if (auto *guardExpr = info.guardExpr) {
+        auto target = *cs.getTargetFor(guardExpr);
+        auto resultTarget = rewriteTarget(target);
+        if (!resultTarget)
+          return None;
 
-      (*caseLabelItem)->setGuardExpr(resultTarget->getAsExpr());
+        item.setGuardExpr(resultTarget->getAsExpr());
+      }
     }
 
     return target;

lib/Sema/CSGen.cpp

@@ -4607,7 +4607,7 @@ bool ConstraintSystem::generateConstraints(
     llvm_unreachable("Handled above");
 
   case SyntacticElementTarget::Kind::closure:
-  case SyntacticElementTarget::Kind::caseLabelItem:
+  case SyntacticElementTarget::Kind::caseStmt:
   case SyntacticElementTarget::Kind::function:
   case SyntacticElementTarget::Kind::stmtCondition:
     llvm_unreachable("Handled separately");