[CSBindings] Attempt a type variable early if it's constrained by a struct/enum type

If a type variable has a subtype binding which came from a conversion/subtype/equality
constraint to a struct or enum (expect to `AnyHashable`, `Unsafe{Mutable}RawPointer`),
attempt it early because that type is the only choice which is not going to fail such
constraint.

For example, in cases like `$T argument convertible to Int` type variable could
only be bound to `Int`, `Int!`, or `@lvalue Int` to satisfy that constraint, so
it would make sense to attempt to bind it to `Int` early if it doesn't represent
a result of a member lookup (that's how IUO and/or `@lvalue` could be inferred)`
and doesn't have any direct disjunction associated with it e.g. for coercion or
optional matching.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -360,6 +360,9 @@ class TypeVariableType::Implementation {
   /// a type of a key path expression.
   bool isKeyPathType() const;
 
+  /// Determine whether this type variable represents a subscript result type.
+  bool isSubscriptResultType() const;
+
   /// Retrieve the representative of the equivalence class to which this
   /// type variable belongs.
   ///

lib/Sema/CSBindings.cpp

@@ -981,7 +981,44 @@ bool BindingSet::isViable(PotentialBinding &binding) {
 }
 
 bool BindingSet::favoredOverDisjunction(Constraint *disjunction) const {
-  if (isHole() || isDelayed())
+  if (isHole())
+    return false;
+
+  if (llvm::any_of(Bindings, [&](const PotentialBinding &binding) {
+        if (binding.Kind == AllowedBindingKind::Supertypes)
+          return false;
+
+        auto type = binding.BindingType;
+
+        if (type->isAnyHashable())
+          return false;
+
+        {
+          PointerTypeKind pointerKind;
+          if (type->getAnyPointerElementType(pointerKind)) {
+            switch (pointerKind) {
+            case PTK_UnsafeRawPointer:
+            case PTK_UnsafeMutableRawPointer:
+              return false;
+
+            default:
+              break;
+            }
+          }
+        }
+
+        return type->is<StructType>() || type->is<EnumType>();
+      })) {
+    // Result type of subscript could be l-value so we can't bind it early.
+    if (!TypeVar->getImpl().isSubscriptResultType() &&
+        llvm::none_of(Info.DelayedBy, [](const Constraint *constraint) {
+          return constraint->getKind() == ConstraintKind::Disjunction ||
+                 constraint->getKind() == ConstraintKind::ValueMember;
+        }))
+      return true;
+  }
+
+  if (isDelayed())
     return false;
 
   // If this bindings are for a closure and there are no holes,

lib/Sema/TypeCheckConstraints.cpp

@@ -116,6 +116,14 @@ bool TypeVariableType::Implementation::isKeyPathType() const {
   return locator && locator->isKeyPathType();
 }
 
+bool TypeVariableType::Implementation::isSubscriptResultType() const {
+  if (!(locator && locator->getAnchor()))
+    return false;
+
+  return isExpr<SubscriptExpr>(locator->getAnchor()) &&
+         locator->isLastElement<LocatorPathElt::FunctionResult>();
+}
+
 void *operator new(size_t bytes, ConstraintSystem& cs,
                    size_t alignment) {
   return cs.getAllocator().Allocate(bytes, alignment);

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

@@ -3,9 +3,7 @@
 // rdar://problem/32998180
 func checksum(value: UInt16) -> UInt16 {
   var checksum = (((value >> 2) ^ (value >> 8) ^ (value >> 12) ^ (value >> 14)) & 0x01) << 1
-  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
   checksum |= (((value) ^ (value >> UInt16(4)) ^ (value >> UInt16(6)) ^ (value >> UInt16(10))) & 0x01)
-  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
   checksum ^= 0x02
   return checksum
 }

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

@@ -4,6 +4,5 @@
 func rdar32998180(value: UInt16) -> UInt16 {
   let result = ((((value >> 1) ^ (value >> 1) ^ (value >> 1) ^ (value >> 1)) & 1) << 1)
   | (((((value >> 1) ^ (value >> 1) ^ (value >> 1) ^ (value >> 1)) & 1) << 1) << 1)
-  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
   return result
 }

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

@@ -8,5 +8,4 @@ func wrap<T: ExpressibleByStringLiteral>(_ key: String, _ value: T) -> T { retur
 
 func wrapped() -> Int {
   return wrap("1", 1) + wrap("1", 1) + wrap("1", 1) + wrap("1", 1)
-  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
 }

validation-test/Sema/type_checker_perf/fast/rdar74035425.swift

@@ -0,0 +1,10 @@
+// RUN: %target-typecheck-verify-swift -solver-expression-time-threshold=1
+// REQUIRES: tools-release,no_asan
+
+struct Value {
+  let debugDescription: String
+}
+
+func test(values: [[Value]]) -> String {
+  "[" + "" + values.map({ "[" + $0.map({ $0.debugDescription }).joined(separator: ", ") + "]" }).joined(separator: ", ") + "]"
+}