[CSOptimizer] Add support for chained members without arguments

If disjunction represents a member reference that has no arguments
applied, let's score that as `1` to indicate that it should be priorized.

This helps in situations like `a.b + 1` where resolving `a.b` member
chain helps to establish context for `+`.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -253,6 +253,37 @@ static void findFavoredChoicesBasedOnArity(
     favoredChoice(choice);
 }
 
+/// Determine whether the given disjunction serves as a base of
+/// another member reference i.e. `x.y` where `x` could be overloaded.
+static bool isPartOfMemberChain(ConstraintSystem &CS, Constraint *disjunction) {
+  if (isOperatorDisjunction(disjunction))
+    return false;
+
+  auto &CG = CS.getConstraintGraph();
+
+  TypeVariableType *typeVar = nullptr;
+
+  // If disjunction is applied, the member is chained on the result.
+  if (auto appliedFn = CS.getAppliedDisjunctionArgumentFunction(disjunction)) {
+    typeVar = appliedFn->getResult()->getAs<TypeVariableType>();
+  } else {
+    typeVar = disjunction->getNestedConstraints()[0]
+                  ->getFirstType()
+                  ->getAs<TypeVariableType>();
+  }
+
+  if (!typeVar)
+    return false;
+
+  return llvm::any_of(
+      CG[typeVar].getConstraints(), [&typeVar](Constraint *constraint) {
+        if (constraint->getKind() != ConstraintKind::ValueMember)
+          return false;
+
+        return constraint->getFirstType()->isEqual(typeVar);
+      });
+}
+
 } // end anonymous namespace
 
 /// Given a set of disjunctions, attempt to determine
@@ -286,8 +317,15 @@ static void determineBestChoicesInContext(
     auto applicableFn =
         getApplicableFnConstraint(cs.getConstraintGraph(), disjunction);
 
-    if (applicableFn.isNull())
+    if (applicableFn.isNull()) {
+      // If this is a chained member reference it could be prioritized since
+      // it helps to establish context for other calls i.e. `a.b + 2` if
+      // `a` is a disjunction it should be preferred over `+`.
+      if (isPartOfMemberChain(cs, disjunction))
+        recordResult(disjunction, {/*score=*/1.0});
+
       continue;
+    }
 
     auto argFuncType =
         applicableFn.get()->getFirstType()->getAs<FunctionType>();

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

@@ -0,0 +1,35 @@
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck -solver-expression-time-threshold=1
+
+// REQUIRES: OS=macosx,no_asan
+// REQUIRES: objc_interop
+
+import Foundation
+
+struct CGRect {
+  var x: CGFloat
+
+  init(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) { }
+  init(x: Double, y: Double, width: Double, height: Double) { }
+}
+
+protocol View {}
+
+extension Optional: View where Wrapped: View {}
+
+extension View {
+  func frame() -> some View { self }
+  func frame(x: Int, y: Int, w: Int, z: Int) -> some View { self }
+  func frame(y: Bool) -> some View { self }
+}
+
+struct NSView {
+  var frame: CGRect
+}
+
+func test(margin: CGFloat, view: NSView!) -> CGRect {
+  // `view` is first attempted as `NSView?` and only if that fails is force unwrapped
+  return CGRect(x: view.frame.x + margin,
+                y: view.frame.x + margin,
+                width: view.frame.x - view.frame.x - view.frame.x - (margin * 2),
+                height: margin)
+}