[region-isolation] When RegionIsolation is enabled, delay the preconcurrency import not used diagnostic to the SIL pipeline.

The reason why I am doing this is that I am going to be adding support for
preconcurrency imports to TransferNonSendable. That implies that we can have
preconcurrency import suppression in the SIL pipeline and thus that emitting the
diagnostic in Sema is too early.

To do this, I introduced a new module pass called
DiagnoseUnnecessaryPreconcurrencyImports that runs after the SILFunction pass
TransferNonSendable. The reason why I use a module pass is to ensure that
TransferNonSendable has run on all functions before we attempt to emit these
diagnostics. Then in that pass, we iterate over all of the modules functions and
construct a uniqued array of SourceFiles for these functions. Then we iterate
over the uniqued SourceFiles and use the already constructed Sema machinery to
emit the diagnostic using the source files.

rdar://126928265
(cherry picked from commit c4f7076)

Author: gottesmm

include/swift/SILOptimizer/PassManager/Passes.def

@@ -501,6 +501,8 @@ PASS(ReferenceBindingTransform, "sil-reference-binding-transform",
      "Check/transform reference bindings")
 PASS(DiagnosticDeadFunctionElimination, "sil-diagnostic-dead-function-elim",
      "Eliminate dead functions from early specialization optimizations before we run later diagnostics")
+PASS(DiagnoseUnnecessaryPreconcurrencyImports, "sil-diagnose-unnecessary-preconcurrency-imports",
+     "Diagnose any preconcurrency imports that Sema and TransferNonSendable did not use")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

include/swift/Sema/Concurrency.h

@@ -0,0 +1,34 @@
+//===--- Concurrency.h ----------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+/// This file defines concurrency utility routines from Sema that are used by
+/// later parts of the compiler like the pass pipeline.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SEMA_CONCURRENCY_H
+#define SWIFT_SEMA_CONCURRENCY_H
+
+namespace swift {
+
+class SourceFile;
+
+/// If any of the imports in this source file was @preconcurrency but there were
+/// no diagnostics downgraded or suppressed due to that @preconcurrency, suggest
+/// that the attribute be removed.
+void diagnoseUnnecessaryPreconcurrencyImports(SourceFile &sf);
+
+} // namespace swift
+
+#endif

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -9,6 +9,7 @@ target_sources(swiftSILOptimizer PRIVATE
   ConsumeOperatorCopyableValuesChecker.cpp
   PhiStorageOptimizer.cpp
   ConstantPropagation.cpp
+  DiagnoseUnnecessaryPreconcurrencyImports.cpp
   DebugInfoCanonicalizer.cpp
   DefiniteInitialization.cpp
   DIMemoryUseCollector.cpp

lib/SILOptimizer/Mandatory/DiagnoseUnnecessaryPreconcurrencyImports.cpp

@@ -0,0 +1,79 @@
+//===--- DiagnoseUnnecessaryPreconcurrencyImports.cpp ---------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+/// This is run after TransferNonSendable and uses Sema infrastructure to
+/// determine if in Sema or TransferNonSendable any of the preconcurrency import
+/// statements were not used.
+///
+/// This only runs when RegionIsolation is enabled. If RegionIsolation is
+/// disabled, we emit the unnecessary preconcurrency imports earlier during Sema
+/// since no later diagnostics will be emitted.
+///
+/// NOTE: This needs to be a module pass and run after TransferNonSendable so we
+/// can guarantee that we have run TransferNonSendable on all functions in our
+/// module before this runs.
+///
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/SourceFile.h"
+#include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "swift/Sema/Concurrency.h"
+
+using namespace swift;
+
+//===----------------------------------------------------------------------===//
+//                         MARK: Top Level Entrypoint
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+class DiagnoseUnnecessaryPreconcurrencyImports : public SILModuleTransform {
+  void run() override {
+    // If region isolation is not enabled... return early.
+    if (!getModule()->getASTContext().LangOpts.hasFeature(
+            Feature::RegionBasedIsolation))
+      return;
+
+    std::vector<SourceFile *> data;
+    for (auto &fn : *getModule()) {
+      auto *sf = fn.getSourceFile();
+      if (!sf) {
+        continue;
+      }
+
+      data.push_back(sf);
+      assert(sf->getBufferID() != -1 && "Must have a buffer id");
+    }
+
+    // Sort unique by filename so our diagnostics are deterministic.
+    //
+    // TODO: If we cannot rely upon this, just sort by pointer address. Non
+    // determinism emission of diagnostics isn't great but it isn't fatal.
+    sortUnique(data, [](SourceFile *lhs, SourceFile *rhs) -> bool {
+      return lhs->getBufferID() < rhs->getBufferID();
+    });
+
+    // At this point, we know that we have our sorted unique list of source
+    // files.
+    for (auto *sf : data) {
+      diagnoseUnnecessaryPreconcurrencyImports(*sf);
+    }
+  }
+};
+
+} // namespace
+
+SILTransform *swift::createDiagnoseUnnecessaryPreconcurrencyImports() {
+  return new DiagnoseUnnecessaryPreconcurrencyImports();
+}

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -140,8 +140,11 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
   P.addTransferNonSendable();
 
   // Now that we have completed running passes that use region analysis, clear
-  // region analysis.
+  // region analysis and emit diagnostics for unnecessary preconcurrency
+  // imports.
   P.addRegionAnalysisInvalidationTransform();
+  P.addDiagnoseUnnecessaryPreconcurrencyImports();
+
   // Lower tuple addr constructor. Eventually this can be merged into later
   // passes. This ensures we do not need to update later passes for something
   // that is only needed by TransferNonSendable().

lib/Sema/TypeCheckConcurrency.h

@@ -23,6 +23,8 @@
 #include "swift/AST/Expr.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/Type.h"
+#include "swift/Sema/Concurrency.h"
+
 #include <cassert>
 
 namespace swift {
@@ -487,11 +489,6 @@ bool diagnoseSendabilityErrorBasedOn(
     NominalTypeDecl *nominal, SendableCheckContext fromContext,
     llvm::function_ref<bool(DiagnosticBehavior)> diagnose);
 
-/// If any of the imports in this source file was @preconcurrency but
-/// there were no diagnostics downgraded or suppressed due to that
-/// @preconcurrency, suggest that the attribute be removed.
-void diagnoseUnnecessaryPreconcurrencyImports(SourceFile &sf);
-
 /// Given a set of custom attributes, pick out the global actor attributes
 /// and perform any necessary resolution and diagnostics, returning the
 /// global actor attribute and type it refers to (or \c std::nullopt).

lib/Sema/TypeChecker.cpp

@@ -315,7 +315,11 @@ TypeCheckSourceFileRequest::evaluate(Evaluator &eval, SourceFile *SF) const {
     SF->typeCheckDelayedFunctions();
   }
 
-  diagnoseUnnecessaryPreconcurrencyImports(*SF);
+  // If region based isolation is enabled, we diagnose unnecessary
+  // preconcurrency imports in the SIL pipeline in the
+  // DiagnoseUnnecessaryPreconcurrencyImports pass.
+  if (!Ctx.LangOpts.hasFeature(Feature::RegionBasedIsolation))
+    diagnoseUnnecessaryPreconcurrencyImports(*SF);
   diagnoseUnnecessaryPublicImports(*SF);
 
   // Check to see if there are any inconsistent imports.