[AST/Sema] Add a diagnostic group ExplicitSendable to replace -require-explicit-sendable

Always run explicit `Sendable` checks on public types and suppress
warning printing by default instead of using a special compiler argument.

Resolves: rdar://162394810

include/swift/AST/DiagnosticGroups.def

@@ -87,6 +87,7 @@ GROUP(TemporaryPointers,none,"temporary-pointers")
 GROUP(TrailingClosureMatching,none,"trailing-closure-matching")
 GROUP(UnknownWarningGroup,none,"unknown-warning-group")
 GROUP(WeakMutability,none,"weak-mutability")
+GROUP(ExplicitSendable,DefaultIgnoreWarnings,"explicit-sendable-annotations")
 
 GROUP_LINK(PerformanceHints,ExistentialType)
 GROUP_LINK(PerformanceHints,ReturnTypeImplicitCopy)

include/swift/AST/DiagnosticsSema.def

@@ -2857,9 +2857,9 @@ WARNING(remove_public_import,none,
 WARNING(remove_package_import,none,
         "package import of %0 was not used in package declarations",
         (Identifier))
-WARNING(public_decl_needs_sendable,none,
-        "public %kind0 does not specify whether it is 'Sendable' or not",
-        (const ValueDecl *))
+GROUPED_WARNING(public_decl_needs_sendable,ExplicitSendable,none,
+                "public %kind0 does not specify whether it is 'Sendable' or not",
+                (const ValueDecl *))
 NOTE(explicit_disable_sendable,none,
      "make %kind0 explicitly non-Sendable to suppress this warning",
      (const ValueDecl *))

lib/Sema/TypeCheckConcurrency.cpp

@@ -25,6 +25,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/Concurrency.h"
 #include "swift/AST/ConformanceLookup.h"
+#include "swift/AST/DiagnosticGroups.h"
 #include "swift/AST/DistributedDecl.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -1376,7 +1377,7 @@ static bool checkSendableInstanceStorage(
 void swift::diagnoseMissingExplicitSendable(NominalTypeDecl *nominal) {
   // Only diagnose when explicitly requested.
   ASTContext &ctx = nominal->getASTContext();
-  if (!ctx.LangOpts.RequireExplicitSendable)
+  if (ctx.Diags.isIgnoredDiagnosticGroupTree(DiagGroupID::ExplicitSendable))
     return;
 
   if (nominal->getLoc().isInvalid())

test/Concurrency/objc_require_explicit_sendable.swift

@@ -1,6 +1,6 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-sil -o /dev/null -I %S/Inputs/custom-modules %s -verify -parse-as-library -require-explicit-sendable
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-sil -o /dev/null -I %S/Inputs/custom-modules %s -verify -parse-as-library -require-explicit-sendable -strict-concurrency=targeted
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-sil -o /dev/null -I %S/Inputs/custom-modules %s -verify -parse-as-library -require-explicit-sendable -strict-concurrency=complete
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-sil -o /dev/null -I %S/Inputs/custom-modules %s -verify -parse-as-library -Wwarning ExplicitSendable
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-sil -o /dev/null -I %S/Inputs/custom-modules %s -verify -parse-as-library -Wwarning ExplicitSendable -strict-concurrency=targeted
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-sil -o /dev/null -I %S/Inputs/custom-modules %s -verify -parse-as-library -Wwarning ExplicitSendable -strict-concurrency=complete
 
 // REQUIRES: objc_interop
 // REQUIRES: concurrency

test/Concurrency/require-explicit-sendable.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -require-explicit-sendable -strict-concurrency=complete %s -emit-sil -o /dev/null -verify
+// RUN: %target-swift-frontend -Wwarning ExplicitSendable -strict-concurrency=complete %s -emit-sil -o /dev/null -verify
 
 
 public protocol P { }

userdocs/diagnostics/explicit-sendable-annotations.md

@@ -0,0 +1,30 @@
+# Explicit Sendable annotations on public type declarations
+
+If a public type doesn't have an explicit Sendable or non-Sendable annotation it is sometimes hard to discern whether that is intentional or not, especially if a type could be Sendable.
+
+## Overview
+
+The Swift compiler would emit a warning if a public type has none of the following:
+
+  - A conformance to `Sendable` protocol;
+  - An unavailable conformance to `Sendable` protocol;
+  - `~Sendable` conformance to suppress the inference.
+
+Let's consider a simple public type without any Senable annotations:
+
+```
+public struct S {
+    let x: Int
+}
+```
+
+When compiling with `-Wwarning ExplicitSendable` the following warning is going to be produced by the Swift compiler:
+
+```
+1 | public struct S {
+  |               |- warning: public struct 'S' does not specify whether it is 'Sendable' or not [#ExplicitSendable]
+  |               |- note: consider making struct 'S' conform to the 'Sendable' protocol
+  |               `- note: make struct 'S' explicitly non-Sendable to suppress this warning
+2 |     let x: Int
+3 | }
+```