[Type system] Infer 'Any' for array elements and dictionary values and 'AnyHashable' for dictionary keys.

The id-as-Any work regressed cases where Swift code could specify
heterogeneous collection literals, e.g.,

    var states: [String: Any] = [
      "California": [
        "population": 37_000_000,
        "cities": ["Los Angeles", "San Diego", "San Jose"],
      ],
      "Oregon": [
        "population": 4_000_000,
        "cities": ["Portland", "Salem", "Eugene"],
      ]
    ]

Prior to this, the code worked (when Foundation was imported) because
we'd end up with literals of type [NSObject : AnyObject].

The new defaulting rule says that the element type of an array literal
and the key/value types of a dictionary literal can be defaulted if no
stronger type can be inferred. The default type is:

  Any, for the element type of an array literal or the value type of a
  dictionary literal, or

  AnyHashable, for the key type of a dictionary literal.

The latter is intended to compose with implicit conversions to
AnyHashable, so the most-general inferred dictionary type is
[AnyHashable : Any] and will work for any plausible dictionary
literal.

To prevent this inference from diluting types too greatly, we don't
allow this inference in "top-level" expressions, e.g.,

  let d = ["a" : 1, "b" : "two"]

will produce an error because it's a heterogeneous dictionary literal
at the top level. One should annotate this with, e.g.,

  let d = ["a" : 1, "b" : "two"] as [String : Any]

However, we do permit heterogeneous collections in nested positions,
to support cases like the original motivating example.

Fixes rdar://problem/27661580.

(cherry picked from commit 22287dd)

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -2711,6 +2711,14 @@ namespace {
 
       expr->setSemanticExpr(result);
       expr->setType(arrayTy);
+
+      // If the array element type was defaulted, note that in the expression.
+      auto elementTypeVariable = cs.ArrayElementTypeVariables.find(expr);
+      if (elementTypeVariable != cs.ArrayElementTypeVariables.end()) {
+        if (solution.DefaultedTypeVariables.count(elementTypeVariable->second))
+          expr->setIsTypeDefaulted();
+      }
+
       return expr;
     }
 
@@ -2780,6 +2788,18 @@ namespace {
 
       expr->setSemanticExpr(result);
       expr->setType(dictionaryTy);
+
+      // If the dictionary key or value type was defaulted, note that in the
+      // expression.
+      auto elementTypeVariable = cs.DictionaryElementTypeVariables.find(expr);
+      if (elementTypeVariable != cs.DictionaryElementTypeVariables.end()) {
+        if (solution.DefaultedTypeVariables.count(
+              elementTypeVariable->second.first) ||
+            solution.DefaultedTypeVariables.count(
+              elementTypeVariable->second.second))
+          expr->setIsTypeDefaulted();
+      }
+
       return expr;
     }
 

lib/Sema/CSGen.cpp

@@ -1728,6 +1728,13 @@ namespace {
                            LocatorPathElt::getTupleElement(index++)));
       }
 
+      // The array element type defaults to 'Any'.
+      if (auto elementTypeVar = arrayElementTy->getAs<TypeVariableType>()) {
+        CS.addConstraint(ConstraintKind::Defaultable, arrayElementTy,
+                         tc.Context.TheAnyType, locator);
+        CS.ArrayElementTypeVariables[expr] = elementTypeVar;
+      }
+
       return arrayTy;
     }
 
@@ -1849,6 +1856,26 @@ namespace {
                              LocatorPathElt::getTupleElement(index++)));
       }
 
+      // The dictionary key type defaults to 'AnyHashable'.
+      auto keyTypeVar = dictionaryKeyTy->getAs<TypeVariableType>();
+      if (keyTypeVar && tc.Context.getAnyHashableDecl()) {
+        auto anyHashable = tc.Context.getAnyHashableDecl();
+        tc.validateDecl(anyHashable);
+        CS.addConstraint(ConstraintKind::Defaultable, dictionaryKeyTy,
+                         anyHashable->getDeclaredInterfaceType(), locator);
+      }
+
+      // The dictionary value type defaults to 'Any'.
+      auto valueTypeVar = dictionaryValueTy->getAs<TypeVariableType>();
+      if (valueTypeVar) {
+        CS.addConstraint(ConstraintKind::Defaultable, dictionaryValueTy,
+                         tc.Context.TheAnyType, locator);
+      }
+
+      // Record key/value type variables.
+      if (keyTypeVar || valueTypeVar)
+        CS.DictionaryElementTypeVariables[expr] = { keyTypeVar, valueTypeVar };
+
       return dictionaryTy;
     }
 

