Sema: Support optional promotion of tuple patterns

include/swift/AST/DiagnosticsSema.def

@@ -4635,8 +4635,9 @@ WARNING(found_one_pattern_for_several_associated_values,Deprecation,
 WARNING(converting_tuple_into_several_associated_values,none,
         "enum case '%0' has %1 associated values", (StringRef, unsigned))
 WARNING(converting_several_associated_values_into_tuple,none,
-        "enum case '%0' has one associated value that is a tuple of %1 "
-        "elements",(StringRef, unsigned))
+        "enum case '%0' has one associated value that is a %select{|optional }1"
+        "tuple of %2 elements",
+        (StringRef, bool, unsigned))
 ERROR(closure_argument_list_tuple,none,
       "contextual closure type %0 expects %1 argument%s1, "
       "but %2 %select{were|was}3 used in closure body", (Type, unsigned, unsigned, bool))

include/swift/Sema/Constraint.h

@@ -158,6 +158,11 @@ enum class ConstraintKind : char {
   /// The first type is an optional type whose object type is the second
   /// type, preserving lvalue-ness.
   OptionalObject,
+  /// The first type is an optional of non-negative depth of the second type,
+  /// ignoring lvalueness (because the constraint is currently applied only to
+  /// pattern types, which are always rvalue). For example, given a RHS of
+  /// 'Int', a LHS of 'Int' or 'Int??' would satisfy this constraint.
+  EqualOrOptional,
   /// The first type is the same function type as the second type, but
   /// made @escaping.
   EscapableFunctionOf,
@@ -696,6 +701,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::DynamicCallableApplicableFunction:
     case ConstraintKind::BindOverload:
     case ConstraintKind::OptionalObject:
+    case ConstraintKind::EqualOrOptional:
     case ConstraintKind::OneWayEqual:
     case ConstraintKind::OneWayBindParam:
     case ConstraintKind::DefaultClosureType:

include/swift/Sema/ConstraintSystem.h

@@ -4693,6 +4693,12 @@ class ConstraintSystem {
                                           TypeMatchOptions flags,
                                           ConstraintLocatorBuilder locator);
 
+  /// Attempt to simplify an equal-or-optional constraint.
+  SolutionKind
+  simplifyEqualOrOptionalConstraint(Type first, Type second,
+                                    TypeMatchOptions flags,
+                                    ConstraintLocatorBuilder locator);
+
   /// Attempt to simplify the BridgingConversion constraint.
   SolutionKind simplifyBridgingConstraint(Type type1,
                                          Type type2,

lib/Sema/CSBindings.cpp

@@ -1440,6 +1440,7 @@ void PotentialBindings::infer(Constraint *constraint) {
   case ConstraintKind::ArgumentConversion:
   case ConstraintKind::OperatorArgumentConversion:
   case ConstraintKind::OptionalObject:
+  case ConstraintKind::EqualOrOptional:
   case ConstraintKind::UnresolvedMemberChainBase: {
     auto binding = inferFromRelational(constraint);
     if (!binding)

lib/Sema/CSGen.cpp

@@ -2710,7 +2710,24 @@ namespace {
           tupleTypeElts.push_back(TupleTypeElt(eltTy, tupleElt.getLabel()));
         }
 
-        return setType(TupleType::get(tupleTypeElts, CS.getASTContext()));
+        Type patternTy = TupleType::get(tupleTypeElts, CS.getASTContext());
+
+        // 1. Allow optional promotion only when the matching is conditional,
+        //    i.e., not in pattern binding declarations.
+        // 2. A single-element tuple can only mean that we are matching the
+        //    payload of an enum case without splatting, in which case optional
+        //    promotion is irrelevant.
+        if (!patternBinding && tupleTypeElts.size() > 1) {
+          Type tyVar = CS.createTypeVariable(CS.getConstraintLocator(locator),
+                                             TVO_CanBindToNoEscape);
+          CS.addConstraint(
+              ConstraintKind::EqualOrOptional, tyVar, patternTy,
+              locator.withPathElement(LocatorPathElt::PatternMatch(pattern)));
+
+          patternTy = tyVar;
+        }
+
+        return setType(patternTy);
       }
 
       case PatternKind::OptionalSome: {

lib/Sema/CSSimplify.cpp

@@ -2244,6 +2244,7 @@ ConstraintSystem::matchTupleTypes(TupleType *tuple1, TupleType *tuple2,
   case ConstraintKind::KeyPathApplication:
   case ConstraintKind::LiteralConformsTo:
   case ConstraintKind::OptionalObject:
+  case ConstraintKind::EqualOrOptional:
   case ConstraintKind::SelfObjectOfProtocol:
   case ConstraintKind::UnresolvedValueMember:
   case ConstraintKind::ValueMember:
@@ -2619,6 +2620,7 @@ static bool matchFunctionRepresentations(FunctionType::ExtInfo einfo1,
   case ConstraintKind::KeyPathApplication:
   case ConstraintKind::LiteralConformsTo:
   case ConstraintKind::OptionalObject:
+  case ConstraintKind::EqualOrOptional:
   case ConstraintKind::SelfObjectOfProtocol:
   case ConstraintKind::UnresolvedValueMember:
   case ConstraintKind::ValueMember:
@@ -3126,6 +3128,7 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
   case ConstraintKind::KeyPathApplication:
   case ConstraintKind::LiteralConformsTo:
   case ConstraintKind::OptionalObject:
+  case ConstraintKind::EqualOrOptional:
   case ConstraintKind::SelfObjectOfProtocol:
   case ConstraintKind::UnresolvedValueMember:
   case ConstraintKind::ValueMember:
@@ -6732,6 +6735,7 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
     case ConstraintKind::KeyPathApplication:
     case ConstraintKind::LiteralConformsTo:
     case ConstraintKind::OptionalObject:
+    case ConstraintKind::EqualOrOptional:
     case ConstraintKind::SelfObjectOfProtocol:
     case ConstraintKind::UnresolvedValueMember:
     case ConstraintKind::ValueMember:
@@ -8873,6 +8877,60 @@ ConstraintSystem::simplifyOptionalObjectConstraint(
   return SolutionKind::Solved;
 }
 
+ConstraintSystem::SolutionKind
+ConstraintSystem::simplifyEqualOrOptionalConstraint(
+    Type first, Type second, TypeMatchOptions flags,
+    ConstraintLocatorBuilder locator) {
+  // Reify all the type variables we can.
+  first = getFixedTypeRecursive(first, flags, /*wantRValue=*/false);
+  second = getFixedTypeRecursive(second, flags, /*wantRValue=*/false);
+
+  assert(!first->hasLValueType() && !second->hasLValueType() &&
+         "Unexpected lvalue; constraint operand is not a pattern type?");
+
+  if (first->isEqual(second)) {
+    return SolutionKind::Solved;
+  }
+
+  // Unwrap both types simultaneously until one of them is no longer optional.
+  while (true) {
+    if (auto firstObject = first->getOptionalObjectType()) {
+      if (auto secondObject = second->getOptionalObjectType()) {
+        first = firstObject;
+        second = secondObject;
+        continue;
+      }
+    }
+
+    break;
+  }
+
+  const Type firstUnwrapped = first->lookThroughAllOptionalTypes();
+
+  // At this point at most one of the two types is a known optional. The
+  // constraint can be reduced to an equation between the fully unwrapped LHS
+  // and the RHS — and thus solved — if the following conditions are met:
+  // 1. The fully unwrapped LHS is not a type variable.
+  // 2. Either the LHS is not optional to begin with, or the RHS is not a
+  //    type variable.
+
+  if (firstUnwrapped->isTypeVariableOrMember() ||
+      (first->isOptional() && second->isTypeVariableOrMember())) {
+    if (!flags.contains(TMF_GenerateConstraints)) {
+      return SolutionKind::Unsolved;
+    }
+
+    addUnsolvedConstraint(
+        Constraint::create(*this, ConstraintKind::EqualOrOptional, first,
+                           second, getConstraintLocator(locator)));
+    return SolutionKind::Solved;
+  }
+
+  addConstraint(ConstraintKind::Bind, firstUnwrapped, second, locator);
+
+  return SolutionKind::Solved;
+}
+
 ConstraintSystem::SolutionKind
 ConstraintSystem::simplifyBindTupleOfFunctionParamsConstraint(
     Type first, Type second, TypeMatchOptions flags,
@@ -14528,6 +14586,9 @@ ConstraintSystem::addConstraintImpl(ConstraintKind kind, Type first,
   case ConstraintKind::OptionalObject:
     return simplifyOptionalObjectConstraint(first, second, subflags, locator);
 
+  case ConstraintKind::EqualOrOptional:
+    return simplifyEqualOrOptionalConstraint(first, second, subflags, locator);
+
   case ConstraintKind::Defaultable:
     return simplifyDefaultableConstraint(first, second, subflags, locator);
 
@@ -15074,7 +15135,12 @@ ConstraintSystem::simplifyConstraint(const Constraint &constraint) {
                                             constraint.getSecondType(),
                                             /*flags*/ None,
                                             constraint.getLocator());
-
+
+  case ConstraintKind::EqualOrOptional:
+    return simplifyEqualOrOptionalConstraint(
+        constraint.getFirstType(), constraint.getSecondType(),
+        /*flags*/ None, constraint.getLocator());
+
   case ConstraintKind::ValueMember:
   case ConstraintKind::UnresolvedValueMember:
     return simplifyMemberConstraint(constraint.getKind(),

lib/Sema/CSSyntacticElement.cpp

@@ -624,8 +624,8 @@ class SyntacticElementConstraintGenerator
       return;
     }
 
-    // Convert the contextual type to the pattern, which establishes the
-    // bindings.
+    // Require a conversion from the contextual type to the pattern type, which
+    // establishes the bindings.
     cs.addConstraint(ConstraintKind::Conversion, context.getType(), patternType,
                      locator);
 

lib/Sema/Constraint.cpp

@@ -74,6 +74,7 @@ Constraint::Constraint(ConstraintKind Kind, Type First, Type Second,
   case ConstraintKind::EscapableFunctionOf:
   case ConstraintKind::OpenedExistentialOf:
   case ConstraintKind::OptionalObject:
+  case ConstraintKind::EqualOrOptional:
   case ConstraintKind::OneWayEqual:
   case ConstraintKind::OneWayBindParam:
   case ConstraintKind::UnresolvedMemberChainBase:
@@ -152,6 +153,7 @@ Constraint::Constraint(ConstraintKind Kind, Type First, Type Second, Type Third,
   case ConstraintKind::EscapableFunctionOf:
   case ConstraintKind::OpenedExistentialOf:
   case ConstraintKind::OptionalObject:
+  case ConstraintKind::EqualOrOptional:
   case ConstraintKind::ApplicableFunction:
   case ConstraintKind::DynamicCallableApplicableFunction:
   case ConstraintKind::ValueMember:
@@ -309,6 +311,7 @@ Constraint *Constraint::clone(ConstraintSystem &cs) const {
   case ConstraintKind::SelfObjectOfProtocol:
   case ConstraintKind::DynamicCallableApplicableFunction:
   case ConstraintKind::OptionalObject:
+  case ConstraintKind::EqualOrOptional:
   case ConstraintKind::Defaultable:
   case ConstraintKind::OneWayEqual:
   case ConstraintKind::OneWayBindParam:
@@ -493,6 +496,9 @@ void Constraint::print(llvm::raw_ostream &Out, SourceManager *sm,
       break;
   case ConstraintKind::OptionalObject:
       Out << " optional with object type "; break;
+  case ConstraintKind::EqualOrOptional:
+    Out << " equal to or optional of ";
+    break;
   case ConstraintKind::BindOverload: {
     Out << " bound to ";
     auto overload = getOverloadChoice();
@@ -727,6 +733,7 @@ gatherReferencedTypeVars(Constraint *constraint,
   case ConstraintKind::EscapableFunctionOf:
   case ConstraintKind::OpenedExistentialOf:
   case ConstraintKind::OptionalObject:
+  case ConstraintKind::EqualOrOptional:
   case ConstraintKind::Defaultable:
   case ConstraintKind::SubclassOf:
   case ConstraintKind::ConformsTo: