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

Resolves #60011

Tests: add verification for emitted fixit, a flag for no availability checking; add expected warnings

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

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -disable-availability-checking
 
 struct IntList : ExpressibleByArrayLiteral {
   typealias Element = Int
@@ -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}} {{41-41= as [Any]}}
+  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) {

test/IDE/print_usrs_opaque_types.swift

@@ -9,29 +9,34 @@
 func testUnifyingGenericParams<T, U>(x: T) -> some Collection where T == U {
   // expected-warning@-1 {{same-type requirement makes generic parameters 'U' and 'T' equivalent}}
   return []
+  // expected-warning@-1 {{empty collection literal requires an explicit type}}
 }
 
 // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test0C22UnifyingGenericParams21xQrx_tSlRz7ElementQzRs_r0_lF
 func testUnifyingGenericParams2<T, U>(x: T) -> some Collection where T: Collection, U == T.Element {
   return []
+  // expected-warning@-1 {{empty collection literal requires an explicit type}}
 }
 
 // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test0C24ConcretizingGenericParam1xQrSi_tSiRszlF
 func testConcretizingGenericParam<T>(x: T) -> some Collection where T == Int {
   // expected-warning@-1 {{same-type requirement makes generic parameter 'T' non-generic}}
   return []
+  // expected-warning@-1 {{empty collection literal requires an explicit type}}
 }
 
 struct GenericContext<T> {
   // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test14GenericContextV0c8UnifyingD6Params1xQrx_tqd__RszlF
   func testUnifyingGenericParams<U>(x: T) -> some Collection where T == U {
     // expected-warning@-1 {{same-type requirement makes generic parameters 'U' and 'T' equivalent}}
     return []
+    // expected-warning@-1 {{empty collection literal requires an explicit type}}
   }
 
   // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test14GenericContextV0c8UnifyingD7Params21xQrx_tSlRz7ElementQzRsd__lF
   func testUnifyingGenericParams2<U>(x: T) -> some Collection where T: Collection, U == T.Element {
     return []
+    // expected-warning@-1 {{empty collection literal requires an explicit type}}
   }
 
   // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test14GenericContextVyQrxcqd__Rszluip
@@ -40,6 +45,7 @@ struct GenericContext<T> {
     // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test14GenericContextVyQrxcqd__Rszluig
     get {
       return []
+      // expected-warning@-1 {{empty collection literal requires an explicit type}}
     }
   }
 }
@@ -48,6 +54,7 @@ extension GenericContext where T == Int {
   // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test14GenericContextVAASiRszlE0c12ConcretizingD5Param1xQrSi_tF
   func testConcretizingGenericParam(x: T) -> some Collection {
     return []
+    // expected-warning@-1 {{empty collection literal requires an explicit type}}
   }
 }
 
@@ -58,19 +65,22 @@ extension TooGenericTooContext where T == U {
   // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test010TooGenericD7ContextVAAq_RszrlE0c8UnifyingE6Params1xQrx_tF
   func testUnifyingGenericParams(x: T) -> some Collection {
     return []
+    // expected-warning@-1 {{empty collection literal requires an explicit type}}
   }
 }
 
 extension TooGenericTooContext where T: Collection, U == T.Element {
   // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test010TooGenericD7ContextVAASlRz7ElementQzRs_rlE0c8UnifyingE7Params21xQrx_tF
   func testUnifyingGenericParams2(x: T) -> some Collection {
     return []
+    // expected-warning@-1 {{empty collection literal requires an explicit type}}
   }
 }
 extension TooGenericTooContext where T == Int {
   // CHECK: [[@LINE+1]]:{{[0-9]+}} s:14swift_ide_test010TooGenericD7ContextVAASiRszrlE0c12ConcretizingE5Param1xQrSi_tF
   func testConcretizingGenericParam(x: T) -> some Collection {
     return []
+    // expected-warning@-1 {{empty collection literal requires an explicit type}}
   }
 }