[NFC] Factor out ImportTypeAttrs

Preparation for integrating the logic remaining in `applyParamAttributes()` into `importType()`.

Author: beccadax

include/swift/AST/DiagnosticsClangImporter.def

@@ -89,10 +89,10 @@ WARNING(clang_error_code_must_be_sendable,none,
         "cannot make error code type '%0' non-sendable because Swift errors "
         "are always sendable", (StringRef))
 
-WARNING(clang_param_ignored_sendable_attr,none,
-        "cannot make parameter '%0' sendable type %1 cannot be made sendable "
-        "by adding '@Sendable' or '& Sendable'",
-        (StringRef, Type))
+WARNING(clang_ignored_sendable_attr,none,
+        "cannot make type %0 sendable because '@Sendable' and '& Sendable' "
+        "cannot be added to it",
+        (Type))
 NOTE(clang_param_should_be_implicitly_sendable,none,
      "parameter should be implicitly 'Sendable' because it is a completion "
      "handler", ())

lib/ClangImporter/ImportType.cpp

@@ -1948,19 +1948,21 @@ class GetSendableType :
 
 } // anonymous namespace
 
-Type ClangImporter::Implementation::applyParamAttributes(
-    const clang::ParmVarDecl *param, Type type, bool sendableByDefault) {
+ImportTypeAttrs swift::getImportTypeAttrs(const clang::Decl *D, bool isParam,
+                                          bool sendableByDefault) {
+  ImportTypeAttrs attrs;
+
+  if (sendableByDefault)
+    attrs |= ImportTypeAttr::DefaultsToSendable;
+
   bool sendableRequested = sendableByDefault;
   bool sendableDisqualified = false;
 
-  if (param->hasAttrs()) {
-    for (auto attr : param->getAttrs()) {
+  if (D->hasAttrs()) {
+    for (auto attr : D->getAttrs()) {
       // Map __attribute__((noescape)) to @noescape.
-      if (isa<clang::NoEscapeAttr>(attr)) {
-        type = applyToFunctionType(type, [](ASTExtInfo extInfo) {
-          return extInfo.withNoEscape();
-        });
-
+      if (isParam && isa<clang::NoEscapeAttr>(attr)) {
+        attrs |= ImportTypeAttr::NoEscape;
         continue;
       }
 
@@ -1969,14 +1971,9 @@ Type ClangImporter::Implementation::applyParamAttributes(
         continue;
 
       // Map the main-actor attribute.
-      if (isMainActorAttr(swiftAttr)) {
-        if (Type mainActor = SwiftContext.getMainActorType()) {
-          type = applyToFunctionType(type, [&](ASTExtInfo extInfo) {
-            return extInfo.withGlobalActor(mainActor);
-          });
-          sendableDisqualified = true;
-        }
-
+      if (isParam && isMainActorAttr(swiftAttr)) {
+        attrs |= ImportTypeAttr::MainActor;
+        sendableDisqualified = true;
         continue;
       }
 
@@ -1995,22 +1992,51 @@ Type ClangImporter::Implementation::applyParamAttributes(
   }
 
   if (!sendableDisqualified && sendableRequested) {
+    attrs |= ImportTypeAttr::Sendable;
+  }
+
+  return attrs;
+}
+
+Type ClangImporter::Implementation::applyParamAttributes(
+    const clang::ParmVarDecl *param, Type type, bool sendableByDefault) {
+  auto parentDecl = cast<clang::Decl>(param->getDeclContext());
+  ImportDiagnosticAdder addDiag(*this, parentDecl, param->getLocation());
+
+  auto attrs = getImportTypeAttrs(param, /*isParam=*/true, sendableByDefault);
+  return applyImportTypeAttrs(attrs, type, addDiag);
+}
+
+Type ClangImporter::Implementation::
+applyImportTypeAttrs(ImportTypeAttrs attrs, Type type,
+                     llvm::function_ref<void(Diagnostic &&)> addDiag) {
+  if (attrs.contains(ImportTypeAttr::NoEscape)) {
+    type = applyToFunctionType(type, [](ASTExtInfo extInfo) {
+      return extInfo.withNoEscape();
+    });
+  }
+
+  if (attrs.contains(ImportTypeAttr::MainActor)) {
+    if (Type mainActor = SwiftContext.getMainActorType()) {
+      type = applyToFunctionType(type, [&](ASTExtInfo extInfo) {
+        return extInfo.withGlobalActor(mainActor);
+      });
+    } else {
+      // If we can't use @MainActor, fall back to at least using @Sendable.
+      attrs |= ImportTypeAttr::Sendable;
+    }
+  }
+
+  if (attrs.contains(ImportTypeAttr::Sendable)) {
     bool changed;
     std::tie(type, changed) = GetSendableType(SwiftContext).convert(type);
 
     // Diagnose if we couldn't find a place to add `Sendable` to the type.
     if (!changed) {
-      auto parentDecl = cast<clang::Decl>(param->getDeclContext());
-
-      addImportDiagnostic(parentDecl,
-          Diagnostic(diag::clang_param_ignored_sendable_attr,
-                     param->getName(), type),
-          param->getLocation());
+      addDiag(Diagnostic(diag::clang_ignored_sendable_attr, type));
 
-      if (sendableByDefault)
-        addImportDiagnostic(parentDecl,
-            Diagnostic(diag::clang_param_should_be_implicitly_sendable),
-            param->getLocation());
+      if (attrs.contains(ImportTypeAttr::DefaultsToSendable))
+        addDiag(Diagnostic(diag::clang_param_should_be_implicitly_sendable));
     }
   }
 

lib/ClangImporter/ImporterImpl.h

@@ -187,6 +187,48 @@ enum class ImportTypeKind {
   Enum
 };
 
+/// Flags which are extracted from an imported declaration to influence how its
+/// type is imported. Typically used via \c ImportTypeAttrs to form an option
+/// set.
+///
+/// \warning Do not use this as a random grab bag of flags to \c importType() .
+/// This information is intended to be extracted and applied all at once.
+enum class ImportTypeAttr : uint8_t {
+  /// Type should be imported as though declaration was marked with
+  /// \c __attribute__((noescape)) .
+  NoEscape = 1 << 0,
+
+  /// Type should be imported as though declaration was marked with
+  /// \c __attribute__((swift_attr("@MainActor"))) .
+  MainActor = 1 << 1,
+
+  /// Type should be imported as though declaration was marked with
+  /// \c __attribute__((swift_attr("@Sendable"))) .
+  Sendable = 1 << 2,
+
+  /// Type is in a declaration where it would be imported as Sendable by
+  /// default. This comes directly from the parameters to
+  /// \c getImportTypeAttrs() and merely affects diagnostics.
+  DefaultsToSendable = 1 << 3
+};
+
+/// Attributes which were set on the declaration and affect how its type is
+/// imported.
+///
+/// \seeAlso ImportTypeAttr
+using ImportTypeAttrs = OptionSet<ImportTypeAttr>;
+
+/// Extracts the \c ImportTypeAttrs from a declaration.
+///
+/// \param D The declaration to extract attributes from.
+/// \param isParam Is the declaration a function parameter? If so, additional
+///        attributes will be imported.
+/// \param sendableByDefault If the sendability of the declaration is not
+///        specified, should the \c \@Sendable attribute be added implicitly?
+///        Used for e.g. completion handlers.
+ImportTypeAttrs getImportTypeAttrs(const clang::Decl *D, bool isParam = false,
+                                   bool sendableByDefault = false);
+
 struct ImportDiagnostic {
   ImportDiagnosticTarget target;
   Diagnostic diag;
@@ -956,6 +998,9 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   Type applyParamAttributes(const clang::ParmVarDecl *param, Type type,
                             bool sendableByDefault);
 
+  Type applyImportTypeAttrs(ImportTypeAttrs attrs, Type type,
+                 llvm::function_ref<void(Diagnostic &&)> addImportDiagnosticFn);
+
   /// If we already imported a given decl, return the corresponding Swift decl.
   /// Otherwise, return nullptr.
   Optional<Decl *> importDeclCached(const clang::NamedDecl *ClangDecl,