Pass IsInherited when merging attribute lists [RFC]

[Meinersbur]

Summary

Attempt to solve the the diagnostic marker order ('note: previous declaration here' pointing to a source location before the main error marker) from D48100.

The approach is to pass a IsInherited parameters. If false, the order if the diagnostic marker is reversed.

The actual reversal is only implemented for two diagnoses: diag::err_mismatched_visibility and diag::err_ownership_returns_index_mismatch. Test cases not adapted.

include/clang/Sema/Sema.h

AvailabilityAttr *mergeAvailabilityAttr(NamedDecl *D, SourceRange Range,
                                           VersionTuple Introduced,
                                           VersionTuple Deprecated,
                                           VersionTuple Obsoleted,
                                           bool IsUnavailable,
                                           StringRef Message,
                                           bool IsStrict, StringRef Replacement,
                                           AvailabilityMergeKind AMK,
                                           unsigned AttrSpellingListIndex);
-  TypeVisibilityAttr *mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
-                                       TypeVisibilityAttr::VisibilityType Vis,
-                                              unsigned AttrSpellingListIndex);
+  TypeVisibilityAttr *
+  mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
+                          unsigned AttrSpellingListIndex, bool IsInherited);
   VisibilityAttr *mergeVisibilityAttr(Decl *D, SourceRange Range,
                                       VisibilityAttr::VisibilityType Vis,
-                                      unsigned AttrSpellingListIndex);
+                                      unsigned AttrSpellingListIndex,
+                                      bool IsInherited);
   UuidAttr *mergeUuidAttr(Decl *D, SourceRange Range,
                           unsigned AttrSpellingListIndex, StringRef Uuid);
   DLLImportAttr *mergeDLLImportAttr(Decl *D, SourceRange Range,
                                     unsigned AttrSpellingListIndex);
   DLLExportAttr *mergeDLLExportAttr(Decl *D, SourceRange Range,
                                     unsigned AttrSpellingListIndex);
   MSInheritanceAttr *
   mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase,
public:
   NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
                                       Scope *S);
   void AddKnownFunctionAttributes(FunctionDecl *FD);
 
   // More parsing and symbol table subroutines.
 
   void ProcessPragmaWeak(Scope *S, Decl *D);
   // Decl attributes - this routine is the top level dispatcher.
-  void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
+  void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
+                             bool IsInherited);
   // Helper for delayed processing of attributes.
   void ProcessDeclAttributeDelayed(Decl *D,
                                    const ParsedAttributesView &AttrList);
-  void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,
-                             bool IncludeCXX11Attributes = true);
+  void ProcessDeclAttributeList(Scope *S, Decl *D,
+                                const ParsedAttributesView &AL,
+                                bool IncludeCXX11Attributes /*=true*/,
+                                bool IsInherited);
   bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
-                                   const ParsedAttributesView &AttrList);
+                                      const ParsedAttributesView &AttrList,
+                                      bool IsInherited);
 
   void checkUnusedDeclAttributes(Declarator &D);
 
   /// Determine if type T is a valid subject for a nonnull and similar
   /// attributes. By default, we look through references (the behavior used by
   /// nonnull), but if the second parameter is true, then we treat a reference
   /// type as valid.
   bool isValidPointerAttrType(QualType T, bool RefOkay = false);

lib/Parse/ParseCXXInlineMethods.cpp

NamedDecl *Parser::ParseCXXInlineMethodDef(
   if (D.getDeclSpec().isFriendSpecified())
     FnD = Actions.ActOnFriendFunctionDecl(getCurScope(), D,
                                           TemplateParams);
   else {
     FnD = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, D,
                                            TemplateParams, nullptr,
                                            VS, ICIS_NoInit);
     if (FnD) {
-      Actions.ProcessDeclAttributeList(getCurScope(), FnD, AccessAttrs);
+      Actions.ProcessDeclAttributeList(getCurScope(), FnD, AccessAttrs, true,
+                                       false);
       if (PureSpecLoc.isValid())
         Actions.ActOnPureSpecifier(FnD, PureSpecLoc);
     }
   }
 
   if (FnD)
     HandleMemberFunctionDeclDelays(D, FnD);
 

lib/Parse/ParseDeclCXX.cpp

if (DS.isFriendSpecified()) {
 
       if (VarTemplateDecl *VT =
               ThisDecl ? dyn_cast<VarTemplateDecl>(ThisDecl) : nullptr)
         // Re-direct this decl to refer to the templated decl so that we can
         // initialize it.
         ThisDecl = VT->getTemplatedDecl();
 
       if (ThisDecl)
-        Actions.ProcessDeclAttributeList(getCurScope(), ThisDecl, AccessAttrs);
+        Actions.ProcessDeclAttributeList(getCurScope(), ThisDecl, AccessAttrs,
+                                         true, false);
     }
 
     // Error recovery might have converted a non-static member into a static
     // member.
     if (HasInClassInit != ICIS_NoInit &&
         DeclaratorInfo.getDeclSpec().getStorageClassSpec() ==
             DeclSpec::SCS_static) {
       HasInClassInit = ICIS_NoInit;

lib/Parse/ParseStmt.cpp

if (!SubStmt.isInvalid() && !SubStmt.isUsable())
     SubStmt = ParseStatement();
 
   // Broken substmt shouldn't prevent the label from being added to the AST.
   if (SubStmt.isInvalid())
     SubStmt = Actions.ActOnNullStmt(ColonLoc);
 
   LabelDecl *LD = Actions.LookupOrCreateLabel(IdentTok.getIdentifierInfo(),
                                               IdentTok.getLocation());
-  Actions.ProcessDeclAttributeList(Actions.CurScope, LD, attrs);
+  Actions.ProcessDeclAttributeList(Actions.CurScope, LD, attrs, true, false);
   attrs.clear();
 
   return Actions.ActOnLabelStmt(IdentTok.getLocation(), LD, ColonLoc,
                                 SubStmt.get());
 }
 
 /// ParseCaseStatement
 ///       labeled-statement:

