[CSBindings] Account for literal bindings when checking "subtype of existential" property

It's important to know whether a binding set has all of its bindings
as subtypes of some existential type(s), type variables like that
should be delayed.

Incremental binding inference introduced a bug into computation of
this property by checking only directly inferable bindings, but
it's also important to check that there are no literal requirements
that can produce bindings, because that would mean that type variable
can never be just a subtype of existential type(s).

Resolves: rdar://77570994

Author: xedin

include/swift/Sema/CSBindings.h

@@ -391,6 +391,13 @@ class BindingSet {
     if (Bindings.empty())
       return false;
 
+    // Literal requirements always result in a subtype/supertype
+    // relationship to a concrete type.
+    if (llvm::any_of(Literals, [](const auto &literal) {
+          return literal.second.viableAsBinding();
+        }))
+      return false;
+
     return llvm::all_of(Bindings, [](const PotentialBinding &binding) {
       return binding.BindingType->isExistentialType() &&
              binding.Kind == AllowedBindingKind::Subtypes;

test/Constraints/protocols.swift

@@ -492,3 +492,30 @@ func test_arg_conformance_with_conditional_reqs(i: Int) {
   let _: Int?? = simple(overloaded_result())
   let _: Int?? = overloaded(overloaded_result())
 }
+
+// rdar://77570994 - regression in type unification for literal collections
+
+protocol Elt {
+}
+
+extension Int : Elt {}
+extension Int64 : Elt {}
+extension Dictionary : Elt where Key == String, Value: Elt {}
+
+struct Object {}
+
+extension Object : ExpressibleByDictionaryLiteral {
+  init(dictionaryLiteral elements: (String, Elt)...) {
+  }
+}
+
+enum E {
+case test(cond: Bool, v: Int64)
+
+  var test_prop: Object {
+    switch self {
+    case let .test(cond, v):
+      return ["obj": ["a": v, "b": cond ? 0 : 42]] // Ok
+    }
+  }
+}