[Constraint solver] Match call arguments for subscripts.

Record the argument labels provided to a subscript in the solver, and
use that to filter out subscript declarations with non-matching
argument labels during function application. This reduces the number of
overloaded subscript declarations that will be considered in later
steps in the solver, reducing the solution space.

*Disable* this optimization in the normal member-lookup path, which is
intended to go away in the near future. This limits the scope of the
change somewhat, so we can separately tackle the diagnostics issue.
The one diagnostics change here is probably an improvement, because
the user explicitly stated the argument labels, and is more likely
missing a conversion on the argument than having typed the wrong
label.

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -3614,6 +3614,14 @@ namespace {
         return { true, expr };
       }
 
+      if (auto subscript = dyn_cast<SubscriptExpr>(expr)) {
+        associateArgumentLabels(subscript,
+                                { subscript->getArgumentLabels(),
+                                  subscript->hasTrailingClosure() },
+                                /*labelsArePermanent=*/true);
+        return { true, expr };
+      }
+
       // FIXME: other expressions have argument labels, but this is an
       // optimization, so stage it in later.
       return { true, expr };

lib/Sema/CSSimplify.cpp

@@ -122,7 +122,9 @@ bool constraints::areConservativelyCompatibleArgumentLabels(
   // the member lookup binding the first level.  But there are cases where
   // we can get an unapplied declaration reference back.
   bool hasCurriedSelf;
-  if (!baseType || baseType->is<ModuleType>()) {
+  if (isa<SubscriptDecl>(decl)) {
+    hasCurriedSelf = false;
+  } else if (!baseType || baseType->is<ModuleType>()) {
     hasCurriedSelf = false;
   } else if (baseType->is<AnyMetatypeType>() && decl->isInstanceMember()) {
     hasCurriedSelf = false;
@@ -139,11 +141,16 @@ areConservativelyCompatibleArgumentLabels(ValueDecl *decl,
                                           bool hasCurriedSelf,
                                           ArrayRef<Identifier> labels,
                                           bool hasTrailingClosure) {
-  // Bail out conservatively if this isn't a function declaration.
-  auto fn = dyn_cast<AbstractFunctionDecl>(decl);
-  if (!fn) return true;
-  
-  auto *fTy = fn->getInterfaceType()->castTo<AnyFunctionType>();
+  const AnyFunctionType *fTy;
+
+  if (auto fn = dyn_cast<AbstractFunctionDecl>(decl)) {
+    fTy = fn->getInterfaceType()->castTo<AnyFunctionType>();
+  } else if (auto subscript = dyn_cast<SubscriptDecl>(decl)) {
+    assert(!hasCurriedSelf && "Subscripts never have curried 'self'");
+    fTy = subscript->getInterfaceType()->castTo<AnyFunctionType>();
+  } else {
+    return true;
+  }
 
   SmallVector<AnyFunctionType::Param, 8> argInfos;
   for (auto argLabel : labels) {
@@ -3573,7 +3580,10 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
 
     // If the argument labels for this result are incompatible with
     // the call site, skip it.
+    // FIXME: The subscript check here forces the use of the
+    // function-application simplification logic to handle labels.
     if (argumentLabels &&
+        (!candidate.isDecl() || !isa<SubscriptDecl>(candidate.getDecl())) &&
         !areConservativelyCompatibleArgumentLabels(
             candidate, argumentLabels->Labels,
             argumentLabels->HasTrailingClosure)) {

test/Constraints/overload_filtering.swift

@@ -14,3 +14,15 @@ func testModuleScope(i: Int) {
   // CHECK: (introducing single enabled disjunction term {{.*}} (Int, Int) -> ()
   foo(i, i)
 }
+
+struct X {
+  subscript(_: Int) -> Int { return 0 }
+  subscript(_: Int, _: Int) -> Double { return 0 }
+  subscript(_: Int, _: Int, _: Int) -> String { return "" }
+}
+
+func testSubscript(x: X, i: Int) {
+  // CHECK: disabled disjunction term {{.*}}X.subscript(_:)
+  // CHECK-NEXT: disabled disjunction term {{.*}}X.subscript(_:_:_:)
+  _ = x[i, i]
+}

test/Constraints/subscript.swift

@@ -91,7 +91,7 @@ struct SR718 {
   subscript(a a : UInt) -> Int { return 0 }
 }
 
-SR718()[a: Int()] // expected-error {{extraneous argument label 'a:' in subscript}}
+SR718()[a: Int()] // expected-error {{cannot convert value of type 'Int' to expected argument type 'UInt'}}
 
 // rdar://problem/25601561 - Qol: Bad diagnostic for failed assignment from Any to more specific type