lib/Sema/SemaAttr.cpp

for (const auto &Rule : Entry.MatchRules) {
       }
     }
     if (!Applies)
       continue;
     Entry.IsUsed = true;
     PragmaAttributeCurrentTargetDecl = D;
     ParsedAttributesView Attrs;
     Attrs.addAtEnd(Attribute);
-    ProcessDeclAttributeList(S, D, Attrs);
+    ProcessDeclAttributeList(S, D, Attrs, true, false);
     PragmaAttributeCurrentTargetDecl = nullptr;
   }
 }
 
 void Sema::PrintPragmaAttributeInstantiationPoint() {
   assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration");
   Diags.Report(PragmaAttributeCurrentTargetDecl->getLocStart(),
                diag::note_pragma_attribute_applied_decl_here);

lib/Sema/SemaDecl.cpp

if (OldAlignasAttr && !NewAlignasAttr &&
     AnyAdded = true;
   }
 
   return AnyAdded;
 }
 
 static bool mergeDeclAttribute(Sema &S, NamedDecl *D,
                                const InheritableAttr *Attr,
-                               Sema::AvailabilityMergeKind AMK) {
+                               Sema::AvailabilityMergeKind AMK,
+                               bool IsInherited) {
   // This function copies an attribute Attr from a previous declaration to the
   // new declaration D if the new declaration doesn't itself have that attribute
   // yet or if that attribute allows duplicates.
   // If you're adding a new attribute that requires logic different from
   // "use explicit attribute on decl if present, else use attribute from
   // previous decl", for example if the attribute needs to be consistent
   // between redeclarations, you need to call a custom merge function here.
   InheritableAttr *NewAttr = nullptr;
   unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
   if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
     NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
                                       AA->isImplicit(), AA->getIntroduced(),
                                       AA->getDeprecated(),
                                       AA->getObsoleted(), AA->getUnavailable(),
                                       AA->getMessage(), AA->getStrict(),
                                       AA->getReplacement(), AMK,
                                       AttrSpellingListIndex);
   else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
     NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
-                                    AttrSpellingListIndex);
+                                    AttrSpellingListIndex, IsInherited);
   else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
     NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
-                                        AttrSpellingListIndex);
+                                        AttrSpellingListIndex, IsInherited);
   else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
     NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
                                    AttrSpellingListIndex);
   else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
     NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
                                    AttrSpellingListIndex);
   else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
     NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
if (isa<DeprecatedAttr>(I) ||
         break;
       }
     }
 
     // Already handled.
     if (isa<UsedAttr>(I))
       continue;
 
-    if (mergeDeclAttribute(*this, New, I, LocalAMK))
+    if (mergeDeclAttribute(*this, New, I, LocalAMK, true))
       foundAny = true;
   }
 
   if (mergeAlignedAttrs(*this, New, Old))
     foundAny = true;
 
   if (!foundAny) New->dropAttrs();
 }
else
           << D.getName().getSourceRange();
     return nullptr;
   }
 
   TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
   if (!NewTD) return nullptr;
 
   // Handle attributes prior to checking for duplicates in MergeVarDecl
-  ProcessDeclAttributes(S, NewTD, D);
+  ProcessDeclAttributes(S, NewTD, D, false);
 
   CheckTypedefForVariablyModifiedType(S, NewTD);
 
   bool Redeclaration = D.isRedeclaration();
   NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
   D.setRedeclaration(Redeclaration);
   return ND;
 }
else {
       if (NewTemplate)
         NewTemplate->setModulePrivate();
       for (auto *B : Bindings)
         B->setModulePrivate();
     }
   }
 
   // Handle attributes prior to checking for duplicates in MergeVarDecl
-  ProcessDeclAttributes(S, NewVD, D);
+  ProcessDeclAttributes(S, NewVD, D, false);
 
   if (getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) {
     if (EmitTLSUnsupportedError &&
         ((getLangOpts().CUDA && DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) ||
          (getLangOpts().OpenMPIsDevice &&
           NewVD->hasAttr<OMPDeclareTargetDeclAttr>())))
       Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
            diag::err_thread_unsupported);
Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   if (!NewFD->hasAttr<CodeSegAttr>()) {
     if (Attr *SAttr = getImplicitCodeSegOrSectionAttrForFunction(NewFD,
                                                                  D.isFunctionDefinition())) {
       NewFD->addAttr(SAttr);
     }
   }
 
   // Handle attributes.
