[Type checker] Don't merge dictionary key type variables with different expression kinds.

The constraint generator's optimization to eagerly merge type
variables for different keys in a dictionary literal was too eager,
merging the type variables for (e.g.) a string literal and an integer
literal. This prevented us from properly inferring AnyHashable key
types in dictionary literals. Fixes the rest of rdar://problem/27661580.

(cherry picked from commit 4a569f3)

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -1739,8 +1739,7 @@ namespace {
     }
 
     static bool isMergeableValueKind(Expr *expr) {
-      return isa<CollectionExpr>(expr) ||
-             isa<StringLiteralExpr>(expr) || isa<IntegerLiteralExpr>(expr) ||
+      return isa<StringLiteralExpr>(expr) || isa<IntegerLiteralExpr>(expr) ||
              isa<FloatLiteralExpr>(expr);
     }
 
@@ -1818,16 +1817,22 @@ namespace {
               auto keyTyvar2 = tty2->getElementTypes()[0]->
                                 getAs<TypeVariableType>();
 
-              mergedKey = mergeRepresentativeEquivalenceClasses(CS, 
+              auto keyExpr1 = cast<TupleExpr>(element1)->getElements()[0];
+              auto keyExpr2 = cast<TupleExpr>(element2)->getElements()[0];
+
+              if (keyExpr1->getKind() == keyExpr2->getKind() &&
+                  isMergeableValueKind(keyExpr1)) {
+                mergedKey = mergeRepresentativeEquivalenceClasses(CS,
                             keyTyvar1, keyTyvar2);
+              }
 
               auto valueTyvar1 = tty1->getElementTypes()[1]->
                                   getAs<TypeVariableType>();
               auto valueTyvar2 = tty2->getElementTypes()[1]->
                                   getAs<TypeVariableType>();
 
-              auto elemExpr1 = dyn_cast<TupleExpr>(element1)->getElements()[1];
-              auto elemExpr2 = dyn_cast<TupleExpr>(element2)->getElements()[1];
+              auto elemExpr1 = cast<TupleExpr>(element1)->getElements()[1];
+              auto elemExpr2 = cast<TupleExpr>(element2)->getElements()[1];
 
               if (elemExpr1->getKind() == elemExpr2->getKind() &&
                 isMergeableValueKind(elemExpr1)) {

test/Constraints/dictionary_literal.swift

@@ -85,4 +85,10 @@ func testDefaultExistentials() {
 
   let d3 = ["b" : B(), "c" : C()]
   let _: Int = d3 // expected-error{{value of type 'Dictionary<String, A>'}}
+
+  let _ = ["a" : B(), 17 : "seventeen", 3.14159 : "Pi"]
+  // expected-error@-1{{heterogenous collection literal could only be inferred to 'Dictionary<AnyHashable, Any>'}}
+
+  let _ = ["a" : "hello", 17 : "string"]
+  // expected-error@-1{{heterogenous collection literal could only be inferred to 'Dictionary<AnyHashable, String>'}}
 }