[Diagnostics] Extend keypath subscript index missing Hashable to support dynamic member lookup

Author: xedin

lib/Sema/CSApply.cpp

@@ -4661,9 +4661,9 @@ namespace {
       auto fnType = overload.openedType->castTo<FunctionType>();
       for (const auto &param : fnType->getParams()) {
         auto indexType = simplifyType(param.getPlainType());
-        // index conformance to the Hashable protocol has been verified
-        // by the solver, we just need to get it again with all of the
-        // generic parameters resolved.
+        // Index type conformance to Hashable protocol has been
+        // verified by the solver, we just need to get it again
+        // with all of the generic parameters resolved.
         auto hashableConformance =
             TC.conformsToProtocol(indexType, hashable, cs.DC,
                                   (ConformanceCheckFlags::Used |
@@ -4674,7 +4674,7 @@ namespace {
         // Equatable conformance is forced into existence during type
         // checking so that it's available for SILGen.
         auto eqConformance =
-            TC.conformsToProtocol(simplifyType(indexType), equatable, cs.DC,
+            TC.conformsToProtocol(indexType, equatable, cs.DC,
                                   (ConformanceCheckFlags::Used |
                                    ConformanceCheckFlags::InExpression));
         assert(eqConformance.hasValue());

lib/Sema/CSDiagnostics.cpp

@@ -2400,13 +2400,21 @@ bool InaccessibleMemberFailure::diagnoseAsError() {
 }
 
 bool KeyPathSubscriptIndexHashableFailure::diagnoseAsError() {
-  auto *anchor = cast<KeyPathExpr>(getRawAnchor());
-  auto path = getLocator()->getPath();
-  const auto &componentIndex = path.back().getValue();
+  auto *anchor = getRawAnchor();
+  auto *locator = getLocator();
+
+  auto loc = anchor->getLoc();
+  if (locator->isKeyPathSubscriptComponent()) {
+    auto *KPE = cast<KeyPathExpr>(anchor);
+    for (auto &elt : locator->getPath()) {
+      if (elt.isKeyPathComponent()) {
+        loc = KPE->getComponents()[elt.getValue()].getLoc();
+        break;
+      }
+    }
+  }
 
-  auto *indexExpr = anchor->getComponents()[componentIndex].getIndexExpr();
-  emitDiagnostic(indexExpr->getLoc(),
-                 diag::expr_keypath_subscript_index_not_hashable,
+  emitDiagnostic(loc, diag::expr_keypath_subscript_index_not_hashable,
                  resolveType(NonConformingType));
   return true;
 }

lib/Sema/CSDiagnostics.h

@@ -1008,10 +1008,8 @@ class KeyPathSubscriptIndexHashableFailure final : public FailureDiagnostic {
   KeyPathSubscriptIndexHashableFailure(Expr *root, ConstraintSystem &cs,
                                        Type type, ConstraintLocator *locator)
       : FailureDiagnostic(root, cs, locator), NonConformingType(type) {
-#ifndef NDEBUG
-    auto path = locator->getPath();
-    assert(!path.empty() && path.back().isKeyPathComponent());
-#endif
+    assert(locator->isResultOfKeyPathDynamicMemberLookup() ||
+           locator->isKeyPathSubscriptComponent());
   }
 
   bool diagnoseAsError() override;

test/attr/attr_dynamic_member_lookup.swift

@@ -619,9 +619,8 @@ struct WithTrailingClosure {
 
 func keypath_with_trailing_closure_subscript(_ ty: inout SubscriptLens<WithTrailingClosure>) {
   _ = ty[0] { 42 } // expected-error {{subscript index of type '() -> Int' in a key path must be Hashable}}
-  _ = ty[0] { 42 } = 0 // FIXME(diagnostics): Once keypath related diagnostics are using fixes, "ambiguous" error would disappear
+  _ = ty[0] { 42 } = 0
   // expected-error@-1 {{subscript index of type '() -> Int' in a key path must be Hashable}}
-  // expected-error@-2 {{type of expression is ambiguous without more context}}
   _ = ty[] { 42 }  // expected-error {{subscript index of type '() -> Int' in a key path must be Hashable}}
   _ = ty[] { 42 } = 0 // expected-error {{subscript index of type '() -> Int' in a key path must be Hashable}}
 }