-  ProcessDeclAttributes(S, NewFD, D);
+  ProcessDeclAttributes(S, NewFD, D, false);
 
   if (getLangOpts().OpenCL) {
     // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
     // type declaration will generate a compilation error.
     LangAS AddressSpace = NewFD->getReturnType().getAddressSpace();
     if (AddressSpace != LangAS::Default) {
       Diag(NewFD->getLocation(),
            diag::err_opencl_return_value_with_address_space);
Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
   New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
                     S->getNextFunctionPrototypeIndex());
 
   // Add the parameter declaration into this scope.
   S->AddDecl(New);
   if (II)
     IdResolver.AddDecl(New);
 
-  ProcessDeclAttributes(S, New, D);
+  ProcessDeclAttributes(S, New, D, false);
 
   if (D.getDeclSpec().isModulePrivateSpecified())
     Diag(New->getLocation(), diag::err_module_private_local)
       << 1 << New->getDeclName()
       << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
       << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
 
   if (New->hasAttr<BlocksAttr>()) {

 
 /// When we finish delayed parsing of an attribute, we must attach it to the
 /// relevant Decl.
 void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D,
                                        ParsedAttributes &Attrs) {
   // Always attach attributes to the underlying decl.
   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
     D = TD->getTemplatedDecl();
-  ProcessDeclAttributeList(S, D, Attrs);
+  ProcessDeclAttributeList(S, D, Attrs, true, false);
 
   if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
     if (Method->isStatic())
       checkThisInStaticMemberFunctionAttributes(Method);
 }
 
 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
if (!Invalid && SearchDC->isRecord())
     SetMemberAccessSpecifier(New, PrevDecl, AS);
 
   if (PrevDecl)
     CheckRedeclarationModuleOwnership(New, PrevDecl);
 
   if (TUK == TUK_Definition)
     New->startDefinition();
 
-  ProcessDeclAttributeList(S, New, Attrs);
+  ProcessDeclAttributeList(S, New, Attrs, true, false);
   AddPragmaAttributes(S, New);
 
   // If this has an identifier, add it to the scope stack.
   if (TUK == TUK_Friend) {
     // We might be replacing an existing declaration in the lookup tables;
     // if so, borrow its access specifier.
     if (PrevDecl)
       New->setAccess(PrevDecl->getAccess());
if (Record->isUnion()) {
       }
     }
   }
 
   // FIXME: We need to pass in the attributes given an AST
   // representation, not a parser representation.
   if (D) {
     // FIXME: The current scope is almost... but not entirely... correct here.
-    ProcessDeclAttributes(getCurScope(), NewFD, *D);
+    ProcessDeclAttributes(getCurScope(), NewFD, *D, false);
 
     if (NewFD->hasAttrs())
       CheckAlignasUnderalignment(NewFD);
   }
 
   // In auto-retain/release, infer strong retension for fields of
   // retainable type.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
         && !isa<TagDecl>(PrevDecl)) {
       Diag(Loc, diag::err_duplicate_member) << II;
       Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
       NewID->setInvalidDecl();
     }
   }
 
   // Process attributes attached to the ivar.
-  ProcessDeclAttributes(S, NewID, D);
+  ProcessDeclAttributes(S, NewID, D, false);
 
   if (D.isInvalidType())
     NewID->setInvalidDecl();
 
   // In ARC, infer 'retaining' for ivars of retainable type.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
     NewID->setInvalidDecl();
 
if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
         }
       }
     }
 
     if (!Completed)
       Record->completeDefinition();
 
     // Handle attributes before checking the layout.
-    ProcessDeclAttributeList(S, Record, Attrs);
+    ProcessDeclAttributeList(S, Record, Attrs, true, false);
 
     // We may have deferred checking for a deleted destructor. Check now.
     if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
       auto *Dtor = CXXRecord->getDestructor();
       if (Dtor && Dtor->isImplicit() &&
           ShouldDeleteSpecialMember(Dtor, CXXDestructor)) {
         CXXRecord->setImplicitDestructorIsDeleted();
         SetDeclDeleted(Dtor, CXXRecord->getLocation());
if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
       else
         Diag(IdLoc, diag::err_redefinition) << Id;
       notePreviousDefinition(PrevDecl, IdLoc);
       return nullptr;
     }
   }
 
   // Process attributes.
