[CSSimplify] Transfer conformance requirements of a parameter to an argument

Performance optimization to help rule out generic overload choices sooner.

This is based on an observation of the constraint solver behavior,
consider following example:

```swift
func test<U: ExpressibleByStringLiteral>(_: U) {}

test(42)
```

Constraint System for call to `test` is going to look like this:

```
$T_test := ($T_U) -> $T_U
$T_U <conforms to> ExpressibleByStringLiteral
$T_42 <argument conversion> $T_U
$T_42 <literal conforms to> ExpressibleByIntegerLiteral
```

Currently to find out that `test` doesn't match, solver would have
to first find a binding for `$T_42`, then find a binding for `$T_U`
(through `<argument conversion>` constraint) and only later fail
while checking conformance of `Int` to `ExpressibleByStringLiteral`.

Instead of waiting for parameter to be bound, let's transfer conformance
requirements through a conversion constraint directly to an argument type,
since it has to conform to the same set of protocols as parameter to
be convertible (restrictions apply i.e. protocol composition types).

With that change it's possible to verify conformances early and reject
`test<U: ExpressibleByStringLiteral>` overload as soon as type of an
argument has been determined. This especially powerful for chained calls
because solver would only have to check as deep as first invald argument
binding.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -1433,6 +1433,40 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
       assert(!argsWithLabels[argIdx].isAutoClosure() ||
              isSynthesizedArgument(argument));
 
+      // If parameter is a generic parameter, let's copy its
+      // conformance requirements (if any), to the argument
+      // be able to filter mismatching choices earlier.
+      if (auto *typeVar = paramTy->getAs<TypeVariableType>()) {
+        auto *locator = typeVar->getImpl().getLocator();
+        if (locator->isForGenericParameter()) {
+          auto &CG = cs.getConstraintGraph();
+          auto *repr = cs.getRepresentative(typeVar);
+          for (auto *constraint : CG[repr].getConstraints()) {
+            if (constraint->getKind() != ConstraintKind::ConformsTo)
+              continue;
+
+            // This is not a direct requirement.
+            if (!constraint->getFirstType()->isEqual(typeVar))
+              continue;
+
+            // If the composition consists of a class + protocol,
+            // we can't attach conformance to the argument because
+            // parameter would have to pick one of the components.
+            if (argTy.findIf([](Type type) {
+                  return type->is<ProtocolCompositionType>();
+                }))
+              continue;
+
+            auto protocolTy = constraint->getSecondType();
+            if (!protocolTy->is<ProtocolType>())
+              continue;
+
+            cs.addConstraint(ConstraintKind::TransitivelyConformsTo, argTy,
+                             protocolTy, constraint->getLocator());
+          }
+        }
+      }
+
       cs.addConstraint(
           subKind, argTy, paramTy,
           matchingAutoClosureResult
@@ -6193,7 +6227,79 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
 ConstraintSystem::SolutionKind ConstraintSystem::simplifyTransitivelyConformsTo(
     Type type, Type protocolTy, ConstraintLocatorBuilder locator,
     TypeMatchOptions flags) {
-  return SolutionKind::Error;
+  // Since this is a performance optimization, let's ignore it
+  // in diagnostic mode.
+  if (shouldAttemptFixes())
+    return SolutionKind::Solved;
+
+  auto formUnsolved = [&]() {
+    // If we're supposed to generate constraints, do so.
+    if (flags.contains(TMF_GenerateConstraints)) {
+      auto *conformance =
+          Constraint::create(*this, ConstraintKind::TransitivelyConformsTo,
+                             type, protocolTy, getConstraintLocator(locator));
+
+      addUnsolvedConstraint(conformance);
+      return SolutionKind::Solved;
+    }
+
+    return SolutionKind::Unsolved;
+  };
+
+  auto resolvedTy = getFixedTypeRecursive(type, /*wantRValue=*/true);
+  if (resolvedTy->isTypeVariableOrMember())
+    return formUnsolved();
+
+  auto *protocol = protocolTy->castTo<ProtocolType>()->getDecl();
+
+  // First, let's check whether the type itself conforms,
+  // if it does - we are done.
+  if (TypeChecker::conformsToProtocol(resolvedTy, protocol, DC))
+    return SolutionKind::Solved;
+
+  // If the type doesn't conform, let's check whether
+  // an Optional or Unsafe{Mutable}Pointer from it would.
+
+  SmallVector<Type, 4> typesToCheck;
+
+  // Optional<T>
+  typesToCheck.push_back(
+      OptionalType::get(resolvedTy->getWithoutSpecifierType()));
+
+  // Unsafe{Mutable}Pointer<T>
+  {
+    auto &ctx = getASTContext();
+
+    auto *ptrDecl = ctx.getUnsafePointerDecl();
+
+    // String -> UnsafePointer<Void>
+    if (resolvedTy->isEqual(ctx.getStringDecl()->getDeclaredInterfaceType())) {
+      typesToCheck.push_back(BoundGenericType::get(ptrDecl, /*parent=*/Type(),
+                                                   {ctx.TheEmptyTupleType}));
+    }
+
+    // Array<T> -> UnsafePointer<T>
+    if (auto elt = isArrayType(resolvedTy)) {
+      typesToCheck.push_back(
+          BoundGenericType::get(ptrDecl, /*parent=*/Type(), {*elt}));
+    }
+
+    // inout argument -> UnsafePointer<T>, UnsafeMutablePointer<T>
+    if (type->is<InOutType>()) {
+      typesToCheck.push_back(
+          BoundGenericType::get(ptrDecl, /*parent=*/Type(), {resolvedTy}));
+      typesToCheck.push_back(BoundGenericType::get(
+          ctx.getUnsafeMutablePointerDecl(), /*parent=*/Type(), {resolvedTy}));
+    }
+  }
+
+  return llvm::any_of(
+             typesToCheck,
+             [&](Type type) {
+               return bool(TypeChecker::conformsToProtocol(type, protocol, DC));
+             })
+             ? SolutionKind::Solved
+             : SolutionKind::Error;
 }
 
 /// Determine the kind of checked cast to perform from the given type to

validation-test/Sema/type_checker_perf/slow/rdar31439825.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar31439825.swift

@@ -4,4 +4,3 @@
 let a = 1
 
 _ = -a + -a - -a + -a - -a
-// expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}

validation-test/Sema/type_checker_perf/slow/rdar46713933.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar46713933_concrete_args.swift

@@ -7,8 +7,5 @@ func wrap<T: ExpressibleByFloatLiteral>(_ key: String, _ value: T) -> T { return
 func wrap<T: ExpressibleByStringLiteral>(_ key: String, _ value: T) -> T { return value }
 
 func wrapped(i: Int) -> Int {
-  // FIXME: When this stops being "too complex", turn the integer value into
-  // an integer literal.
-  // expected-error@+1{{reasonable time}}
   return wrap("1", i) + wrap("1", i) + wrap("1", i) + wrap("1", i)
 }

validation-test/Sema/type_checker_perf/slow/fast-operator-typechecking.swift

@@ -19,5 +19,4 @@ func f(tail: UInt64, byteCount: UInt64) {
 func size(count: Int) {
   // Size of the buffer we need to allocate
   let _ = count * MemoryLayout<Float>.size * (4 + 3 + 3 + 2 + 4)
-  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
 }