Undo changes to inferLifetimeBoundAttribute and use mergeParamDeclAttributes instead

Author: higher-performance

clang/lib/Sema/SemaAttr.cpp

@@ -217,8 +217,7 @@ void Sema::inferGslOwnerPointerAttribute(CXXRecordDecl *Record) {
 }
 
 void Sema::inferLifetimeBoundAttribute(FunctionDecl *FD) {
-  unsigned NumParams = FD->getNumParams();
-  if (NumParams == 0)
+  if (FD->getNumParams() == 0)
     return;
 
   if (unsigned BuiltinID = FD->getBuiltinID()) {
@@ -240,13 +239,18 @@ void Sema::inferLifetimeBoundAttribute(FunctionDecl *FD) {
     default:
       break;
     }
-  } else if (auto *CMD = dyn_cast<CXXMethodDecl>(FD)) {
-    const CXXRecordDecl *CRD = CMD->getParent();
-    if (CRD->isInStdNamespace() && CRD->getIdentifier() &&
-        isa<CXXConstructorDecl>(CMD)) {
+    return;
+  }
+  if (auto *CMD = dyn_cast<CXXMethodDecl>(FD)) {
+    const auto *CRD = CMD->getParent();
+    if (!CRD->isInStdNamespace() || !CRD->getIdentifier())
+      return;
+
+    if (isa<CXXConstructorDecl>(CMD)) {
       auto *Param = CMD->getParamDecl(0);
-      if (!Param->hasAttr<LifetimeBoundAttr>() &&
-          CRD->getName() == "basic_string_view" &&
+      if (Param->hasAttr<LifetimeBoundAttr>())
+        return;
+      if (CRD->getName() == "basic_string_view" &&
           Param->getType()->isPointerType()) {
         // construct from a char array pointed by a pointer.
         //   basic_string_view(const CharT* s);
@@ -262,20 +266,6 @@ void Sema::inferLifetimeBoundAttribute(FunctionDecl *FD) {
               LifetimeBoundAttr::CreateImplicit(Context, FD->getLocation()));
       }
     }
-  } else if (auto *CanonDecl = FD->getCanonicalDecl(); FD != CanonDecl) {
-    // Propagate the lifetimebound attribute from parameters to the canonical
-    // declaration.
-    // Note that this doesn't include the implicit 'this' parameter, as the
-    // attribute is applied to the function type in that case.
-    unsigned NP = std::min(NumParams, CanonDecl->getNumParams());
-    for (unsigned I = 0; I < NP; ++I) {
-      auto *CanonParam = CanonDecl->getParamDecl(I);
-      if (!CanonParam->hasAttr<LifetimeBoundAttr>() &&
-          FD->getParamDecl(I)->hasAttr<LifetimeBoundAttr>()) {
-        CanonParam->addAttr(LifetimeBoundAttr::CreateImplicit(
-            Context, CanonParam->getLocation()));
-      }
-    }
   }
 }
 

clang/lib/Sema/SemaDecl.cpp

@@ -3227,10 +3227,44 @@ void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
   if (!foundAny) New->dropAttrs();
 }
 
+template <class T>
+static unsigned propagateAttribute(ParmVarDecl *toDecl,
+                                   const ParmVarDecl *fromDecl, Sema &S) {
+  unsigned found = 0;
+  for (const auto *I : fromDecl->specific_attrs<T>()) {
+    if (!DeclHasAttr(toDecl, I)) {
+      T *newAttr = cast<T>(I->clone(S.Context));
+      newAttr->setInherited(true);
+      toDecl->addAttr(newAttr);
+      ++found;
+    }
+  }
+  return found;
+}
+
+template <class F>
+static void propagateAttributes(ParmVarDecl *toDecl,
+                                const ParmVarDecl *fromDecl, F &&propagator) {
+  if (!fromDecl->hasAttrs()) {
+    return;
+  }
+
+  bool foundAny = toDecl->hasAttrs();
+
+  // Ensure that any moving of objects within the allocated map is
+  // done before we process them.
+  if (!foundAny)
+    toDecl->setAttrs(AttrVec());
+
+  foundAny |= std::forward<F>(propagator)(toDecl, fromDecl) != 0;
+
+  if (!foundAny)
+    toDecl->dropAttrs();
+}
+
 /// mergeParamDeclAttributes - Copy attributes from the old parameter
 /// to the new one.
-static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
-                                     const ParmVarDecl *oldDecl,
+static void mergeParamDeclAttributes(ParmVarDecl *newDecl, ParmVarDecl *oldDecl,
                                      Sema &S) {
   // C++11 [dcl.attr.depend]p2:
   //   The first declaration of a function shall specify the
@@ -3250,26 +3284,25 @@ static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
            diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
   }
 
-  if (!oldDecl->hasAttrs())
-    return;
-
-  bool foundAny = newDecl->hasAttrs();
-
-  // Ensure that any moving of objects within the allocated map is
-  // done before we process them.
-  if (!foundAny) newDecl->setAttrs(AttrVec());
-
-  for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
-    if (!DeclHasAttr(newDecl, I)) {
-      InheritableAttr *newAttr =
-        cast<InheritableParamAttr>(I->clone(S.Context));
-      newAttr->setInherited(true);
-      newDecl->addAttr(newAttr);
-      foundAny = true;
-    }
-  }
+  // Forward propagation (from old parameter to new)
+  propagateAttributes(
+      newDecl, oldDecl, [&S](ParmVarDecl *toDecl, const ParmVarDecl *fromDecl) {
+        unsigned found = 0;
+        found += propagateAttribute<InheritableParamAttr>(toDecl, fromDecl, S);
+        return found;
+      });
 
-  if (!foundAny) newDecl->dropAttrs();
+  // Backward propagation (from new parameter to old)
+  propagateAttributes(
+      oldDecl, newDecl, [&S](ParmVarDecl *toDecl, const ParmVarDecl *fromDecl) {
+        unsigned found = 0;
+        // Propagate the lifetimebound attribute from parameters to the
+        // canonical declaration. Note that this doesn't include the implicit
+        // 'this' parameter, as the attribute is applied to the function type in
+        // that case.
+        found += propagateAttribute<LifetimeBoundAttr>(toDecl, fromDecl, S);
+        return found;
+      });
 }
 
 static bool EquivalentArrayTypes(QualType Old, QualType New,
@@ -4323,8 +4356,8 @@ void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
   mergeDeclAttributes(newMethod, oldMethod, MergeKind);
 
   // Merge attributes from the parameters.
-  ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(),
-                                       oe = oldMethod->param_end();
+  ObjCMethodDecl::param_iterator oi = oldMethod->param_begin(),
+                                 oe = oldMethod->param_end();
   for (ObjCMethodDecl::param_iterator
          ni = newMethod->param_begin(), ne = newMethod->param_end();
        ni != ne && oi != oe; ++ni, ++oi)