[Sema] SwiftAttr in some situations should be handled as a declaration attribute

Adjust `SwiftAttr` handling to determine when attribute should be
handled as a type or declaration attribute i.e. if attribute is
attached to a declarator or declaration name, it should be handled
as a declaration attribute.

Author: xedin

clang/lib/Sema/SemaType.cpp

@@ -7438,16 +7438,55 @@ static bool HandleWebAssemblyFuncrefAttr(TypeProcessingState &State,
   return false;
 }
 
-static void HandleSwiftAttr(TypeProcessingState &State, QualType &QT,
-                            ParsedAttr &PAttr) {
+static void HandleSwiftAttr(TypeProcessingState &State, TypeAttrLocation TAL,
+                            QualType &QT, ParsedAttr &PAttr) {
+  if (TAL == TAL_DeclName)
+    return;
+
   Sema &S = State.getSema();
+  auto &D = State.getDeclarator();
+
+  // If the attribute appears in declaration specifiers
+  // it should be handled as a declaration attribute,
+  // unless it's associated with a type or a function
+  // prototype (i.e. appears on a parameter or result type).
+  if (State.isProcessingDeclSpec()) {
+    if (!(D.isPrototypeContext() ||
+          D.getContext() == DeclaratorContext::TypeName))
+      return;
+
+    if (auto *chunk = D.getInnermostNonParenChunk()) {
+      moveAttrFromListToList(PAttr, State.getCurrentAttributes(),
+                             const_cast<DeclaratorChunk *>(chunk)->getAttrs());
+      return;
+    }
+  }
 
   StringRef Str;
   if (!S.checkStringLiteralArgumentAttr(PAttr, 0, Str)) {
     PAttr.setInvalid();
     return;
   }
 
+  // If the attribute as attached to a paren move it closer to
+  // the declarator. This can happen in block declarations when
+  // an attribute is placed before `^` i.e. `(__attribute__((...)) ^)`.
+  //
+  // Note that it's actually invalid to use GNU style attributes
+  // in a block but such cases are currently handled gracefully
+  // but the parser and behavior should be consistent between
+  // cases when attribute appears before/after block's result
+  // type and inside (^).
+  if (TAL == TAL_DeclChunk) {
+    auto chunkIdx = State.getCurrentChunkIndex();
+    if (chunkIdx >= 1 &&
+        D.getTypeObject(chunkIdx).Kind == DeclaratorChunk::Paren) {
+      moveAttrFromListToList(PAttr, State.getCurrentAttributes(),
+                             D.getTypeObject(chunkIdx - 1).getAttrs());
+      return;
+    }
+  }
+
   auto *A = ::new (S.Context) SwiftAttrAttr(S.Context, PAttr, Str);
   QT = State.getAttributedType(A, QT, QT);
   PAttr.setUsedAsTypeAttr();
@@ -8835,7 +8874,7 @@ static void processTypeAttrs(TypeProcessingState &state, QualType &type,
     }
 
     case ParsedAttr::AT_SwiftAttr: {
-      HandleSwiftAttr(state, type, attr);
+      HandleSwiftAttr(state, TAL, type, attr);
       break;
     }
 

clang/test/AST/attr-swift_attr.m

@@ -16,15 +16,14 @@ @interface Contact
 // CHECK-NEXT: SwiftAttrAttr {{.*}} "@sendable"
 
 #define SWIFT_SENDABLE __attribute__((swift_attr("@Sendable")))
-#define MAIN_ACTOR __attribute__((swift_attr("@MainActor")))
 
 @interface InTypeContext
 - (nullable id)test:(nullable SWIFT_SENDABLE id)obj SWIFT_SENDABLE;
 @end
 
 // CHECK-LABEL: InterfaceDecl {{.*}} InTypeContext
 // CHECK-NEXT: MethodDecl {{.*}} - test: 'id _Nullable':'id'
-// CHECK-NEXT: ParmVarDecl {{.*}} obj 'id _Nullable':'id'
+// CHECK-NEXT: ParmVarDecl {{.*}} obj 'SWIFT_SENDABLE id _Nullable':'id'
 // CHECK-NEXT: SwiftAttrAttr {{.*}} "@Sendable"
 
 @interface Generic<T: SWIFT_SENDABLE id>
@@ -38,3 +37,11 @@ @interface Generic<T: SWIFT_SENDABLE id>
 // CHECK-LABEL: TypedefDecl {{.*}} Alias 'Generic<id>'
 // CHECK-NEXT: ObjectType {{.*}} 'Generic<id>'
 // CHECK-NEXT: SwiftAttrAttr {{.*}} "@Sendable"
+
+SWIFT_SENDABLE
+typedef struct {
+  void *ptr;
+} SendableStruct;
+
+// CHECK-LABEL: TypedefDecl {{.*}} SendableStruct 'struct SendableStruct':'SendableStruct'
+// CHECK: SwiftAttrAttr {{.*}} "@Sendable"