-  ProcessDeclAttributeList(S, New, Attrs);
+  ProcessDeclAttributeList(S, New, Attrs, true, false);
   AddPragmaAttributes(S, New);
 
   // Register this decl in the current scope stack.
   New->setAccess(TheEnumDecl->getAccess());
   PushOnScopeChains(New, S);
 
   ActOnDocumentableDecl(New);
 

 }
 
 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
                          Decl *EnumDeclX, ArrayRef<Decl *> Elements, Scope *S,
                          const ParsedAttributesView &Attrs) {
   EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
   QualType EnumType = Context.getTypeDeclType(Enum);
 
-  ProcessDeclAttributeList(S, Enum, Attrs);
+  ProcessDeclAttributeList(S, Enum, Attrs, true, false);
 
   if (Enum->isDependentType()) {
     for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
       EnumConstantDecl *ECD =
         cast_or_null<EnumConstantDecl>(Elements[i]);
       if (!ECD) continue;
 
       ECD->setType(EnumType);

lib/Sema/SemaDeclAttr.cpp

static bool normalizeName(StringRef &AttrName) {
   if (AttrName.size() > 4 && AttrName.startswith("__") &&
       AttrName.endswith("__")) {
     AttrName = AttrName.drop_front(2).drop_back(2);
     return true;
   }
   return false;
 }
 
-static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL,
+                                bool IsInherited) {
   // This attribute must be applied to a function declaration. The first
   // argument to the attribute must be an identifier, the name of the resource,
   // for example: malloc. The following arguments must be argument indexes, the
   // arguments must be of integer type for Returns, otherwise of pointer type.
   // The difference between Holds and Takes is that a pointer may still be used
   // after being held. free() should be __attribute((ownership_takes)), whereas
   // a list append function may well be __attribute((ownership_holds)).
 
for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
         S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
           << AL.getName() << I;
         return;
       } else if (K == OwnershipAttr::Returns &&
                  I->getOwnKind() == OwnershipAttr::Returns) {
         // A returns attribute conflicts with any other returns attribute using
         // a different index.
         if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) {
-          S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
+          S.Diag(IsInherited ? I->getLocation() : AL.getLoc(),
+                 diag::err_ownership_returns_index_mismatch)
               << I->args_begin()->getSourceIndex();
           if (I->args_size())
-            S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
+            S.Diag(IsInherited ? AL.getLoc() : I->getLocation(),
+                   diag::note_ownership_returns_index_mismatch)
                 << Idx.getSourceIndex() << Ex->getSourceRange();
           return;
         }
       }
     }
     OwnershipArgs.push_back(Idx);
   }
 
static void handleExternalSourceSymbolAttr(Sema &S, Decl *D,
   D->addAttr(::new (S.Context) ExternalSourceSymbolAttr(
       AL.getRange(), S.Context, Language, DefinedIn, IsGeneratedDeclaration,
       AL.getAttributeSpellingListIndex()));
 }
 
 template <class T>
 static T *mergeVisibilityAttr(Sema &S, Decl *D, SourceRange range,
                               typename T::VisibilityType value,
-                              unsigned attrSpellingListIndex) {
+                              unsigned attrSpellingListIndex,
+                              bool IsInherited) {
   T *existingAttr = D->getAttr<T>();
   if (existingAttr) {
     typename T::VisibilityType existingValue = existingAttr->getVisibility();
     if (existingValue == value)
       return nullptr;
-    S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
-    S.Diag(range.getBegin(), diag::note_previous_attribute);
+    S.Diag(IsInherited ? existingAttr->getLocation() : range.getBegin(),
+           diag::err_mismatched_visibility);
+    S.Diag(IsInherited ? range.getBegin() : existingAttr->getLocation(),
+           diag::note_previous_attribute);
+    // S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
+    // S.Diag(range.getBegin(), diag::note_previous_attribute);
     D->dropAttr<T>();
   }
   return ::new (S.Context) T(range, S.Context, value, attrSpellingListIndex);
 }
 
 VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
                                           VisibilityAttr::VisibilityType Vis,
-                                          unsigned AttrSpellingListIndex) {
-  return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, Range, Vis,
-                                               AttrSpellingListIndex);
+                                          unsigned AttrSpellingListIndex,
+                                          bool IsInherited) {
+  return ::mergeVisibilityAttr<VisibilityAttr>(
+      *this, D, Range, Vis, AttrSpellingListIndex, IsInherited);
 }
 
-TypeVisibilityAttr *Sema::mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
-                                      TypeVisibilityAttr::VisibilityType Vis,
-                                      unsigned AttrSpellingListIndex) {
-  return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, Range, Vis,
-                                                   AttrSpellingListIndex);
+TypeVisibilityAttr *Sema::mergeTypeVisibilityAttr(
+    Decl *D, SourceRange Range, TypeVisibilityAttr::VisibilityType Vis,
+    unsigned AttrSpellingListIndex, bool IsInherited) {
+  return ::mergeVisibilityAttr<TypeVisibilityAttr>(
+      *this, D, Range, Vis, AttrSpellingListIndex, IsInherited);
 }
 
 static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL,
-                                 bool isTypeVisibility) {
+                                 bool isTypeVisibility, bool IsInherited) {
   // Visibility attributes don't mean anything on a typedef.
   if (isa<TypedefNameDecl>(D)) {
     S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored)
       << AL.getName();
     return;
   }
 
   // 'type_visibility' can only go on a type or namespace.
