[ClangImporter] Augment importType to infer concurrency attributes from types

Support for `swift_attr` has been extended to type contexts.
Such attributes form `clang::AtributedType` that carries an
optional `clang::Attr *`. Teach `importType` has to examine
immediate sugar to determine whether it carries any concurrency
information and, if so, add it to `ImportTypeAttrs` to be
applied after import.

Author: xedin

lib/ClangImporter/ImportType.cpp

@@ -1633,6 +1633,52 @@ static ImportedType adjustTypeForConcreteImport(
   return {importedType, isIUO};
 }
 
+static void applyTypeAttributes(ImportTypeKind importKind,
+                                ImportTypeAttrs &attrs, clang::QualType type) {
+  bool isMainActor = false;
+  bool isSendable = false;
+  bool isNonSendable = false;
+
+  std::function<clang::QualType(clang::QualType)> skipUnrelatedSugar =
+      [&](clang::QualType type) -> clang::QualType {
+    if (auto *MQT = dyn_cast<clang::MacroQualifiedType>(type))
+      return MQT->isSugared() ? skipUnrelatedSugar(MQT->desugar()) : type;
+
+    if (auto *ET = dyn_cast<clang::ElaboratedType>(type))
+      return ET->isSugared() ? skipUnrelatedSugar(ET->desugar()) : type;
+
+    return type;
+  };
+
+  type = skipUnrelatedSugar(type);
+
+  // Consider only immediate attributes, don't look through the typerefs
+  // because they are imported separately.
+  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;
+    }
+
+    type = skipUnrelatedSugar(AT->getEquivalentType());
+  }
+
+  if (isMainActor)
+    attrs |= ImportTypeAttr::MainActor;
+  if (isSendable)
+    attrs |= ImportTypeAttr::Sendable;
+  if (isNonSendable)
+    attrs -= ImportTypeAttr::Sendable;
+}
+
 ImportedType ClangImporter::Implementation::importType(
     clang::QualType type, ImportTypeKind importKind,
     llvm::function_ref<void(Diagnostic &&)> addImportDiagnosticFn,
@@ -1679,6 +1725,8 @@ ImportedType ClangImporter::Implementation::importType(
     optionality = translateNullability(*nullability, stripNonResultOptionality);
   }
 
+  applyTypeAttributes(importKind, attrs, type);
+
   // If this is a completion handler parameter, record the function type whose
   // parameters will act as the results of the completion handler.
   const clang::FunctionType *completionHandlerType = nullptr;

test/Concurrency/sendable_objc_attr_in_type_context.swift

@@ -0,0 +1,75 @@
+// RUN: %empty-directory(%t/src)
+// RUN: %empty-directory(%t/sdk)
+// RUN: split-file %s %t/src
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck %t/src/main.swift \
+// RUN:   -import-objc-header %t/src/Test.h \
+// RUN:   -strict-concurrency=complete \
+// RUN:   -enable-experimental-feature SendableCompletionHandlers \
+// RUN:   -module-name main -I %t -verify
+
+// REQUIRES: objc_interop
+
+//--- Test.h
+#define SWIFT_SENDABLE __attribute__((__swift_attr__("@Sendable")))
+#define NONSENDABLE __attribute__((__swift_attr__("@_nonSendable")))
+
+#pragma clang assume_nonnull begin
+
+@import Foundation;
+
+@interface MyValue : NSObject
+@end
+
+typedef void (^CompletionHandler)(void (^ SWIFT_SENDABLE)(void)) SWIFT_SENDABLE;
+
+@interface Test : NSObject
+-(void) makeRequest:
+          (NSString *)typeIdentifier
+          loadHandler:(void (^SWIFT_SENDABLE )(void (SWIFT_SENDABLE ^)(void)))loadHandler;
+-(void) withSendableId: (void (^)(SWIFT_SENDABLE id)) handler;
+-(void) withSendableCustom: (void (^)(MyValue *_Nullable SWIFT_SENDABLE)) handler;
+-(void) withNonSendable:(NSString *)operation completionHandler:(void (^ _Nullable NONSENDABLE)(NSString *_Nullable, NSError * _Nullable)) handler;
+-(void) withAliasCompletionHandler:(CompletionHandler)handler;
+@end
+
+// Placement of SWIFT_SENDABLE matters here
+void doSomethingConcurrently(__attribute__((noescape)) void SWIFT_SENDABLE (^block)(void));
+
+#pragma clang assume_nonnull end
+
+//--- main.swift
+
+func test_sendable_attr_in_type_context(test: Test) {
+  let fn: (String?, (any Error)?) -> Void = { _,_ in }
+
+  test.withNonSendable("", completionHandler: fn) // Ok
+
+  test.makeRequest("id") {
+    doSomethingConcurrently($0) // Ok
+  }
+
+  test.makeRequest("id") { callback in
+    _ = { @Sendable in
+      callback() // Ok
+    }
+  }
+
+  test.withSendableId { id in
+    _ = { @Sendable in
+      print(id) // Ok
+    }
+  }
+
+  test.withSendableCustom { val in
+    _ = { @Sendable in
+      print(val!)
+    }
+  }
+
+  let _: (@escaping @Sendable (@escaping @Sendable () -> Void) -> Void) -> Void = test.withAliasCompletionHandler
+
+  test.withAliasCompletionHandler { callback in
+    doSomethingConcurrently(callback) // Ok
+  }
+}