[Diagnostics] Port diagnostics related to dictionary literal use

Author: xedin

lib/Sema/CSDiag.cpp

@@ -239,7 +239,6 @@ class FailureDiagnosis :public ASTVisitor<FailureDiagnosis, /*exprresult*/bool>{
   bool visitTryExpr(TryExpr *E);
 
   bool visitUnresolvedDotExpr(UnresolvedDotExpr *UDE);
-  bool visitDictionaryExpr(DictionaryExpr *E);
   bool visitObjectLiteralExpr(ObjectLiteralExpr *E);
 
   bool visitApplyExpr(ApplyExpr *AE);
@@ -1723,71 +1722,6 @@ visitRebindSelfInConstructorExpr(RebindSelfInConstructorExpr *E) {
   return false;
 }
 
-bool FailureDiagnosis::visitDictionaryExpr(DictionaryExpr *E) {
-  Type contextualKeyType, contextualValueType;
-  auto keyTypePurpose = CTP_Unused, valueTypePurpose = CTP_Unused;
-
-  // If we had a contextual type, then it either conforms to
-  // ExpressibleByDictionaryLiteral or it is an invalid contextual type.
-  if (auto contextualType = CS.getContextualType()) {
-    // If our contextual type is an optional, look through them, because we're
-    // surely initializing whatever is inside.
-    contextualType = contextualType->lookThroughAllOptionalTypes();
-
-    auto DLC = TypeChecker::getProtocol(
-        CS.getASTContext(), E->getLoc(),
-        KnownProtocolKind::ExpressibleByDictionaryLiteral);
-    if (!DLC) return visitExpr(E);
-
-    // Validate the contextual type conforms to ExpressibleByDictionaryLiteral
-    // and figure out what the contextual Key/Value types are in place.
-    auto Conformance = TypeChecker::conformsToProtocol(
-        contextualType, DLC, CS.DC, ConformanceCheckFlags::InExpression);
-    if (Conformance.isInvalid()) {
-      diagnose(E->getStartLoc(), diag::type_is_not_dictionary, contextualType)
-        .highlight(E->getSourceRange());
-      return true;
-    }
-
-    contextualKeyType =
-        Conformance
-            .getTypeWitnessByName(contextualType, CS.getASTContext().Id_Key)
-            ->getDesugaredType();
-
-    contextualValueType =
-        Conformance
-            .getTypeWitnessByName(contextualType, CS.getASTContext().Id_Value)
-            ->getDesugaredType();
-
-    assert(contextualKeyType && contextualValueType &&
-           "Could not find Key/Value DictionaryLiteral associated types from"
-           " contextual type conformance");
-    
-    keyTypePurpose = CTP_DictionaryKey;
-    valueTypePurpose = CTP_DictionaryValue;
-  }
-  
-  // Type check each of the subexpressions in place, passing down the contextual
-  // type information if we have it.
-  for (auto elt : E->getElements()) {
-    auto TE = dyn_cast<TupleExpr>(elt);
-    if (!TE || TE->getNumElements() != 2) continue;
-
-    if (!typeCheckChildIndependently(TE->getElement(0),
-                                     contextualKeyType, keyTypePurpose))
-      return true;
-    if (!typeCheckChildIndependently(TE->getElement(1),
-                                     contextualValueType, valueTypePurpose))
-      return true;
-  }
-
-  // If that didn't turn up an issue, then we don't know what to do.
-  // TODO: When a contextual type is missing, we could try to diagnose cases
-  // where the element types mismatch.  There is no Any equivalent since they
-  // keys need to be hashable.
-  return false;
-}
-
 /// When an object literal fails to typecheck because its protocol's
 /// corresponding default type has not been set in the global namespace (e.g.
 /// _ColorLiteralType), suggest that the user import the appropriate module for

lib/Sema/CSDiagnostics.cpp

@@ -673,6 +673,12 @@ bool GenericArgumentsMismatchFailure::diagnoseAsError() {
     case ConstraintLocator::TupleElement: {
       if (auto *array = dyn_cast<ArrayExpr>(getRawAnchor()))
         diagnostic = getDiagnosticFor(CTP_ArrayElement);
+
+      if (auto *dict = dyn_cast<DictionaryExpr>(getRawAnchor())) {
+        auto eltLoc = last.castTo<LocatorPathElt::TupleElement>();
+        diagnostic = getDiagnosticFor(
+            eltLoc.getIndex() == 0 ? CTP_DictionaryKey : CTP_DictionaryValue);
+      }
       break;
     }
 

test/Constraints/generics.swift

@@ -835,3 +835,14 @@ func sr_11491(_ value: [String]) {
   arr.insert(value)
   // expected-error@-1 {{cannot convert value of type '[String]' to expected argument type 'String'}}
 }
+
+func test_dictionary_with_generic_mismatch_in_key_or_value() {
+  struct S<T> : Hashable {}
+  // expected-note@-1 2 {{arguments to generic parameter 'T' ('Int' and 'Bool') are expected to be equal}}
+
+  let _: [Int: S<Bool>] = [0: S<Bool>(), 1: S<Int>()]
+  // expected-error@-1 {{cannot convert value of type 'S<Int>' to expected dictionary value type 'S<Bool>'}}
+
+  let _: [S<Bool>: Int] = [S<Int>(): 42]
+  // expected-error@-1 {{cannot convert value of type 'S<Int>' to expected dictionary key type 'S<Bool>'}}
+}