if (type == VisibilityAttr::Protected &&
       !S.Context.getTargetInfo().hasProtectedVisibility()) {
     S.Diag(AL.getLoc(), diag::warn_attribute_protected_visibility);
     type = VisibilityAttr::Default;
   }
 
   unsigned Index = AL.getAttributeSpellingListIndex();
   Attr *newAttr;
   if (isTypeVisibility) {
-    newAttr = S.mergeTypeVisibilityAttr(D, AL.getRange(),
-                                    (TypeVisibilityAttr::VisibilityType) type,
-                                        Index);
+    newAttr = S.mergeTypeVisibilityAttr(
+        D, AL.getRange(), (TypeVisibilityAttr::VisibilityType)type, Index,
+        IsInherited);
   } else {
-    newAttr = S.mergeVisibilityAttr(D, AL.getRange(), type, Index);
+    newAttr = S.mergeVisibilityAttr(D, AL.getRange(), type, Index, IsInherited);
   }
   if (newAttr)
     D->addAttr(newAttr);
 }
 
 static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   const auto *M = cast<ObjCMethodDecl>(D);
   if (!AL.isArgIdent(0)) {

 // Top Level Sema Entry Points
 //===----------------------------------------------------------------------===//
 
 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
 /// the attribute applies to decls.  If the attribute is a type attribute, just
 /// silently ignore it if a GNU attribute.
 static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
                                  const ParsedAttr &AL,
-                                 bool IncludeCXX11Attributes) {
+                                 bool IncludeCXX11Attributes,
+                                 bool IsInherited) {
   if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
     return;
 
   // Ignore C++11 attributes on declarator chunks: they appertain to the type
   // instead.
   if (AL.isCXX11Attribute() && !IncludeCXX11Attributes)
     return;
 
case ParsedAttr::AT_AssumeAligned:
     break;
   case ParsedAttr::AT_AllocAlign:
     handleAllocAlignAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Overloadable:
     handleSimpleAttribute<OverloadableAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_Ownership:
-    handleOwnershipAttr(S, D, AL);
+    handleOwnershipAttr(S, D, AL, IsInherited);
     break;
   case ParsedAttr::AT_Cold:
     handleSimpleAttributeWithExclusions<ColdAttr, HotAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_Hot:
     handleSimpleAttributeWithExclusions<HotAttr, ColdAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_Naked:
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_DisableTailCalls:
     handleSimpleAttributeWithExclusions<DisableTailCallsAttr, NakedAttr>(S, D,
                                                                          AL);
     break;
   case ParsedAttr::AT_Used:
     handleSimpleAttribute<UsedAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_Visibility:
-    handleVisibilityAttr(S, D, AL, false);
+    handleVisibilityAttr(S, D, AL, false, IsInherited);
     break;
   case ParsedAttr::AT_TypeVisibility:
-    handleVisibilityAttr(S, D, AL, true);
+    handleVisibilityAttr(S, D, AL, true, IsInherited);
     break;
   case ParsedAttr::AT_WarnUnused:
     handleSimpleAttribute<WarnUnusedAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_WarnUnusedResult:
     handleWarnUnusedResult(S, D, AL);
     break;
   case ParsedAttr::AT_Weak:
case ParsedAttr::AT_XRayLogArgs:
     break;
   }
 }
 
 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
 /// attribute list to the specified decl, ignoring any type attributes.
 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
                                     const ParsedAttributesView &AttrList,
-                                    bool IncludeCXX11Attributes) {
+                                    bool IncludeCXX11Attributes,
+                                    bool IsInherited) {
   if (AttrList.empty())
     return;
 
   for (const ParsedAttr &AL : AttrList)
-    ProcessDeclAttribute(*this, S, D, AL, IncludeCXX11Attributes);
+    ProcessDeclAttribute(*this, S, D, AL, IncludeCXX11Attributes, IsInherited);
 
   // FIXME: We should be able to handle these cases in TableGen.
   // GCC accepts
   // static int a9 __attribute__((weakref));
   // but that looks really pointless. We reject it.
   if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
     Diag(AttrList.begin()->getLoc(), diag::err_attribute_weakref_without_alias)
         << cast<NamedDecl>(D);
for (const ParsedAttr &AL : AttrList)
     if (AL.getKind() == ParsedAttr::AT_TransparentUnion) {
       handleTransparentUnionAttr(*this, D, AL);
       break;
     }
 }
 
 // Annotation attributes are the only attributes allowed after an access
 // specifier.
-bool Sema::ProcessAccessDeclAttributeList(
-    AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList) {
+bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
+                                          const ParsedAttributesView &AttrList,
+                                          bool IsInherited) {
   for (const ParsedAttr &AL : AttrList) {
     if (AL.getKind() == ParsedAttr::AT_Annotate) {
-      ProcessDeclAttribute(*this, nullptr, ASDecl, AL, AL.isCXX11Attribute());
+      ProcessDeclAttribute(*this, nullptr, ASDecl, AL, AL.isCXX11Attribute(),
+                           IsInherited);
     } else {
       Diag(AL.getLoc(), diag::err_only_annotate_after_access_spec);
       return true;
     }
   }
   return false;
 }
 
if (ND) {
       }
     }
   }
 }
 
 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
 /// it, apply them to D.  This is a bit tricky because PD can have attributes
 /// specified in many different places, and we need to find and apply them all.
-void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
+void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
+                                 bool IsInherited) {
   // Apply decl attributes from the DeclSpec if present.
   if (!PD.getDeclSpec().getAttributes().empty())
-    ProcessDeclAttributeList(S, D, PD.getDeclSpec().getAttributes());
+    ProcessDeclAttributeList(S, D, PD.getDeclSpec().getAttributes(),
+                             IsInherited, false);
 
   // Walk the declarator structure, applying decl attributes that were in a type
   // position to the decl itself.  This handles cases like:
   //   int *__attr__(x)** D;
   // when X is a decl attribute.
   for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
     ProcessDeclAttributeList(S, D, PD.getTypeObject(i).getAttrs(),
-                             /*IncludeCXX11Attributes=*/false);
+                             /*IncludeCXX11Attributes=*/false, IsInherited);
 
   // Finally, apply any attributes on the decl itself.
-  ProcessDeclAttributeList(S, D, PD.getAttributes());
+  ProcessDeclAttributeList(S, D, PD.getAttributes(), true, IsInherited);
 
   // Apply additional attributes specified by '#pragma clang attribute'.
   AddPragmaAttributes(S, D);
 }
 
 /// Is the given declaration allowed to use a forbidden type?
 /// If so, it'll still be annotated with an attribute that makes it
 /// illegal to actually use.

