[CS] Connect arg-to-param constraint to function builder

Previously we could inadvertently split the
constraint system without realizing that a function
builder with a generic argument may allow the
closure body to reference a type variable that
connects it to the enclosing expression.

Fix this issue by checking for an unresolved
closure argument and forming an unresolved argument
conversion constraint that includes any type
variables from the function builder type.

Resolves SR-13183
Resolves rdar://problem/65695054

Author: hamishknight

lib/Sema/CSSimplify.cpp

@@ -9905,9 +9905,11 @@ ConstraintSystem::addConstraintImpl(ConstraintKind kind, Type first,
   case ConstraintKind::BindToPointerType:
   case ConstraintKind::Subtype:
   case ConstraintKind::Conversion:
+    return matchTypes(first, second, kind, subflags, locator);
+
   case ConstraintKind::ArgumentConversion:
   case ConstraintKind::OperatorArgumentConversion:
-    return matchTypes(first, second, kind, subflags, locator);
+    return addArgumentConversionConstraintImpl(kind, first, second, locator);
 
   case ConstraintKind::OpaqueUnderlyingType:
     return simplifyOpaqueUnderlyingTypeConstraint(first, second,
@@ -9977,6 +9979,36 @@ ConstraintSystem::addConstraintImpl(ConstraintKind kind, Type first,
   llvm_unreachable("Unhandled ConstraintKind in switch.");
 }
 
+ConstraintSystem::SolutionKind
+ConstraintSystem::addArgumentConversionConstraintImpl(
+    ConstraintKind kind, Type first, Type second,
+    ConstraintLocatorBuilder locator) {
+  assert(kind == ConstraintKind::ArgumentConversion ||
+         kind == ConstraintKind::OperatorArgumentConversion);
+
+  // If we have an unresolved closure argument, form an unsolved argument
+  // conversion constraint, making sure to reference the type variables for
+  // a function builder if applicable. This ensures we properly connect the
+  // closure type variable with any type variables in the function builder, as
+  // such type variables will be accessible within the body of the closure when
+  // we open it.
+  first = getFixedTypeRecursive(first, /*rvalue*/ false);
+  if (auto *argTypeVar = first->getAs<TypeVariableType>()) {
+    if (argTypeVar->getImpl().isClosureType()) {
+      // Extract any type variables present in the parameter's function builder.
+      SmallVector<TypeVariableType *, 4> typeVars;
+      if (auto builderTy = getOpenedFunctionBuilderTypeFor(*this, locator))
+        builderTy->getTypeVariables(typeVars);
+
+      auto *loc = getConstraintLocator(locator);
+      addUnsolvedConstraint(
+          Constraint::create(*this, kind, first, second, loc, typeVars));
+      return SolutionKind::Solved;
+    }
+  }
+  return matchTypes(first, second, kind, TMF_GenerateConstraints, locator);
+}
+
 void
 ConstraintSystem::addKeyPathApplicationRootConstraint(Type root, ConstraintLocatorBuilder locator) {
   // If this is a subscript with a KeyPath expression, add a constraint that

lib/Sema/ConstraintSystem.h

@@ -4686,6 +4686,13 @@ class ConstraintSystem {
                                  ConstraintLocatorBuilder locator,
                                  bool isFavored);
 
+  /// Adds a constraint for the conversion of an argument to a parameter. Do not
+  /// call directly, use \c addConstraint instead.
+  SolutionKind
+  addArgumentConversionConstraintImpl(ConstraintKind kind, Type first,
+                                      Type second,
+                                      ConstraintLocatorBuilder locator);
+
   /// Collect the current inactive disjunction constraints.
   void collectDisjunctions(SmallVectorImpl<Constraint *> &disjunctions);
 

test/Constraints/sr13183.swift

@@ -0,0 +1,34 @@
+// RUN: %target-typecheck-verify-swift
+
+// SR-13183: Make sure we don't incorrectly split the constraint system without
+// considering that a function builder type var may connect the inside of a
+// closure body with the enclosing expression.
+
+struct New<Value> {
+  init(value: Value, @ScopeBuilder<Value> scope: () -> Component) { }
+}
+
+struct Component {}
+
+struct Map<Value, Transformed> {
+  let transform: (Value) -> Transformed
+}
+
+@_functionBuilder
+struct ScopeBuilder<Value> {
+  static func buildExpression<T>(_ map: Map<Value, T>) -> Component {
+    Component()
+  }
+
+  static func buildBlock(_ components: Component...) -> Component {
+    Component()
+  }
+}
+
+let new1 = New(value: 42) {
+  Map { $0.description }
+}
+
+let new2 = New<Int>(value: 42) {
+  Map { $0.description }
+}