[ConstraintSystem] Exclude not-applicable members (e.g. properties) from common result compulation

This is the situation where a property has the same name as a method e.g.

```swift
protocol P {
  var test: String { get }
}

extension P {
  var test: String { get { return "" } }
}

struct S : P {
  func test() -> Int { 42 }
}

var s = S()
s.test() // disjunction would have two choices here, one
         // for the property from `P` and one for the method of `S`.
```
In cases like this, let's exclude property overload from common
result determination because it cannot be applied.

Note that such overloads cannot be disabled, because they still
have to be checked in diagnostic mode and there is (currently)
no way to re-enable them for diagnostics.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -10432,6 +10432,34 @@ bool ConstraintSystem::simplifyAppliedOverloadsImpl(
           return true;
         }
 
+        // This is the situation where a property has the same name
+        // as a method e.g.
+        //
+        // protocol P {
+        //   var test: String { get }
+        // }
+        //
+        // extension P {
+        //   var test: String { get { return "" } }
+        // }
+        //
+        // struct S : P {
+        //  func test() -> Int { 42 }
+        // }
+        //
+        // var s = S()
+        // s.test() <- disjunction would have two choices here, one
+        //             for the property from `P` and one for the method of `S`.
+        //
+        // In cases like this, let's exclude property overload from common
+        // result determination because it cannot be applied.
+        //
+        // Note that such overloads cannot be disabled, because they still
+        // have to be checked in diagnostic mode and there is (currently)
+        // no way to re-enable them for diagnostics.
+        if (!choiceType->lookThroughAllOptionalTypes()->is<FunctionType>())
+          return true;
+
         // If types lined up exactly, let's favor this overload choice.
         if (Type(argFnType)->isEqual(choiceType))
           constraint->setFavored();

validation-test/Sema/type_checker_perf/fast/property_and_methods_with_same_name.swift.gyb

@@ -0,0 +1,30 @@
+// RUN: %scale-test --begin 1 --end 10  --step 1 --select NumLeafScopes %s
+// REQUIRES: asserts,no_asan
+
+func test(_: [A]) {}
+
+class A {}
+
+protocol P {
+  var arr: Int { get }
+}
+
+extension P {
+  var arr: Int { get { return 42 } }
+}
+
+class S : P {
+  func arr() -> [A] { [] }
+  func arr(_: Int = 42) -> [A] { [] }
+}
+
+// There is a clash between `arr` property and `arr` methods
+// returning `[A]` which shouldn't prevent "common result"
+// determination.
+func run_test(s: S) {
+  test(s.arr() +
+       %for i in range(0, N):
+       s.arr() +
+       %end
+       s.arr())
+}