[CSOptimizer] Favor choices that don't require application

When disjunction is not applied, don't only bump its score
but also favor all of the choices that don't require application
because selection algorithm uses that for comparison.

This is important for situation when property is overload with
a method i.e. `Array.count`.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "TypeChecker.h"
+#include "swift/AST/ConformanceLookup.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/Basic/OptionSet.h"
@@ -61,6 +62,12 @@ static bool isFloatType(Type type) {
   return type->isFloat() || type->isDouble() || type->isFloat80();
 }
 
+static bool isUnboundArrayType(Type type) {
+  if (auto *UGT = type->getAs<UnboundGenericType>())
+    return UGT->getDecl() == type->getASTContext().getArrayDecl();
+  return false;
+}
+
 static bool isSupportedOperator(Constraint *disjunction) {
   if (!isOperatorDisjunction(disjunction))
     return false;
@@ -298,9 +305,19 @@ static void determineBestChoicesInContext(
           case ExprKind::Binary:
           case ExprKind::PrefixUnary:
           case ExprKind::PostfixUnary:
-          case ExprKind::UnresolvedDot:
-            recordResult(disjunction, {/*score=*/1.0});
+          case ExprKind::UnresolvedDot: {
+            llvm::SmallVector<Constraint *, 2> favoredChoices;
+            // Favor choices that don't require application.
+            llvm::copy_if(
+                disjunction->getNestedConstraints(),
+                std::back_inserter(favoredChoices), [](Constraint *choice) {
+                  auto *decl = getOverloadChoiceDecl(choice);
+                  return decl &&
+                         !decl->getInterfaceType()->is<AnyFunctionType>();
+                });
+            recordResult(disjunction, {/*score=*/1.0, favoredChoices});
             continue;
+          }
 
           default:
             break;
@@ -538,8 +555,33 @@ static void determineBestChoicesInContext(
         }
       }
 
-      if (options.contains(MatchFlag::ExactOnly))
+      // Match `[...]` to Array<...> and/or `ExpressibleByArrayLiteral`
+      // conforming types.
+      if (options.contains(MatchFlag::OnParam) &&
+          options.contains(MatchFlag::Literal) &&
+          isUnboundArrayType(candidateType)) {
+        // If an exact match is requested favor only `[...]` to `Array<...>`
+        // since everything else is going to increase to score.
+        if (options.contains(MatchFlag::ExactOnly))
+          return paramType->isArrayType() ? 1 : 0;
+
+        Type type = paramType->lookThroughAllOptionalTypes();
+        // Otherwise, check if the other side conforms to
+        // `ExpressibleByArrayLiteral` protocol (in some way).
+        if (auto *nominal = type->getAnyNominal()) {
+          auto &ctx = cs.getASTContext();
+          SmallVector<ProtocolConformance *> conformances;
+
+          nominal->lookupConformance(
+              ctx.getProtocol(KnownProtocolKind::ExpressibleByArrayLiteral),
+              conformances);
+          return conformances.empty() ? 0 : 0.3;
+        }
+      }
+
+      if (options.contains(MatchFlag::ExactOnly)) {
         return areEqual(candidateType, paramType) ? 1 : 0;
+      }
 
       // Exact match between candidate and parameter types.
       if (areEqual(candidateType, paramType)) {

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

@@ -0,0 +1,7 @@
+// RUN: %target-typecheck-verify-swift -solver-scope-threshold=11000
+// REQUIRES: tools-release,no_asan
+
+func f(n: Int, a: [Int]) {
+  let _ = [(0 ..< n + a.count).map { Int8($0) }] +
+          [(0 ..< n + a.count).map { Int8($0) }.reversed()] // Ok
+}