Sema: Look through implicit conversions when diagnosing collection literals with defaulted types

Resolves #60011

Author: simanerush

lib/Sema/MiscDiagnostics.cpp

@@ -423,20 +423,33 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
     /// We have a collection literal with a defaulted type, e.g. of [Any].  Emit
     /// 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) {
+    void checkTypeDefaultedCollectionExpr(CollectionExpr *c,
+                                          bool diagnoseAsWarning) {
       // 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.
-      if (c->getNumElements() == 0)
-        Ctx.Diags.diagnose(c->getLoc(), diag::collection_literal_empty)
-          .highlight(c->getSourceRange());
-      else {
+      auto &diags = Ctx.Diags;
+
+      if (c->getNumElements() == 0) {
+        InFlightDiagnostic inFlight =
+            diags.diagnose(c->getLoc(), diag::collection_literal_empty);
+        inFlight.highlight(c->getSourceRange());
+
+        if (diagnoseAsWarning) {
+          inFlight.limitBehavior(DiagnosticBehavior::Warning);
+        }
+      } else {
         assert(c->getType()->hasTypeRepr() &&
                "a defaulted type should always be printable");
-        Ctx.Diags.diagnose(c->getLoc(), diag::collection_literal_heterogeneous,
-                           c->getType())
-          .highlight(c->getSourceRange())
-          .fixItInsertAfter(c->getEndLoc(), " as " + c->getType()->getString());
+        InFlightDiagnostic inFlight = diags.diagnose(
+            c->getLoc(), diag::collection_literal_heterogeneous, c->getType());
+        inFlight.highlight(c->getSourceRange());
+        inFlight.fixItInsertAfter(c->getEndLoc(),
+                                  " as " + c->getType()->getString());
+
+        if (diagnoseAsWarning) {
+          inFlight.limitBehavior(DiagnosticBehavior::Warning);
+        }
       }
     }
 
@@ -1313,11 +1326,26 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
 
   // Diagnose uses of collection literals with defaulted types at the top
   // level.
-  if (auto collection
-        = dyn_cast<CollectionExpr>(E->getSemanticsProvidingExpr())) {
+  E = E->getSemanticsProvidingExpr();
+  bool diagnoseAsWarning = false;
+
+  // Look through implicit conversions.
+  if (auto conversion = dyn_cast<ImplicitConversionExpr>(E)) {
+    // This case was not diagnosed previously; emit a warning instead of an
+    // error for source compatibility.
+    diagnoseAsWarning = true;
+    while (auto *expr =
+               dyn_cast<ImplicitConversionExpr>(conversion->getSubExpr())) {
+      conversion = expr;
+    }
+
+    E = conversion->getSubExpr();
+  }
+
+  if (auto collection = dyn_cast<CollectionExpr>(E)) {
     if (collection->isTypeDefaulted()) {
       Walker.checkTypeDefaultedCollectionExpr(
-        const_cast<CollectionExpr *>(collection));
+          const_cast<CollectionExpr *>(collection), diagnoseAsWarning);
     }
   }
 }

test/Constraints/array_literal.swift

@@ -155,6 +155,13 @@ func defaultToAny(i: Int, s: String) {
 
   let a6 = [B(), C()]
   let _: Int = a6 // expected-error{{value of type '[A]'}}
+  
+  let a7: some Collection = [1, "Swift"]
+  // expected-warning@-1{{heterogeneous collection literal could only be inferred to '[Any]'; add explicit type annotation if this is intentional}}
+  let a8: (any Sequence)? = [1, "Swift"]
+  // expected-warning@-1{{heterogeneous collection literal could only be inferred to '[Any]'; add explicit type annotation if this is intentional}}
+  let a9: any Sequence = [1, nil, "Swift"]
+  // expected-warning@-1{{heterogeneous collection literal could only be inferred to '[Any?]'; add explicit type annotation if this is intentional}}
 }
 
 func noInferAny(iob: inout B, ioc: inout C) {