Sema: Optional-promote tuple patterns during solution application

Author: AnthonyLatsis

lib/Sema/TypeCheckPattern.cpp

@@ -1205,6 +1205,24 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
   case PatternKind::Tuple: {
     TuplePattern *TP = cast<TuplePattern>(P);
 
+    // Allow optional promotion only for pattern matching, not pattern binding.
+    const bool allowOptionalPromotion = !pattern.getPatternBindingDecl();
+
+    // If optional promotion is allowed and the coercion type is optional,
+    // pretend we are in the context of an enum case payload.
+    if (allowOptionalPromotion && type->isOptional()) {
+      subOptions.setContext(TypeResolverContext::EnumPatternPayload);
+      subOptions |= TypeResolutionFlags::FromNonInferredPattern;
+    }
+
+    const auto origTy = type;
+    if (allowOptionalPromotion) {
+      // Strip the coercion type of optionality. If the coercion succeeds, we
+      // will promote the resulting pattern to the original type by wrapping it
+      // in 'OptionalSome' patterns.
+      type = type->lookThroughAllOptionalTypes();
+    }
+
     TupleType *tupleTy = type->getAs<TupleType>();
 
     // Sometimes a paren is just a paren. If the tuple pattern has a single
@@ -1277,6 +1295,21 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
       P->setType(type);
     }
 
+    if (allowOptionalPromotion) {
+      // If the original coercion type is optional, promote the resulting
+      // pattern to match the optionality.
+      if (auto wrappedTy = origTy->getOptionalObjectType()) {
+        do {
+          auto *OSP =
+              OptionalSomePattern::createImplicit(Context, P, P->getEndLoc());
+          OSP->setType(OptionalType::get(P->getType()));
+          OSP->setImplicit();
+          P = OSP;
+          wrappedTy = wrappedTy->getOptionalObjectType();
+        } while (wrappedTy);
+      }
+    }
+
     return P;
   }
 
@@ -1561,10 +1594,12 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
       }
     }
 
+    Type elementType;
+    Pattern *sub = EEP->getSubPattern();
+
     // If there is a subpattern, push the enum element type down onto it.
     auto argType = elt->getArgumentInterfaceType();
-    if (EEP->hasSubPattern()) {
-      Pattern *sub = EEP->getSubPattern();
+    if (sub) {
       if (!elt->hasAssociatedValues()) {
         diags.diagnose(EEP->getLoc(),
                        diag::enum_element_pattern_assoc_values_mismatch,
@@ -1574,33 +1609,21 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
           .fixItRemove(sub->getSourceRange());
         return nullptr;
       }
-      
-      Type elementType;
+
       if (argType)
         elementType = enumTy->getTypeOfMember(elt->getModuleContext(),
                                               elt, argType);
       else
         elementType = TupleType::getEmpty(Context);
-      auto newSubOptions = subOptions;
-      newSubOptions.setContext(TypeResolverContext::EnumPatternPayload);
-      newSubOptions |= TypeResolutionFlags::FromNonInferredPattern;
 
       ::repairTupleOrAssociatedValuePatternIfApplicable(
         Context, sub, elementType, elt);
-
-      sub = coercePatternToType(
-          pattern.forSubPattern(sub, /*retainTopLevel=*/false), elementType,
-          newSubOptions);
-      if (!sub)
-        return nullptr;
-
-      EEP->setSubPattern(sub);
     } else if (argType) {
       // Else if the element pattern has no sub-pattern but the element type has
       // associated values, expand it to be semantically equivalent to an
       // element pattern of wildcards.
-      Type elementType = enumTy->getTypeOfMember(elt->getModuleContext(),
-                                                 elt, argType);
+      elementType =
+          enumTy->getTypeOfMember(elt->getModuleContext(), elt, argType);
       SmallVector<TuplePatternElt, 8> elements;
       if (auto *TTy = dyn_cast<TupleType>(elementType.getPointer())) {
         for (auto &elt : TTy->getElements()) {
@@ -1617,17 +1640,34 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
         elements.push_back(TuplePatternElt(Identifier(), SourceLoc(),
                                            subPattern));
       }
-      Pattern *sub = TuplePattern::createSimple(Context, SourceLoc(),
-                                                elements, SourceLoc());
+      sub = TuplePattern::createSimple(Context, SourceLoc(), elements,
+                                       SourceLoc());
       sub->setImplicit();
+    }
+
+    if (sub) {
       auto newSubOptions = subOptions;
       newSubOptions.setContext(TypeResolverContext::EnumPatternPayload);
       newSubOptions |= TypeResolutionFlags::FromNonInferredPattern;
+
       sub = coercePatternToType(
           pattern.forSubPattern(sub, /*retainTopLevel=*/false), elementType,
           newSubOptions);
       if (!sub)
         return nullptr;
+
+      // If we are left with an optional pattern rather than a paren or tuple
+      // pattern, then we must have optional-promoted a splatted tuple, e.g.
+      // 'let .a(x, y)' → 'let .a((x, y)?)' for 'case a((X, Y)?)'.
+      //
+      // Wrap it in an implicit paren pattern to meet structural expectations
+      // about the subpattern of an enum element pattern.
+      if (isa<OptionalSomePattern>(sub)) {
+        assert(sub->isImplicit());
+
+        sub = ParenPattern::createImplicit(Context, sub);
+      }
+
       EEP->setSubPattern(sub);
     }