[Diagnostics] When building a subscript don't assume that overload is always present

This handles situation when overload for the subscript hasn't been resolved
by constraint solver, such might happen, for example, if solver was allowed to
produce solutions with free or unresolved type variables (e.g. when running diagnostics).

Resolves: <rdar://problem/27329076>, <rdar://problem/28619118>, <rdar://problem/2778734>.

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -204,6 +204,9 @@ ERROR(cannot_subscript_base,none,
       "cannot subscript a value of type %0",
       (Type))
 
+ERROR(cannot_subscript_ambiguous_base,none,
+      "cannot subscript a value of incorrect or ambiguous type", ())
+
 ERROR(cannot_subscript_nil_literal,none,
       "cannot subscript a nil literal value", ())
 

lib/AST/ASTVerifier.cpp

@@ -1341,7 +1341,7 @@ struct ASTNodeBase {};
     void verifyChecked(SubscriptExpr *E) {
       PrettyStackTraceExpr debugStack(Ctx, "verifying SubscriptExpr", E);
 
-      if (!E->getDecl()) {
+      if (!E->hasDecl()) {
         Out << "Subscript expression is missing subscript declaration";
         abort();
       }

lib/Sema/CSApply.cpp

@@ -1233,11 +1233,32 @@ namespace {
                          ConstraintLocatorBuilder locator,
                          bool isImplicit, AccessSemantics semantics) {
       // Determine the declaration selected for this subscript operation.
-      auto selected = getOverloadChoice(
+      auto selected = getOverloadChoiceIfAvailable(
                         cs.getConstraintLocator(
                           locator.withPathElement(
                             ConstraintLocator::SubscriptMember)));
-      auto choice = selected.choice;
+
+      // Handles situation where there was a solution available but it didn't
+      // have a proper overload selected from subscript call, might be because
+      // solver was allowed to return free or unresolved types, which can
+      // happen while running diagnostics on one of the expressions.
+      if (!selected.hasValue()) {
+        auto &tc = cs.TC;
+        auto baseType = base->getType();
+
+        if (auto errorType = baseType->getAs<ErrorType>()) {
+          tc.diagnose(base->getLoc(), diag::cannot_subscript_base,
+                      errorType->getOriginalType())
+              .highlight(base->getSourceRange());
+        } else {
+          tc.diagnose(base->getLoc(), diag::cannot_subscript_ambiguous_base)
+              .highlight(base->getSourceRange());
+        }
+
+        return nullptr;
+      }
+
+      auto choice = selected->choice;
       auto subscript = cast<SubscriptDecl>(choice.getDecl());
 
       auto &tc = cs.getTypeChecker();
@@ -1255,7 +1276,7 @@ namespace {
       // Figure out the index and result types.
       auto containerTy
         = subscript->getDeclContext()->getDeclaredTypeOfContext();
-      auto subscriptTy = simplifyType(selected.openedType);
+      auto subscriptTy = simplifyType(selected->openedType);
       auto indexTy = subscriptTy->castTo<AnyFunctionType>()->getInput();
       auto resultTy = subscriptTy->castTo<AnyFunctionType>()->getResult();
 
@@ -1282,7 +1303,7 @@ namespace {
       // Form the subscript expression.
 
       // Handle dynamic lookup.
-      if (selected.choice.getKind() == OverloadChoiceKind::DeclViaDynamic ||
+      if (choice.getKind() == OverloadChoiceKind::DeclViaDynamic ||
           subscript->getAttrs().hasAttribute<OptionalAttr>()) {
         base = coerceObjectArgumentToType(base, baseTy, subscript,
                                           AccessSemantics::Ordinary, locator);
@@ -1308,13 +1329,13 @@ namespace {
         solution.computeSubstitutions(
           subscript->getInterfaceType(),
           dc,
-          selected.openedFullType,
+          selected->openedFullType,
           getConstraintSystem().getConstraintLocator(
             locator.withPathElement(ConstraintLocator::SubscriptMember)),
           substitutions);
 
         // Convert the base.
-        auto openedFullFnType = selected.openedFullType->castTo<FunctionType>();
+        auto openedFullFnType = selected->openedFullType->castTo<FunctionType>();
         auto openedBaseType = openedFullFnType->getInput();
         containerTy = solution.simplifyType(tc, openedBaseType);
         base = coerceObjectArgumentToType(

test/Constraints/closures.swift

@@ -381,3 +381,5 @@ func g_2994(arg: Int) -> Double {
   return 2
 }
 C_2994<S_2994>(arg: { (r: S_2994) in f_2994(arg: g_2994(arg: r.dataOffset)) }) // expected-error {{cannot convert value of type 'Double' to expected argument type 'String'}}
+
+let _ = { $0[$1] }(1, 1) // expected-error {{cannot subscript a value of incorrect or ambiguous type}}

validation-test/Sema/type_checker_crashers/rdar27329076.swift

@@ -0,0 +1,3 @@
+// RUN: not %target-swift-frontend %s -typecheck
+
+_ = try [ { return .D($0[0]) } ]

validation-test/Sema/type_checker_crashers/rdar27787341.swift

@@ -0,0 +1,3 @@
+// RUN: not %target-swift-frontend %s -typecheck
+
+_ = [1].reduce([:]) { $0[$1] }

validation-test/Sema/type_checker_crashers_fixed/rdar27329076.swift

@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -typecheck
+// RUN: not %target-swift-frontend %s -typecheck
 
 _ = [1].reduce( [Int:Int]() ) {
   (dict, num) in dict[num] = num * num

validation-test/Sema/type_checker_crashers_fixed/rdar27787341.swift

@@ -0,0 +1,7 @@
+// RUN: not %target-swift-frontend %s -emit-silgen
+
+enum X {
+    init?(a: Int) {
+        .p[a]
+    }
+}

validation-test/Sema/type_checker_crashers/rdar28619118.swift renamed to validation-test/Sema/type_checker_crashers_fixed/rdar28619118.swift

@@ -5,6 +5,6 @@
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
-// RUN: not --crash %target-swift-frontend %s -emit-ir
+// RUN: not %target-swift-frontend %s -emit-ir
 // REQUIRES: asserts
 .A[]