Sema: Allow optional promotion of tuple patterns

AnthonyLatsis · AnthonyLatsis · commit 44b91a612e6b · 2023-04-18T08:25:02.000+03:00
diff --git a/include/swift/Sema/Constraint.h b/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:
diff --git a/include/swift/Sema/ConstraintSystem.h b/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,
diff --git a/lib/Sema/CSBindings.cpp b/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)
diff --git a/lib/Sema/CSGen.cpp b/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: {
diff --git a/lib/Sema/CSSimplify.cpp b/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(),
diff --git a/lib/Sema/CSSyntacticElement.cpp b/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);
 
diff --git a/lib/Sema/Constraint.cpp b/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:
diff --git a/test/Constraints/patterns.swift b/test/Constraints/patterns.swift
@@ -564,3 +564,19 @@ struct TestIUOMatchOp {
     if case self = self {}
   }
 }
+
+// Tuple patterns cannot match existentials without an explicit cast pattern.
+do {
+  enum E {
+    case e
+  }
+
+  let a: Any
+  let i: Int
+
+  // FIXME: Bad diagnostic when matching tuple pattern to existential (https://github.com/apple/swift/issues/65243)
+  if case (i, i) = a {} // expected-error {{type of expression is ambiguous without more context}}
+  if case (0, 0) = a {} // expected-error {{type of expression is ambiguous without more context}}
+
+  if case (E.e, E.e) = a {} // expected-error {{cannot convert value of type 'Any' to specified type '(E, E)'}}
+}
diff --git a/test/SILGen/pattern_matching_optional_promotion.swift.gyb b/test/SILGen/pattern_matching_optional_promotion.swift.gyb
diff --git a/test/Sema/pattern_matching_optional_promotion.swift.gyb b/test/Sema/pattern_matching_optional_promotion.swift.gyb
diff --git a/test/decl/var/variables.swift b/test/decl/var/variables.swift

Original file line number	Diff line number	Diff line change
`@@ -624,8 +624,8 @@ class SyntacticElementConstraintGenerator`
`624`	`624`	`return;`
`625`	`625`	`}`
`626`	`626`
`627`		`- // Convert the contextual type to the pattern, which establishes the`
`628`		`- // bindings.`
	`627`	`+ // Require a conversion from the contextual type to the pattern type, which`
	`628`	`+ // establishes the bindings.`
`629`	`629`	`cs.addConstraint(ConstraintKind::Conversion, context.getType(), patternType,`
`630`	`630`	`locator);`
`631`	`631`