lib/Sema/SemaDeclCXX.cpp

 /// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
 bool Sema::ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc,
                                 SourceLocation ColonLoc,
                                 const ParsedAttributesView &Attrs) {
   assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
   AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
                                                   ASLoc, ColonLoc);
   CurContext->addHiddenDecl(ASDecl);
-  return ProcessAccessDeclAttributeList(ASDecl, Attrs);
+  return ProcessAccessDeclAttributeList(ASDecl, Attrs, false);
 }
 
 /// CheckOverrideControl - Check C++11 override control semantics.
 void Sema::CheckOverrideControl(NamedDecl *D) {
   if (D->isInvalidDecl())
     return;
 
   // We only care about "override" and "final" declarations.
if (PrevNS && IsInline != PrevNS->isInline())
                                       &IsInline, PrevNS);
   }
 
   NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
                                                  StartLoc, Loc, II, PrevNS);
   if (IsInvalid)
     Namespc->setInvalidDecl();
 
-  ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
+  ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList, true, false);
   AddPragmaAttributes(DeclRegionScope, Namespc);
 
   // FIXME: Should we be merging attributes?
   if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
     PushNamespaceVisibilityAttr(Attr, Loc);
 
   if (IsStd)
     StdNamespace = Namespc;
if (!R.empty()) {
     }
 
     PushUsingDirective(S, UDir);
   } else {
     Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
   }
 
   if (UDir)
-    ProcessDeclAttributeList(S, UDir, AttrList);
+    ProcessDeclAttributeList(S, UDir, AttrList, true, false);
 
   return UDir;
 }
 
 void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
   // If the scope has an associated entity and the using directive is at
   // namespace or translation unit scope, add the UsingDirectiveDecl into
   // its lookup structure so qualified name lookup can find it.
TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
                                                Name.StartLocation,
                                                Name.Identifier, TInfo);
 
   NewTD->setAccess(AS);
 
   if (Invalid)
     NewTD->setInvalidDecl();
 
-  ProcessDeclAttributeList(S, NewTD, AttrList);
+  ProcessDeclAttributeList(S, NewTD, AttrList, true, false);
   AddPragmaAttributes(S, NewTD);
 
   CheckTypedefForVariablyModifiedType(S, NewTD);
   Invalid |= NewTD->isInvalidDecl();
 
   bool Redeclaration = false;
 
   NamedDecl *NewND;

 }
 
 Decl *Sema::ActOnEmptyDeclaration(Scope *S,
                                   const ParsedAttributesView &AttrList,
                                   SourceLocation SemiLoc) {
   Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
   // Attribute declarations appertain to empty declaration so we handle
   // them here.
-  ProcessDeclAttributeList(S, ED, AttrList);
+  ProcessDeclAttributeList(S, ED, AttrList, true, false);
 
   CurContext->addDecl(ED);
   return ED;
 }
 
 /// Perform semantic analysis for the variable declaration that
 /// occurs within a C++ catch clause, returning the newly-created
 /// variable.
if (Invalid)
     ExDecl->setInvalidDecl();
 
   // Add the exception declaration into this scope.
   if (II)
     PushOnScopeChains(ExDecl, S);
   else
     CurContext->addDecl(ExDecl);
 