lib/Sema/CSSolver.cpp

@@ -191,6 +191,10 @@ Solution ConstraintSystem::finalize(
     solution.OpenedExistentialTypes.insert(openedExistential);
   }
 
+  // Remember the defaulted type variables.
+  solution.DefaultedTypeVariables.insert(DefaultedTypeVariables.begin(),
+                                         DefaultedTypeVariables.end());
+
   return solution;
 }
 
@@ -247,6 +251,10 @@ void ConstraintSystem::applySolution(const Solution &solution) {
     OpenedExistentialTypes.push_back(openedExistential);
   }
 
+  // Register the defaulted type variables.
+  DefaultedTypeVariables.append(solution.DefaultedTypeVariables.begin(),
+                                solution.DefaultedTypeVariables.end());
+
   // Register any fixes produced along this path.
   Fixes.append(solution.Fixes.begin(), solution.Fixes.end());
 }
@@ -445,6 +453,7 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
   numDisjunctionChoices = cs.DisjunctionChoices.size();
   numOpenedTypes = cs.OpenedTypes.size();
   numOpenedExistentialTypes = cs.OpenedExistentialTypes.size();
+  numDefaultedTypeVariables = cs.DefaultedTypeVariables.size();
   numGeneratedConstraints = cs.solverState->generatedConstraints.size();
   PreviousScore = cs.CurrentScore;
 
