[CS] Restore a type variable for compatibility with rdar://85263844

Despite being otherwise disconnected from the
constraint system, it's possible for it to affect
how we type-check tuple matches in certain cases.

This is due to the fact that:
- It can have a lower type variable ID than an
opened generic parameter type, so becomes the
representative when merged with it. And because it
has a different locator, this can influence
binding prioritization.
- Tuple subtyping is broken, as it's currently a
*weaker* relationship than conversion.

Therefore, temporarily restore this bit of logic
for language versions < 6. If possible, we should
try and fix tuple subtying in Swift 6 mode to not
accept label mismatches, so that it's not more
permissive than tuple conversion.

rdar://85263844

Author: hamishknight

include/swift/Sema/Constraint.h

@@ -213,6 +213,12 @@ enum class ConstraintKind : char {
   /// one type - type variable representing type of a node, other side is
   /// the AST node to infer the type for.
   ClosureBodyElement,
+  /// Do not add new uses of this, it only exists to retain compatibility for
+  /// rdar://85263844.
+  ///
+  /// Binds the RHS type to a tuple of the params of a function typed LHS. Note
+  /// this discards function parameter flags.
+  BindTupleOfFunctionParams
 };
 
 /// Classification of the different kinds of constraints.
@@ -685,6 +691,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::KeyPath:
     case ConstraintKind::KeyPathApplication:
     case ConstraintKind::Defaultable:
+    case ConstraintKind::BindTupleOfFunctionParams:
       return ConstraintClassification::TypeProperty;
 
     case ConstraintKind::Disjunction:

include/swift/Sema/ConstraintSystem.h

@@ -4748,6 +4748,12 @@ class ConstraintSystem {
                                          TypeMatchOptions flags,
                                          ConstraintLocatorBuilder locator);
 
+  /// Attempt to simplify a BindTupleOfFunctionParams constraint.
+  SolutionKind
+  simplifyBindTupleOfFunctionParamsConstraint(Type first, Type second,
+                                              TypeMatchOptions flags,
+                                              ConstraintLocatorBuilder locator);
+
   /// Attempt to simplify the ApplicableFunction constraint.
   SolutionKind simplifyApplicableFnConstraint(
       Type type1, Type type2,

lib/Sema/CSBindings.cpp

@@ -1378,6 +1378,7 @@ void PotentialBindings::infer(Constraint *constraint) {
   case ConstraintKind::KeyPath:
   case ConstraintKind::ClosureBodyElement:
   case ConstraintKind::Conjunction:
+  case ConstraintKind::BindTupleOfFunctionParams:
     // Constraints from which we can't do anything.
     break;
 

lib/Sema/CSGen.cpp

@@ -1525,6 +1525,19 @@ namespace {
         auto methodTy =
             CS.createTypeVariable(memberTypeLoc, TVO_CanBindToNoEscape);
 
+        // HACK: Bind the function's parameter list as a tuple to a type
+        // variable. This only exists to preserve compatibility with
+        // rdar://85263844, as it can affect the prioritization of bindings,
+        // which can affect behavior for tuple matching as tuple subtyping is
+        // currently a *weaker* constraint than tuple conversion.
+        if (!CS.getASTContext().isSwiftVersionAtLeast(6)) {
+          auto paramTypeVar = CS.createTypeVariable(
+              CS.getConstraintLocator(expr, ConstraintLocator::ApplyArgument),
+              TVO_CanBindToLValue | TVO_CanBindToInOut | TVO_CanBindToNoEscape);
+          CS.addConstraint(ConstraintKind::BindTupleOfFunctionParams, methodTy,
+                           paramTypeVar, CS.getConstraintLocator(expr));
+        }
+
         CS.addValueMemberConstraint(
             baseTy, expr->getName(), methodTy, CurDC,
             expr->getFunctionRefKind(),

lib/Sema/CSSimplify.cpp

@@ -1700,6 +1700,7 @@ ConstraintSystem::matchTupleTypes(TupleType *tuple1, TupleType *tuple2,
   case ConstraintKind::UnresolvedMemberChainBase:
   case ConstraintKind::PropertyWrapper:
   case ConstraintKind::ClosureBodyElement:
+  case ConstraintKind::BindTupleOfFunctionParams:
     llvm_unreachable("Not a conversion");
   }
 
@@ -1839,6 +1840,7 @@ static bool matchFunctionRepresentations(FunctionType::ExtInfo einfo1,
   case ConstraintKind::UnresolvedMemberChainBase:
   case ConstraintKind::PropertyWrapper:
   case ConstraintKind::ClosureBodyElement:
+  case ConstraintKind::BindTupleOfFunctionParams:
     return true;
   }
 
@@ -2250,6 +2252,7 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
   case ConstraintKind::UnresolvedMemberChainBase:
   case ConstraintKind::PropertyWrapper:
   case ConstraintKind::ClosureBodyElement:
+  case ConstraintKind::BindTupleOfFunctionParams:
     llvm_unreachable("Not a relational constraint");
   }
 
@@ -5337,6 +5340,7 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
     case ConstraintKind::UnresolvedMemberChainBase:
     case ConstraintKind::PropertyWrapper:
     case ConstraintKind::ClosureBodyElement:
+    case ConstraintKind::BindTupleOfFunctionParams:
       llvm_unreachable("Not a relational constraint");
     }
   }
@@ -6308,6 +6312,19 @@ ConstraintSystem::simplifyConstructionConstraint(
                              fnLocator, 
                              ConstraintLocator::ConstructorMember));
 
