Merge pull request #63817 from tshortli/suppress-add-preconcurrency-remark-in-swiftinterfaces

Author: tshortli

lib/Sema/TypeCheckConcurrency.cpp

@@ -793,6 +793,19 @@ DiagnosticBehavior SendableCheckContext::diagnosticBehavior(
   return defaultBehavior;
 }
 
+static bool shouldDiagnosePreconcurrencyImports(SourceFile &sf) {
+  switch (sf.Kind) {
+  case SourceFileKind::Interface:
+  case SourceFileKind::SIL:
+      return false;
+
+  case SourceFileKind::Library:
+  case SourceFileKind::Main:
+  case SourceFileKind::MacroExpansion:
+      return true;
+  }
+}
+
 bool swift::diagnoseSendabilityErrorBasedOn(
     NominalTypeDecl *nominal, SendableCheckContext fromContext,
     llvm::function_ref<bool(DiagnosticBehavior)> diagnose) {
@@ -806,49 +819,70 @@ bool swift::diagnoseSendabilityErrorBasedOn(
 
   bool wasSuppressed = diagnose(behavior);
 
-  bool emittedDiagnostics =
-      behavior != DiagnosticBehavior::Ignore && !wasSuppressed;
-
-  // When the type is explicitly Sendable *or* explicitly non-Sendable, we
-  // assume it has been audited and `@preconcurrency` is not recommended even
-  // though it would actually affect the diagnostic.
-  bool nominalIsImportedAndHasImplicitSendability =
-      nominal &&
-      nominal->getParentModule() != fromContext.fromDC->getParentModule() &&
-      !hasExplicitSendableConformance(nominal);
-
-  if (emittedDiagnostics && nominalIsImportedAndHasImplicitSendability) {
-    // This type was imported from another module; try to find the
-    // corresponding import.
-    Optional<AttributedImport<swift::ImportedModule>> import;
-    SourceFile *sourceFile = fromContext.fromDC->getParentSourceFile();
-    if (sourceFile) {
-      import = findImportFor(nominal, fromContext.fromDC);
-    }
-
-    // If we found the import that makes this nominal type visible, remark
-    // that it can be @preconcurrency import.
-    // Only emit this remark once per source file, because it can happen a
-    // lot.
-    if (import && !import->options.contains(ImportFlags::Preconcurrency) &&
-        import->importLoc.isValid() && sourceFile &&
-        !sourceFile->hasImportUsedPreconcurrency(*import)) {
-      SourceLoc importLoc = import->importLoc;
-      ASTContext &ctx = nominal->getASTContext();
+  SourceFile *sourceFile = fromContext.fromDC->getParentSourceFile();
+  if (sourceFile && shouldDiagnosePreconcurrencyImports(*sourceFile)) {
+    bool emittedDiagnostics =
+        behavior != DiagnosticBehavior::Ignore && !wasSuppressed;
+
+    // When the type is explicitly Sendable *or* explicitly non-Sendable, we
+    // assume it has been audited and `@preconcurrency` is not recommended even
+    // though it would actually affect the diagnostic.
+    bool nominalIsImportedAndHasImplicitSendability =
+        nominal &&
+        nominal->getParentModule() != fromContext.fromDC->getParentModule() &&
+        !hasExplicitSendableConformance(nominal);
+
+    if (emittedDiagnostics && nominalIsImportedAndHasImplicitSendability) {
+      // This type was imported from another module; try to find the
+      // corresponding import.
+      Optional<AttributedImport<swift::ImportedModule>> import =
+          findImportFor(nominal, fromContext.fromDC);
+
+      // If we found the import that makes this nominal type visible, remark
+      // that it can be @preconcurrency import.
+      // Only emit this remark once per source file, because it can happen a
+      // lot.
+      if (import && !import->options.contains(ImportFlags::Preconcurrency) &&
+          import->importLoc.isValid() && sourceFile &&
+          !sourceFile->hasImportUsedPreconcurrency(*import)) {
+        SourceLoc importLoc = import->importLoc;
+        ASTContext &ctx = nominal->getASTContext();
 
-      ctx.Diags.diagnose(
-          importLoc, diag::add_predates_concurrency_import,
-          ctx.LangOpts.isSwiftVersionAtLeast(6),
-          nominal->getParentModule()->getName())
-        .fixItInsert(importLoc, "@preconcurrency ");
+        ctx.Diags
+            .diagnose(importLoc, diag::add_predates_concurrency_import,
+                      ctx.LangOpts.isSwiftVersionAtLeast(6),
+                      nominal->getParentModule()->getName())
+            .fixItInsert(importLoc, "@preconcurrency ");
 
-      sourceFile->setImportUsedPreconcurrency(*import);
+        sourceFile->setImportUsedPreconcurrency(*import);
+      }
     }
   }
 
   return behavior == DiagnosticBehavior::Unspecified && !wasSuppressed;
 }
 
+void swift::diagnoseUnnecessaryPreconcurrencyImports(SourceFile &sf) {
+  if (!shouldDiagnosePreconcurrencyImports(sf))
+    return;
+
+  ASTContext &ctx = sf.getASTContext();
+
+  if (ctx.TypeCheckerOpts.SkipFunctionBodies != FunctionBodySkipping::None)
+    return;
+
+  for (const auto &import : sf.getImports()) {
+    if (import.options.contains(ImportFlags::Preconcurrency) &&
+        import.importLoc.isValid() &&
+        !sf.hasImportUsedPreconcurrency(import)) {
+      ctx.Diags.diagnose(
+          import.importLoc, diag::remove_predates_concurrency_import,
+          import.module.importedModule->getName())
+        .fixItRemove(import.preconcurrencyRange);
+    }
+  }
+}
+
 /// Produce a diagnostic for a single instance of a non-Sendable type where
 /// a Sendable type is required.
 static bool diagnoseSingleNonSendableType(

lib/Sema/TypeCheckConcurrency.h

@@ -399,6 +399,11 @@ 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 None).

lib/Sema/TypeChecker.cpp

@@ -17,6 +17,7 @@
 
 #include "swift/Subsystems.h"
 #include "TypeChecker.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckDecl.h"
 #include "TypeCheckObjC.h"
 #include "TypeCheckType.h"
@@ -258,38 +259,6 @@ void swift::performTypeChecking(SourceFile &SF) {
                                  TypeCheckSourceFileRequest{&SF}, {});
 }
 
-/// 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.
-static void diagnoseUnnecessaryPreconcurrencyImports(SourceFile &sf) {
-  switch (sf.Kind) {
-  case SourceFileKind::Interface:
-  case SourceFileKind::SIL:
-    return;
-
-  case SourceFileKind::Library:
-  case SourceFileKind::Main:
-  case SourceFileKind::MacroExpansion:
-    break;
-  }
-
-  ASTContext &ctx = sf.getASTContext();
-
-  if (ctx.TypeCheckerOpts.SkipFunctionBodies != FunctionBodySkipping::None)
-    return;
-
-  for (const auto &import : sf.getImports()) {
-    if (import.options.contains(ImportFlags::Preconcurrency) &&
-        import.importLoc.isValid() &&
-        !sf.hasImportUsedPreconcurrency(import)) {
-      ctx.Diags.diagnose(
-          import.importLoc, diag::remove_predates_concurrency_import,
-          import.module.importedModule->getName())
-        .fixItRemove(import.preconcurrencyRange);
-    }
-  }
-}
-
 evaluator::SideEffect
 TypeCheckSourceFileRequest::evaluate(Evaluator &eval, SourceFile *SF) const {
   assert(SF && "Source file cannot be null!");

test/ModuleInterface/SilencePreconcurrency.swiftinterface

@@ -2,8 +2,15 @@
 // swift-module-flags: -module-name SilencePreconcurrency
 
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend -compile-module-from-interface -o %/t/SilencePreconcurrency.swiftmodule %s -verify
+// RUN: %target-swift-frontend -emit-module -o %t/Preconcurrency.swiftmodule -module-name Preconcurrency %S/Inputs/preconcurrency.swift
+// RUN: %target-swift-frontend -compile-module-from-interface -o %t/SilencePreconcurrency.swiftmodule %s -I %t -verify
 
 // REQUIRES: OS=macosx
 
 @preconcurrency import Swift
+import Preconcurrency
+
+@available(macOS 10.15, *)
+public enum SendableEnum: Sendable {
+  case caseWithNonSendablePayload(_ ns: NotSendable)
+}