[ClangImporter] Augment has*Attr methods to find attributes in type positions

`SwiftAttr` can now appear in type positions and `has*Attr` methods
have to account for that when the given declaration is `ParmVarDecl`.

Author: xedin

lib/ClangImporter/ClangImporter.cpp

@@ -7196,36 +7196,40 @@ static bool isForeignReferenceType(const clang::QualType type) {
   return hasImportAsRefAttr(pointeeType->getDecl());
 }
 
+static bool hasSwiftAttribute(const clang::Decl *decl, StringRef attr) {
+  if (decl->hasAttrs() && llvm::any_of(decl->getAttrs(), [&](auto *A) {
+        if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(A))
+          return swiftAttr->getAttribute() == attr;
+        return false;
+      }))
+    return true;
+
+  if (auto *P = dyn_cast<clang::ParmVarDecl>(decl)) {
+    bool found = false;
+    findSwiftAttributes(P->getOriginalType(),
+                        [&](const clang::SwiftAttrAttr *swiftAttr) {
+                          found |= swiftAttr->getAttribute() == attr;
+                        });
+    return found;
+  }
+
+  return false;
+}
+
 static bool hasOwnedValueAttr(const clang::RecordDecl *decl) {
-  return decl->hasAttrs() && llvm::any_of(decl->getAttrs(), [](auto *attr) {
-           if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
-             return swiftAttr->getAttribute() == "import_owned";
-           return false;
-         });
+  return hasSwiftAttribute(decl, "import_owned");
 }
 
 bool importer::hasUnsafeAPIAttr(const clang::Decl *decl) {
-  return decl->hasAttrs() && llvm::any_of(decl->getAttrs(), [](auto *attr) {
-           if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
-             return swiftAttr->getAttribute() == "import_unsafe";
-           return false;
-         });
+  return hasSwiftAttribute(decl, "import_unsafe");
 }
 
 static bool hasIteratorAPIAttr(const clang::Decl *decl) {
-  return decl->hasAttrs() && llvm::any_of(decl->getAttrs(), [](auto *attr) {
-           if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
-             return swiftAttr->getAttribute() == "import_iterator";
-           return false;
-         });
+  return hasSwiftAttribute(decl, "import_iterator");
 }
 
 static bool hasNonCopyableAttr(const clang::RecordDecl *decl) {
-  return decl->hasAttrs() && llvm::any_of(decl->getAttrs(), [](auto *attr) {
-           if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
-             return swiftAttr->getAttribute() == "~Copyable";
-           return false;
-         });
+  return hasSwiftAttribute(decl, "~Copyable");
 }
 
 /// Recursively checks that there are no pointers in any fields or base classes.

lib/ClangImporter/ImportType.cpp

@@ -1633,15 +1633,9 @@ static ImportedType adjustTypeForConcreteImport(
   return {importedType, isIUO};
 }
 
-void swift::getConcurrencyAttrs(ASTContext &SwiftContext,
-                                ImportTypeKind importKind,
-                                ImportTypeAttrs &attrs, clang::QualType type) {
-  bool isMainActor = false;
-  bool isSendable =
-      SwiftContext.LangOpts.hasFeature(Feature::SendableCompletionHandlers) &&
-      importKind == ImportTypeKind::CompletionHandlerParameter;
-  bool isNonSendable = false;
-
+void swift::findSwiftAttributes(
+    clang::QualType type,
+    llvm::function_ref<void(const clang::SwiftAttrAttr *)> callback) {
   std::function<clang::QualType(clang::QualType)> skipUnrelatedSugar =
       [&](clang::QualType type) -> clang::QualType {
     if (auto *MQT = dyn_cast<clang::MacroQualifiedType>(type))
@@ -1660,19 +1654,33 @@ void swift::getConcurrencyAttrs(ASTContext &SwiftContext,
   while (const auto *AT = dyn_cast<clang::AttributedType>(type)) {
     if (auto swiftAttr =
             dyn_cast_or_null<clang::SwiftAttrAttr>(AT->getAttr())) {
-      if (isMainActorAttr(swiftAttr)) {
-        isMainActor = true;
-        isNonSendable =
-            importKind == ImportTypeKind::Parameter ||
-            importKind == ImportTypeKind::CompletionHandlerParameter;
-      } else if (swiftAttr->getAttribute() == "@Sendable")
-        isSendable = true;
-      else if (swiftAttr->getAttribute() == "@_nonSendable")
-        isNonSendable = true;
+      callback(swiftAttr);
     }
-
     type = skipUnrelatedSugar(AT->getEquivalentType());
   }
+}
+
+void swift::getConcurrencyAttrs(ASTContext &SwiftContext,
+                                ImportTypeKind importKind,
+                                ImportTypeAttrs &attrs, clang::QualType type) {
+  bool isMainActor = false;
+  bool isSendable =
+      SwiftContext.LangOpts.hasFeature(Feature::SendableCompletionHandlers) &&
+      importKind == ImportTypeKind::CompletionHandlerParameter;
+  bool isNonSendable = false;
+
+  // Consider only immediate attributes, don't look through the typerefs
+  // because they are imported separately.
+  findSwiftAttributes(type, [&](const clang::SwiftAttrAttr *attr) {
+    if (isMainActorAttr(attr)) {
+      isMainActor = true;
+      isNonSendable = importKind == ImportTypeKind::Parameter ||
+                      importKind == ImportTypeKind::CompletionHandlerParameter;
+    } else if (attr->getAttribute() == "@Sendable")
+      isSendable = true;
+    else if (attr->getAttribute() == "@_nonSendable")
+      isNonSendable = true;
+  });
 
   if (isMainActor)
     attrs |= ImportTypeAttr::MainActor;

lib/ClangImporter/ImporterImpl.h

@@ -216,6 +216,12 @@ enum class ImportTypeAttr : uint8_t {
   CFUnretainedOutParameter = 1 << 5,
 };
 
+/// Find and iterate over swift attributes embedded in the type
+/// without looking through typealiases.
+void findSwiftAttributes(
+    clang::QualType type,
+    llvm::function_ref<void(const clang::SwiftAttrAttr *)> callback);
+
 /// Attributes which were set on the declaration and affect how its type is
 /// imported.
 ///