+  // HACK: Bind the function's parameter list as a tuple to a type variable.
+  // This only exists to preserve compatibility with rdar://85263844, as it can
+  // affect the prioritization of bindings, which can affect behavior for tuple
+  // matching as tuple subtyping is currently a *weaker* constraint than tuple
+  // conversion.
+  if (!getASTContext().isSwiftVersionAtLeast(6)) {
+    auto paramTypeVar = createTypeVariable(
+        getConstraintLocator(locator, ConstraintLocator::ApplyArgument),
+        TVO_CanBindToLValue | TVO_CanBindToInOut | TVO_CanBindToNoEscape);
+    addConstraint(ConstraintKind::BindTupleOfFunctionParams, memberType,
+                  paramTypeVar, locator);
+  }
+
   addConstraint(ConstraintKind::ApplicableFunction, fnType, memberType,
                 fnLocator);
 
@@ -7131,6 +7148,59 @@ ConstraintSystem::simplifyOptionalObjectConstraint(
   return SolutionKind::Solved;
 }
 
+ConstraintSystem::SolutionKind
+ConstraintSystem::simplifyBindTupleOfFunctionParamsConstraint(
+    Type first, Type second, TypeMatchOptions flags,
+    ConstraintLocatorBuilder locator) {
+  auto simplified = simplifyType(first);
+  auto simplifiedCopy = simplified;
+
+  unsigned unwrapCount = 0;
+  if (shouldAttemptFixes()) {
+    while (auto objectTy = simplified->getOptionalObjectType()) {
+      simplified = objectTy;
+
+      // Track how many times we do this so that we can record a fix for each.
+      ++unwrapCount;
+    }
+
+    if (simplified->isPlaceholder()) {
+      if (auto *typeVar = second->getAs<TypeVariableType>())
+        recordPotentialHole(typeVar);
+      return SolutionKind::Solved;
+    }
+  }
+
+  if (simplified->isTypeVariableOrMember()) {
+    if (!flags.contains(TMF_GenerateConstraints))
+      return SolutionKind::Unsolved;
+
+    addUnsolvedConstraint(
+        Constraint::create(*this, ConstraintKind::BindTupleOfFunctionParams,
+                           simplified, second, getConstraintLocator(locator)));
+    return SolutionKind::Solved;
+  }
+
+  auto *funcTy = simplified->getAs<FunctionType>();
+  if (!funcTy)
+    return SolutionKind::Error;
+
+  auto tupleTy =
+      AnyFunctionType::composeTuple(getASTContext(), funcTy->getParams(),
+                                    /*wantParamFlags*/ false);
+
+  addConstraint(ConstraintKind::Bind, tupleTy, second,
+                locator.withPathElement(ConstraintLocator::FunctionArgument));
+
+  if (unwrapCount > 0) {
+    auto *fix = ForceOptional::create(*this, simplifiedCopy, second,
+                                      getConstraintLocator(locator));
+    if (recordFix(fix, /*impact=*/unwrapCount))
+      return SolutionKind::Error;
+  }
+  return SolutionKind::Solved;
+}
+
 static bool isForKeyPathSubscript(ConstraintSystem &cs,
                                   ConstraintLocator *locator) {
   if (!locator || !locator->getAnchor())
@@ -12046,6 +12116,10 @@ ConstraintSystem::addConstraintImpl(ConstraintKind kind, Type first,
     return simplifyUnresolvedMemberChainBaseConstraint(first, second, subflags,
                                                        locator);
 
+  case ConstraintKind::BindTupleOfFunctionParams:
+    return simplifyBindTupleOfFunctionParamsConstraint(first, second, subflags,
+                                                       locator);
+
   case ConstraintKind::ValueMember:
   case ConstraintKind::UnresolvedValueMember:
   case ConstraintKind::ValueWitness:
@@ -12588,6 +12662,11 @@ ConstraintSystem::simplifyConstraint(const Constraint &constraint) {
     return simplifyClosureBodyElementConstraint(
         constraint.getClosureElement(), constraint.getElementContext(),
         /*flags=*/None, constraint.getLocator());
+
+  case ConstraintKind::BindTupleOfFunctionParams:
+    return simplifyBindTupleOfFunctionParamsConstraint(
+        constraint.getFirstType(), constraint.getSecondType(), /*flags*/ None,
+        constraint.getLocator());
   }
 
   llvm_unreachable("Unhandled ConstraintKind in switch.");

lib/Sema/Constraint.cpp

@@ -77,6 +77,7 @@ Constraint::Constraint(ConstraintKind Kind, Type First, Type Second,
   case ConstraintKind::OneWayBindParam:
   case ConstraintKind::UnresolvedMemberChainBase:
   case ConstraintKind::PropertyWrapper:
+  case ConstraintKind::BindTupleOfFunctionParams:
     assert(!First.isNull());
     assert(!Second.isNull());
     break;
@@ -161,6 +162,7 @@ Constraint::Constraint(ConstraintKind Kind, Type First, Type Second, Type Third,
   case ConstraintKind::UnresolvedMemberChainBase:
   case ConstraintKind::PropertyWrapper:
   case ConstraintKind::ClosureBodyElement:
+  case ConstraintKind::BindTupleOfFunctionParams:
     llvm_unreachable("Wrong constructor");
 
   case ConstraintKind::KeyPath:
@@ -303,6 +305,7 @@ Constraint *Constraint::clone(ConstraintSystem &cs) const {
   case ConstraintKind::DefaultClosureType:
   case ConstraintKind::UnresolvedMemberChainBase:
   case ConstraintKind::PropertyWrapper:
+  case ConstraintKind::BindTupleOfFunctionParams:
     return create(cs, getKind(), getFirstType(), getSecondType(), getLocator());
 
   case ConstraintKind::ApplicableFunction:
@@ -503,6 +506,10 @@ void Constraint::print(llvm::raw_ostream &Out, SourceManager *sm) const {
     Out << " can default to ";
     break;
 
+  case ConstraintKind::BindTupleOfFunctionParams:
+    Out << " bind tuple of function params to ";
+    break;
+
   case ConstraintKind::Disjunction:
     llvm_unreachable("disjunction handled above");
   case ConstraintKind::Conjunction:
@@ -663,6 +670,7 @@ gatherReferencedTypeVars(Constraint *constraint,
   case ConstraintKind::DefaultClosureType:
   case ConstraintKind::UnresolvedMemberChainBase:
   case ConstraintKind::PropertyWrapper:
+  case ConstraintKind::BindTupleOfFunctionParams:
     constraint->getFirstType()->getTypeVariables(typeVars);
     constraint->getSecondType()->getTypeVariables(typeVars);
     break;

test/Constraints/construction.swift

@@ -267,6 +267,26 @@ func test_that_optionality_of_closure_result_is_preserved() {
 
 // rdar://85263844 - initializer 'init(_:)' requires the types be equivalent
 func rdar85263844(arr: [(q: String, a: Int)]) -> AnySequence<(question: String, answer: Int)> {
-  AnySequence(arr.map { $0 }) // FIXME: This is supposed to type-check.
-  // expected-error@-1 {{initializer 'init(_:)' requires the types '(question: String, answer: Int)' and '(q: String, a: Int)' be equivalent}}
+  AnySequence(arr.map { $0 })
+}
+
+// Another case for rdar://85263844
+protocol P {
+  associatedtype Element
+}
+extension Array : P {}
+
+public struct S4<T> {
+  init<S : P>(_ x: S) where S.Element == T {}
+  init(_ x: Int) {}
+}
+
+extension S4 where T == (outer: Int, y: Int) {
+  init(arr: [Int]) {
+    self.init(arr.map { (inner: $0, y: $0) })
+  }
+}
+
+public func rdar85263844_2(_ x: [Int]) -> S4<(outer: Int, y: Int)> {
+  S4(x.map { (inner: $0, y: $0) })
 }

test/Constraints/rdar85263844_swift6.swift

@@ -0,0 +1,35 @@
+// RUN: %target-typecheck-verify-swift -swift-version 6
+
+// '-swift-version 6' is currently asserts-only
+// REQUIRES: asserts
+
+// rdar://85263844 - initializer 'init(_:)' requires the types be equivalent
+func rdar85263844(arr: [(q: String, a: Int)]) -> AnySequence<(question: String, answer: Int)> {
+  AnySequence(arr.map { $0 })
+  // expected-error@-1 {{initializer 'init(_:)' requires the types '(question: String, answer: Int)' and '(q: String, a: Int)' be equivalent}}
+}
+
+// Another case for rdar://85263844
+protocol P {
+  associatedtype Element
+}
+extension Array : P {}
+
+public struct S4<T> {
+  init<S : P>(_ x: S) where S.Element == T {}
+  init(_ x: Int) {}
+}
+
+extension S4 where T == (outer: Int, y: Int) {
+  init(arr: [Int]) {
+    // FIXME: This ideally shouldn't compile either, but because of the way we
+    // generate constraints for it, it continues to compile. We should fix
+    // tuple subtyping for Swift 6 mode to not accept label mismatches.
+    self.init(arr.map { (inner: $0, y: $0) })
+  }
+}
+
+public func rdar85263844_2(_ x: [Int]) -> S4<(outer: Int, y: Int)> {
+  // FIXME: Bad error message.
+  S4(x.map { (inner: $0, y: $0) }) // expected-error {{type of expression is ambiguous without more context}}
+}