Make the @_predatesConcurrency diagnostic a once-per-file-per-module remark

Rather than tacking the "add `@_predatesConcurrecy` to import"
diagnostic on to the prior diagnostic as a note, make it its own
remark. Then, ensure that we only emit this remark once per source
file per imported module, so we're not overwhelming the user.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -1952,7 +1952,7 @@ NOTE(non_sendable_nominal,none,
 NOTE(add_nominal_sendable_conformance,none,
      "consider making %0 %1 conform to the 'Sendable' protocol",
      (DescriptiveDeclKind, DeclName))
-NOTE(add_predates_concurrency_import,none,
+REMARK(add_predates_concurrency_import,none,
      "add '@_predatesConcurrency' to %select{suppress|treat}0 "
      "'Sendable'-related %select{warnings|errors}0 from module %1"
      "%select{| as warnings}0", (bool, Identifier))

include/swift/AST/SourceFile.h

@@ -84,6 +84,10 @@ class SourceFile final : public FileUnit {
   /// This is \c None until it is filled in by the import resolution phase.
   Optional<ArrayRef<AttributedImport<ImportedModule>>> Imports;
 
+  /// Which imports have made use of @_predatesConcurrency.
+  llvm::SmallDenseSet<AttributedImport<ImportedModule>>
+      PredatesConcurrencyImportsUsed;
+
   /// A unique identifier representing this file; used to mark private decls
   /// within the file to keep them from conflicting with other files in the
   /// same module.
@@ -293,6 +297,14 @@ class SourceFile final : public FileUnit {
   /// resolution.
   void setImports(ArrayRef<AttributedImport<ImportedModule>> imports);
 
+  /// Whether the given import has used @_predatesConcurrency.
+  bool hasImportUsedPredatesConcurrency(
+      AttributedImport<ImportedModule> import) const;
+
+  /// Note that the given import has used @_predatesConcurrency/
+  void setImportUsedPredatesConcurrency(
+      AttributedImport<ImportedModule> import);
+
   enum ImportQueryKind {
     /// Return the results for testable or private imports.
     TestableAndPrivate,

lib/AST/Module.cpp

@@ -2240,6 +2240,16 @@ SourceFile::setImports(ArrayRef<AttributedImport<ImportedModule>> imports) {
   Imports = getASTContext().AllocateCopy(imports);
 }
 
+bool SourceFile::hasImportUsedPredatesConcurrency(
+    AttributedImport<ImportedModule> import) const {
+  return PredatesConcurrencyImportsUsed.count(import) != 0;
+}
+
+void SourceFile::setImportUsedPredatesConcurrency(
+    AttributedImport<ImportedModule> import) {
+  PredatesConcurrencyImportsUsed.insert(import);
+}
+
 bool HasImplementationOnlyImportsRequest::evaluate(Evaluator &evaluator,
                                                    SourceFile *SF) const {
   return llvm::any_of(SF->getImports(),

lib/Sema/TypeCheckConcurrency.cpp

@@ -776,16 +776,22 @@ static bool diagnoseSingleNonSendableType(
         nominal->getName());
 
     // If we can find an import in this context that makes this nominal
-    // type visible, note that it can be `@_predatesConcurrency` import.
+    // type visible, remark that it can be `@_predatesConcurrency` import.
+    // Only emit this remark once per source file, because it can happen a
+    // lot.
+    SourceFile *sourceFile = fromContext.fromDC->getParentSourceFile();
     auto import = findImportFor(nominal, fromContext.fromDC);
     if (import && !import->options.contains(ImportFlags::PredatesConcurrency) &&
-        import->importLoc.isValid()) {
+        import->importLoc.isValid() && sourceFile &&
+        !sourceFile->hasImportUsedPredatesConcurrency(*import)) {
       SourceLoc importLoc = import->importLoc;
       ctx.Diags.diagnose(
           importLoc, diag::add_predates_concurrency_import,
           ctx.LangOpts.isSwiftVersionAtLeast(6),
           nominal->getParentModule()->getName())
         .fixItInsert(importLoc, "@_predatesConcurrency ");
+
+      sourceFile->setImportUsedPredatesConcurrency(*import);
     }
   }
 

test/Concurrency/actor_isolation.swift

@@ -3,7 +3,7 @@
 // RUN: %target-typecheck-verify-swift -I %t  -disable-availability-checking -warn-concurrency
 // REQUIRES: concurrency
 
-import OtherActors // expected-note 2{{add '@_predatesConcurrency' to suppress 'Sendable'-related warnings from module 'OtherActors'}}{{1-1=@_predatesConcurrency }}
+import OtherActors // expected-remark{{add '@_predatesConcurrency' to suppress 'Sendable'-related warnings from module 'OtherActors'}}{{1-1=@_predatesConcurrency }}
 
 let immutableGlobal: String = "hello"
 var mutableGlobal: String = "can't touch this" // expected-note 5{{var declared here}}