-  ProcessDeclAttributes(S, ExDecl, D);
+  ProcessDeclAttributes(S, ExDecl, D, false);
   return ExDecl;
 }
 
 Decl *Sema::ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
                                          Expr *AssertExpr,
                                          Expr *AssertMessageExpr,
                                          SourceLocation RParenLoc) {
   StringLiteral *AssertMessage =
MSPropertyDecl *Sema::HandleMSProperty(Scope *S, RecordDecl *Record,
 
   if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
     PrevDecl = nullptr;
 
   SourceLocation TSSL = D.getLocStart();
   const ParsedAttr::PropertyData &Data = MSPropertyAttr.getPropertyData();
   MSPropertyDecl *NewPD = MSPropertyDecl::Create(
       Context, Record, Loc, II, T, TInfo, TSSL, Data.GetterId, Data.SetterId);
-  ProcessDeclAttributes(TUScope, NewPD, D);
+  ProcessDeclAttributes(TUScope, NewPD, D, false);
   NewPD->setAccess(AS);
 
   if (NewPD->isInvalidDecl())
     Record->setInvalidDecl();
 
   if (D.getDeclSpec().isModulePrivateSpecified())
     NewPD->setModulePrivate();
 

lib/Sema/SemaDeclObjC.cpp

if (PrevIDecl) {
     if (ObjCInterfaceDecl *Def = PrevIDecl->getDefinition()) {
       Diag(AtInterfaceLoc, diag::err_duplicate_class_def)
         << PrevIDecl->getDeclName();
       Diag(Def->getLocation(), diag::note_previous_definition);
       IDecl->setInvalidDecl();
     }
   }
 
-  ProcessDeclAttributeList(TUScope, IDecl, AttrList);
+  ProcessDeclAttributeList(TUScope, IDecl, AttrList, true, false);
   AddPragmaAttributes(TUScope, IDecl);
   PushOnScopeChains(IDecl, TUScope);
 
   // Start the definition of this class. If we're in a redefinition case, there
   // may already be a definition, so we'll end up adding to it.
   if (!IDecl->hasDefinition())
     IDecl->startDefinition();
 
if (ObjCProtocolDecl *Def = PrevDecl? PrevDecl->getDefinition() : nullptr) {
     PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
                                      ProtocolLoc, AtProtoInterfaceLoc,
                                      /*PrevDecl=*/PrevDecl);
 
     PushOnScopeChains(PDecl, TUScope);
     PDecl->startDefinition();
   }
 
-  ProcessDeclAttributeList(TUScope, PDecl, AttrList);
+  ProcessDeclAttributeList(TUScope, PDecl, AttrList, true, false);
   AddPragmaAttributes(TUScope, PDecl);
 
   // Merge attributes from previous declarations.
   if (PrevDecl)
     mergeDeclAttributes(PDecl, PrevDecl);
 
   if (!err && NumProtoRefs ) {
     /// Check then save referenced protocols.
for (const IdentifierLocPair &IdentPair : IdentList) {
     ObjCProtocolDecl *PDecl
       = ObjCProtocolDecl::Create(Context, CurContext, Ident,
                                  IdentPair.second, AtProtocolLoc,
                                  PrevDecl);
 
     PushOnScopeChains(PDecl, TUScope);
     CheckObjCDeclScope(PDecl);
 
-    ProcessDeclAttributeList(TUScope, PDecl, attrList);
+    ProcessDeclAttributeList(TUScope, PDecl, attrList, true, false);
     AddPragmaAttributes(TUScope, PDecl);
 
     if (PrevDecl)
       mergeDeclAttributes(PDecl, PrevDecl);
 
     DeclsInGroup.push_back(PDecl);
   }
 
CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
                                    ClassLoc, CategoryLoc, CategoryName, IDecl,
                                    typeParamList);
   // FIXME: PushOnScopeChains?
   CurContext->addDecl(CDecl);
 
   // Process the attributes before looking at protocols to ensure that the
   // availability attribute is attached to the category to provide availability
   // checking for protocol uses.
-  ProcessDeclAttributeList(TUScope, CDecl, AttrList);
+  ProcessDeclAttributeList(TUScope, CDecl, AttrList, true, false);
   AddPragmaAttributes(TUScope, CDecl);
 
   if (NumProtoRefs) {
     diagnoseUseOfProtocols(*this, CDecl, (ObjCProtocolDecl*const*)ProtoRefs,
                            NumProtoRefs, ProtoLocs);
     CDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
                            ProtoLocs, Context);
     // Protocols in the class extension belong to the class.
ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
                                         ArgType, DI, SC_None);
 
     Param->setObjCMethodScopeInfo(i);
 
     Param->setObjCDeclQualifier(
       CvtQTToAstBitMask(ArgInfo[i].DeclSpec.getObjCDeclQualifier()));
 
     // Apply the attributes to the parameter.
-    ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs);
+    ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs, true, false);
     AddPragmaAttributes(TUScope, Param);
 
     if (Param->hasAttr<BlocksAttr>()) {
       Diag(Param->getLocation(), diag::err_block_on_nonlocal);
       Param->setInvalidDecl();
     }
     S->AddDecl(Param);
     IdResolver.AddDecl(Param);
for (unsigned i = 0, e = CNumArgs; i != e; ++i) {
     Param->setDeclContext(ObjCMethod);
     Params.push_back(Param);
   }
 
   ObjCMethod->setMethodParams(Context, Params, SelectorLocs);
   ObjCMethod->setObjCDeclQualifier(
     CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier()));
 
-  ProcessDeclAttributeList(TUScope, ObjCMethod, AttrList);
+  ProcessDeclAttributeList(TUScope, ObjCMethod, AttrList, true, false);
   AddPragmaAttributes(TUScope, ObjCMethod);
 
   // Add the method now.
   const ObjCMethodDecl *PrevMethod = nullptr;
   if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
     if (MethodType == tok::minus) {
       PrevMethod = ImpDecl->getInstanceMethod(Sel);
       ImpDecl->addInstanceMethod(ObjCMethod);
if (D.getCXXScopeSpec().isSet()) {
     New->setInvalidDecl();
   }
 
   // Add the parameter declaration into this scope.
   S->AddDecl(New);
   if (D.getIdentifier())
     IdResolver.AddDecl(New);
 
-  ProcessDeclAttributes(S, New, D);
+  ProcessDeclAttributes(S, New, D, false);
 
   if (New->hasAttr<BlocksAttr>())
     Diag(New->getLocation(), diag::err_block_on_nonlocal);
   return New;
 }
 
 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
 /// initialization.

lib/Sema/SemaExpr.cpp

void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
   // Set the parameters on the block decl.
   if (!Params.empty()) {
     CurBlock->TheDecl->setParams(Params);
     CheckParmsForFunctionDef(CurBlock->TheDecl->parameters(),
                              /*CheckParameterNames=*/false);
   }
 
   // Finally we can process decl attributes.
-  ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
+  ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo, false);
 
   // Put the parameter variables in scope.
   for (auto AI : CurBlock->TheDecl->parameters()) {
     AI->setOwningFunction(CurBlock->TheDecl);
 
     // If this has an identifier, add it to the scope stack.
     if (AI->getIdentifier()) {
       CheckShadow(CurBlock->TheScope, AI);

lib/Sema/SemaLambda.cpp

void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
   // have to apply optnone due to a pragma.
   AddRangeBasedOptnone(Method);
 
   // code_seg attribute on lambda apply to the method.
   if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))
     Method->addAttr(A);
 
   // Attributes on the lambda apply to the method.