@@ -501,6 +510,9 @@ ConstraintSystem::SolverScope::~SolverScope() {
   // Remove any opened existential types.
   truncate(cs.OpenedExistentialTypes, numOpenedExistentialTypes);
 
+  // Remove any defaulted type variables.
+  truncate(cs.DefaultedTypeVariables, numDefaultedTypeVariables);
+  
   // Reset the previous score.
   cs.CurrentScore = PreviousScore;
 
@@ -1182,6 +1194,12 @@ static bool tryTypeVariableBindings(
                        typeVar,
                        type,
                        typeVar->getImpl().getLocator());
+
+      // If this was from a defaultable binding note that.
+      if (binding.IsDefaultableBinding) {
+        cs.DefaultedTypeVariables.push_back(typeVar);
+      }
+
       if (!cs.solveRec(solutions, allowFreeTypeVariables))
         anySolved = true;
 

lib/Sema/ConstraintSystem.h

@@ -599,6 +599,9 @@ class Solution {
   llvm::SmallDenseMap<ConstraintLocator *, ArchetypeType *>
     OpenedExistentialTypes;
 
+  /// The type variables that were bound via a Defaultable constraint.
+  llvm::SmallPtrSet<TypeVariableType *, 8> DefaultedTypeVariables;
+
   /// \brief Simplify the given type by substituting all occurrences of
   /// type variables for their fixed types.
   Type simplifyType(TypeChecker &tc, Type type) const;
@@ -997,6 +1000,23 @@ class ConstraintSystem {
   SmallVector<std::pair<ConstraintLocator *, ArchetypeType *>, 4>
     OpenedExistentialTypes;
 
+public:
+  /// The type variables that were bound via a Defaultable constraint.
+  SmallVector<TypeVariableType *, 8> DefaultedTypeVariables;
+
+  /// The type variable used to describe the element type of the given array
+  /// literal.
+  llvm::SmallDenseMap<ArrayExpr *, TypeVariableType *>
+    ArrayElementTypeVariables;
+
+
+  /// The type variables used to describe the key and value types of the given
+  /// dictionary literal.
+  llvm::SmallDenseMap<DictionaryExpr *,
+                      std::pair<TypeVariableType *, TypeVariableType *>>
+    DictionaryElementTypeVariables;
+
+private:
   /// \brief Describes the current solver state.
   struct SolverState {
     SolverState(ConstraintSystem &cs);
@@ -1122,6 +1142,9 @@ class ConstraintSystem {
     /// The length of \c OpenedExistentialTypes.
     unsigned numOpenedExistentialTypes;
 
+    /// The length of \c DefaultedTypeVariables.
+    unsigned numDefaultedTypeVariables;
+
     /// The previous score.
     Score PreviousScore;
 

lib/Sema/MiscDiagnostics.cpp

@@ -240,10 +240,6 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
       while (auto Conv = dyn_cast<ImplicitConversionExpr>(Base))
         Base = Conv->getSubExpr();
 
-      if (auto collection = dyn_cast<CollectionExpr>(E))
-        if (collection->isTypeDefaulted())
-          checkTypeDefaultedCollectionExpr(collection);
-
       // Record call arguments.
       if (auto Call = dyn_cast<CallExpr>(Base))
         CallArgs.insert(Call->getArg());
@@ -390,10 +386,6 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
     /// an error if it was inferred to this type in an invalid context, which is
     /// one in which the parent expression is not itself a collection literal.
     void checkTypeDefaultedCollectionExpr(CollectionExpr *c) {
-      if (auto *ParentExpr = Parent.getAsExpr())
-        if (isa<CollectionExpr>(ParentExpr))
-          return;
-
       // If the parent is a non-expression, or is not itself a literal, then
       // produce an error with a fixit to add the type as an explicit
       // annotation.
@@ -703,6 +695,16 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
 
   DiagnoseWalker Walker(TC, DC, isExprStmt);
   const_cast<Expr *>(E)->walk(Walker);
+
+  // Diagnose uses of collection literals with defaulted types at the top
+  // level.
+  if (auto collection
+        = dyn_cast<CollectionExpr>(E->getSemanticsProvidingExpr())) {
+    if (collection->isTypeDefaulted()) {
+      Walker.checkTypeDefaultedCollectionExpr(
+        const_cast<CollectionExpr *>(collection));
+    }
+  }
 }
 
 

lib/Sema/TypeCheckConstraints.cpp

@@ -2634,6 +2634,15 @@ void Solution::dump(raw_ostream &out) const {
     }
   }
 
+  if (!DefaultedTypeVariables.empty()) {
+    out << "\nDefaulted type variables: ";
+    interleave(DefaultedTypeVariables, [&](TypeVariableType *typeVar) {
+      out << "$T" << typeVar->getID();
+    }, [&] {
+      out << ", ";
+    });
+  }
+
   if (!Fixes.empty()) {
     out << "\nFixes:\n";
     for (auto &fix : Fixes) {
@@ -2783,6 +2792,15 @@ void ConstraintSystem::print(raw_ostream &out) {
     }
   }
 
+  if (!DefaultedTypeVariables.empty()) {
+    out << "\nDefaulted type variables: ";
+    interleave(DefaultedTypeVariables, [&](TypeVariableType *typeVar) {
+      out << "$T" << typeVar->getID();
+    }, [&] {
+      out << ", ";
+    });
+  }
+
   if (failedConstraint) {
     out << "\nFailed constraint:\n";
     out.indent(2);

test/Constraints/array_literal.swift

@@ -115,3 +115,31 @@ func rdar25563498_ok<T : ExpressibleByArrayLiteral>(t: T) -> T
   let x: T = [1]
   return x
 }
+
+class A { }
+class B : A { }
+class C : A { }
+
+/// Check for defaulting the element type to 'Any'.
+func defaultToAny(i: Int, s: String) {
+  let a1 = [1, "a", 3.5]
+  // expected-error@-1{{heterogenous collection literal could only be inferred to '[Any]'; add explicit type annotation if this is intentional}}
+  let _: Int = a1  // expected-error{{value of type '[Any]'}}
+
+  let a2: Array = [1, "a", 3.5]
+  // expected-error@-1{{heterogenous collection literal could only be inferred to '[Any]'; add explicit type annotation if this is intentional}}
+
+  let _: Int = a2  // expected-error{{value of type '[Any]'}}
+
+  let a3 = []
+  // expected-error@-1{{empty collection literal requires an explicit type}}
+
+  let _: Int = a3 // expected-error{{value of type '[Any]'}}
+
+  let _: [Any] = [1, "a", 3.5]
+  let _: [Any] = [1, "a", [3.5, 3.7, 3.9]]
+  let _: [Any] = [1, "a", [3.5, "b", 3]]
+
+  let a4 = [B(), C()]
+  let _: Int = a4 // expected-error{{value of type '[A]'}}
+}

test/Constraints/bridging.swift

@@ -264,7 +264,7 @@ func rdar19831698() {
 // expected-note@-1{{overloads for '+'}}
   var v72 = true + true // expected-error{{binary operator '+' cannot be applied to two 'Bool' operands}}
   // expected-note @-1 {{overloads for '+' exist with these partially matching parameter lists:}}
-  var v73 = true + [] // expected-error{{binary operator '+' cannot be applied to operands of type 'Bool' and '[_]'}}
+  var v73 = true + [] // expected-error{{binary operator '+' cannot be applied to operands of type 'Bool' and '[Any]'}}
   // expected-note @-1 {{overloads for '+' exist with these partially matching parameter lists:}}
   var v75 = true + "str" // expected-error {{binary operator '+' cannot be applied to operands of type 'Bool' and 'String'}} expected-note {{expected an argument list of type '(String, String)'}}
 }

test/Constraints/dictionary_literal.swift

@@ -62,3 +62,27 @@ var _: Dictionary<String, Int>? = ["foo" : 1.0]  // expected-error {{cannot conv
 // <rdar://problem/24058895> QoI: Should handle [] in dictionary contexts better
 var _: [Int: Int] = []  // expected-error {{use [:] to get an empty dictionary literal}} {{22-22=:}}
 
+
+class A { }
+class B : A { }
+class C : A { }
+
+func testDefaultExistentials() {
+  let _ = ["a" : 1, "b" : 2.5, "c" : "hello"]
+  // expected-error@-1{{heterogenous collection literal could only be inferred to 'Dictionary<String, Any>'; add explicit type annotation if this is intentional}}{{46-46= as Dictionary<String, Any>}}
+
+  let _: [String : Any] = ["a" : 1, "b" : 2.5, "c" : "hello"]
+
+  let d2 = [:]
+  // expected-error@-1{{empty collection literal requires an explicit type}}
+
+  let _: Int = d2 // expected-error{{value of type 'Dictionary<AnyHashable, Any>'}}
+
+  let _ = ["a" : 1, 
+            "b" : [ "a", 2, 3.14159 ],
+            "c" : [ "a" : 2, "b" : 3.5] ]
+  // expected-error@-3{{heterogenous collection literal could only be inferred to 'Dictionary<String, Any>'; add explicit type annotation if this is intentional}}
+
+  let d3 = ["b" : B(), "c" : C()]
+  let _: Int = d3 // expected-error{{value of type 'Dictionary<String, A>'}}
+}

test/Constraints/subscript.swift

@@ -70,9 +70,7 @@ extension Int {
 
 let _ = 1["1"]  // expected-error {{ambiguous use of 'subscript'}}
 
-
-// rdar://17687826 - QoI: error message when reducing to an untyped dictionary isn't helpful
-let squares = [ 1, 2, 3 ].reduce([:]) { (dict, n) in // expected-error {{unable to infer complex closure return type; add explicit type to disambiguate}} {{51-51=-> [_ : _] }}
+let squares = [ 1, 2, 3 ].reduce([:]) { (dict, n) in
   var dict = dict
   dict[n] = n * n
   return dict

test/IDE/complete_at_top_level.swift

@@ -349,7 +349,7 @@ func resyncParserB6() {}
 for i in [] {
   #^TOP_LEVEL_STMT_6^#
 // TOP_LEVEL_STMT_6: Begin completions
-// TOP_LEVEL_STMT_6: Decl[LocalVar]/Local: i[#<<error type>>#]{{; name=.+$}}
+// TOP_LEVEL_STMT_6: Decl[LocalVar]/Local: i[#Any#]{{; name=.+$}}
 // TOP_LEVEL_STMT_6: End completions
 }
 

test/expr/expressions.swift

@@ -675,15 +675,15 @@ func unusedExpressionResults() {
 //===----------------------------------------------------------------------===//
 
 func arrayLiterals() { 
-  var a = [1,2,3]
-  var b : [Int] = []
-  var c = []  // expected-error {{cannot infer type for empty collection literal without a contextual type}}
+  let _ = [1,2,3]
+  let _ : [Int] = []
+  let _ = []  // expected-error {{empty collection literal requires an explicit type}}
 }
 
 func dictionaryLiterals() {
-  var a = [1 : "foo",2 : "bar",3 : "baz"]
-  var b : Dictionary<Int, String> = [:]
-  var c = [:]  // expected-error {{cannot infer type for empty collection literal without a contextual type}}
+  let _ = [1 : "foo",2 : "bar",3 : "baz"]
+  let _: Dictionary<Int, String> = [:]
+  let _ = [:]  // expected-error {{empty collection literal requires an explicit type}}
 }
 
 func invalidDictionaryLiteral() {