-  ProcessDeclAttributes(CurScope, Method, ParamInfo);
+  ProcessDeclAttributes(CurScope, Method, ParamInfo, false);
 
   // CUDA lambdas get implicit attributes based on the scope in which they're
   // declared.
   if (getLangOpts().CUDA)
     CUDASetLambdaAttrs(Method);
 
   // Introduce the function call operator as the current declaration context.
   PushDeclContext(CurScope, Method);

lib/Sema/SemaObjCProperty.cpp

if (lexicalDC)
       PDecl->setLexicalDeclContext(lexicalDC);
   }
 
   if (T->isArrayType() || T->isFunctionType()) {
     Diag(AtLoc, diag::err_property_type) << T;
     PDecl->setInvalidDecl();
   }
 
-  ProcessDeclAttributes(S, PDecl, FD.D);
+  ProcessDeclAttributes(S, PDecl, FD.D, false);
 
   // Regardless of setter/getter attribute, we save the default getter/setter
   // selector names in anticipation of declaration of setter/getter methods.
   PDecl->setGetterName(GetterSel, GetterNameLoc);
   PDecl->setSetterName(SetterSel, SetterNameLoc);
   PDecl->setPropertyAttributesAsWritten(
                           makePropertyAttributesAsWritten(AttributesAsWritten));
 

lib/Sema/SemaTemplate.cpp

DeclResult Sema::CheckClassTemplate(
 
   // Set the lexical context of these templates
   NewClass->setLexicalDeclContext(CurContext);
   NewTemplate->setLexicalDeclContext(CurContext);
 
   if (TUK == TUK_Definition)
     NewClass->startDefinition();
 
-  ProcessDeclAttributeList(S, NewClass, Attr);
+  ProcessDeclAttributeList(S, NewClass, Attr, true, false);
 
   if (PrevClassTemplate)
     mergeDeclAttributes(NewClass, PrevClassTemplate->getTemplatedDecl());
 
   AddPushedVisibilityAttribute(NewClass);
 
   if (TUK != TUK_Friend) {
     // Per C++ [basic.scope.temp]p2, skip the template parameter scopes.
if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
       SourceRange Range(TemplateNameLoc, RAngleLoc);
       Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;
       Diag(Def->getLocation(), diag::note_previous_definition);
       Specialization->setInvalidDecl();
       return true;
     }
   }
 
-  ProcessDeclAttributeList(S, Specialization, Attr);
+  ProcessDeclAttributeList(S, Specialization, Attr, true, false);
 
   // Add alignment attributes if necessary; these attributes are checked when
   // the ASTContext lays out the structure.
   if (TUK == TUK_Definition) {
     AddAlignmentAttributesForRecord(Specialization);
     AddMsStructLayoutForRecord(Specialization);
   }
 
DeclResult Sema::ActOnExplicitInstantiation(
   Specialization->setTypeAsWritten(WrittenTy);
 
   // Set source locations for keywords.
   Specialization->setExternLoc(ExternLoc);
   Specialization->setTemplateKeywordLoc(TemplateLoc);
   Specialization->setBraceRange(SourceRange());
 
   bool PreviouslyDLLExported = Specialization->hasAttr<DLLExportAttr>();
-  ProcessDeclAttributeList(S, Specialization, Attr);
+  ProcessDeclAttributeList(S, Specialization, Attr, true, false);
 
   // Add the explicit instantiation into its lexical context. However,
   // since explicit instantiations are never found by name lookup, we
   // just put it into the declaration context directly.
   Specialization->setLexicalDeclContext(CurContext);
   CurContext->addDecl(Specialization);
 
   // Syntax is now OK, so return if it has no other effect on semantics.
if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
                                                PrevTSK, POI, HasNoEffect))
       return true;
 
     if (!HasNoEffect) {
       // Instantiate static data member or variable template.
       Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
       if (PrevTemplate) {
         // Merge attributes.
-        ProcessDeclAttributeList(S, Prev, D.getDeclSpec().getAttributes());
+        ProcessDeclAttributeList(S, Prev, D.getDeclSpec().getAttributes(), true,
+                                 false);
       }
       if (TSK == TSK_ExplicitInstantiationDefinition)
         InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
     }
 
     // Check the new variable specialization against the parsed input.
     if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
       Diag(T->getTypeLoc().getLocStart(),
if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
       return true;
 
     // FIXME: We may still want to build some representation of this
     // explicit specialization.
     if (HasNoEffect)
       return (Decl*) nullptr;
   }
 
-  ProcessDeclAttributeList(S, Specialization, D.getDeclSpec().getAttributes());
+  ProcessDeclAttributeList(S, Specialization, D.getDeclSpec().getAttributes(),
+                           true, false);
 
   // In MSVC mode, dllimported explicit instantiation definitions are treated as
   // instantiation declarations.
   if (TSK == TSK_ExplicitInstantiationDefinition &&
       Specialization->hasAttr<DLLImportAttr>() &&
       Context.getTargetInfo().getCXXABI().isMicrosoft())
     TSK = TSK_ExplicitInstantiationDeclaration;