[NFC] Rename ExtraFunctionInfo and update comments

Author: Sirraide

clang/include/clang/AST/Decl.h

@@ -1982,8 +1982,8 @@ class FunctionDecl : public DeclaratorDecl,
   };
 
   /// Stashed information about a defaulted/deleted function body.
-  class ExtraFunctionInfo final
-      : llvm::TrailingObjects<ExtraFunctionInfo, DeclAccessPair,
+  class DefaultedOrDeletedFunctionInfo final
+      : llvm::TrailingObjects<DefaultedOrDeletedFunctionInfo, DeclAccessPair,
                               StringLiteral *> {
     friend TrailingObjects;
     unsigned NumLookups;
@@ -1994,9 +1994,9 @@ class FunctionDecl : public DeclaratorDecl,
     }
 
   public:
-    static ExtraFunctionInfo *Create(ASTContext &Context,
-                                     ArrayRef<DeclAccessPair> Lookups,
-                                     StringLiteral *DeletedMessage = nullptr);
+    static DefaultedOrDeletedFunctionInfo *
+    Create(ASTContext &Context, ArrayRef<DeclAccessPair> Lookups,
+           StringLiteral *DeletedMessage = nullptr);
 
     /// Get the unqualified lookup results that should be used in this
     /// defaulted function definition.
@@ -2019,12 +2019,12 @@ class FunctionDecl : public DeclaratorDecl,
   ParmVarDecl **ParamInfo = nullptr;
 
   /// The active member of this union is determined by
-  /// FunctionDeclBits.HasExtraFunctionInfo.
+  /// FunctionDeclBits.HasDefaultedOrDeletedInfo.
   union {
     /// The body of the function.
     LazyDeclStmtPtr Body;
     /// Information about a future defaulted function definition.
-    ExtraFunctionInfo *ExtraInfo;
+    DefaultedOrDeletedFunctionInfo *DefaultedOrDeletedInfo;
   };
 
   unsigned ODRHash;
@@ -2282,18 +2282,18 @@ class FunctionDecl : public DeclaratorDecl,
 
   /// Returns whether this specific declaration of the function has a body.
   bool doesThisDeclarationHaveABody() const {
-    return (!FunctionDeclBits.HasExtraFunctionInfo && Body) ||
+    return (!FunctionDeclBits.HasDefaultedOrDeletedInfo && Body) ||
            isLateTemplateParsed();
   }
 
   void setBody(Stmt *B);
   void setLazyBody(uint64_t Offset) {
-    FunctionDeclBits.HasExtraFunctionInfo = false;
+    FunctionDeclBits.HasDefaultedOrDeletedInfo = false;
     Body = LazyDeclStmtPtr(Offset);
   }
 
-  void setExtraFunctionInfo(ExtraFunctionInfo *Info);
-  ExtraFunctionInfo *getExtraFunctionInfo() const;
+  void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info);
+  DefaultedOrDeletedFunctionInfo *getDefalutedOrDeletedInfo() const;
 
   /// Whether this function is variadic.
   bool isVariadic() const;
@@ -2657,8 +2657,8 @@ class FunctionDecl : public DeclaratorDecl,
 
   /// Get the message that indicates why this function was deleted.
   StringLiteral *getDeletedMessage() const {
-    return FunctionDeclBits.HasExtraFunctionInfo
-               ? ExtraInfo->getDeletedMessage()
+    return FunctionDeclBits.HasDefaultedOrDeletedInfo
+               ? DefaultedOrDeletedInfo->getDeletedMessage()
                : nullptr;
   }
 

clang/include/clang/AST/DeclBase.h

@@ -1740,7 +1740,7 @@ class DeclContext {
     LLVM_PREFERRED_TYPE(bool)
     uint64_t IsExplicitlyDefaulted : 1;
     LLVM_PREFERRED_TYPE(bool)
-    uint64_t HasExtraFunctionInfo : 1;
+    uint64_t HasDefaultedOrDeletedInfo : 1;
 
     /// For member functions of complete types, whether this is an ineligible
     /// special member function or an unselected destructor. See

clang/include/clang/Sema/Sema.h

@@ -3203,7 +3203,7 @@ class Sema final {
   void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
 
   enum class FnBodyKind {
-    /// C++ [dcl.fct.def.general]p1
+    /// C++26 [dcl.fct.def.general]p1
     /// function-body:
     ///   ctor-initializer[opt] compound-statement
     ///   function-try-block

clang/lib/AST/ASTImporter.cpp

@@ -3961,8 +3961,9 @@ ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   ToFunction->setDefaultLoc(ToDefaultLoc);
 
   if (Msg)
-    ToFunction->setExtraFunctionInfo(FunctionDecl::ExtraFunctionInfo::Create(
-        Importer.getToContext(), {}, Msg));
+    ToFunction->setDefaultedOrDeletedInfo(
+        FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
+            Importer.getToContext(), {}, Msg));
 
   // Set the parameters.
   for (auto *Param : Parameters) {

clang/lib/AST/Decl.cpp

@@ -3058,7 +3058,7 @@ FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
   FunctionDeclBits.IsTrivialForCall = false;
   FunctionDeclBits.IsDefaulted = false;
   FunctionDeclBits.IsExplicitlyDefaulted = false;
-  FunctionDeclBits.HasExtraFunctionInfo = false;
+  FunctionDeclBits.HasDefaultedOrDeletedInfo = false;
   FunctionDeclBits.IsIneligibleOrNotSelected = false;
   FunctionDeclBits.HasImplicitReturnZero = false;
   FunctionDeclBits.IsLateTemplateParsed = false;
@@ -3092,18 +3092,18 @@ bool FunctionDecl::isVariadic() const {
   return false;
 }
 
-FunctionDecl::ExtraFunctionInfo *
-FunctionDecl::ExtraFunctionInfo::Create(ASTContext &Context,
-                                        ArrayRef<DeclAccessPair> Lookups,
-                                        StringLiteral *DeletedMessage) {
+FunctionDecl::DefaultedOrDeletedFunctionInfo *
+FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
+    ASTContext &Context, ArrayRef<DeclAccessPair> Lookups,
+    StringLiteral *DeletedMessage) {
   static constexpr size_t Alignment =
-      std::max({alignof(ExtraFunctionInfo), alignof(DeclAccessPair),
-                alignof(StringLiteral *)});
+      std::max({alignof(DefaultedOrDeletedFunctionInfo),
+                alignof(DeclAccessPair), alignof(StringLiteral *)});
   size_t Size = totalSizeToAlloc<DeclAccessPair, StringLiteral *>(
       Lookups.size(), !!DeletedMessage);
 
-  ExtraFunctionInfo *Info =
-      new (Context.Allocate(Size, Alignment)) ExtraFunctionInfo;
+  DefaultedOrDeletedFunctionInfo *Info =
+      new (Context.Allocate(Size, Alignment)) DefaultedOrDeletedFunctionInfo;
   Info->NumLookups = Lookups.size();
   Info->HasDeletedMessage = !!DeletedMessage;
 
@@ -3114,36 +3114,40 @@ FunctionDecl::ExtraFunctionInfo::Create(ASTContext &Context,
   return Info;
 }
 
-void FunctionDecl::setExtraFunctionInfo(ExtraFunctionInfo *Info) {
-  assert(!FunctionDeclBits.HasExtraFunctionInfo && "already have this");
+void FunctionDecl::setDefaultedOrDeletedInfo(
+    DefaultedOrDeletedFunctionInfo *Info) {
+  assert(!FunctionDeclBits.HasDefaultedOrDeletedInfo && "already have this");
   assert(!Body && "can't replace function body with defaulted function info");
 
-  FunctionDeclBits.HasExtraFunctionInfo = true;
-  ExtraInfo = Info;
+  FunctionDeclBits.HasDefaultedOrDeletedInfo = true;
+  DefaultedOrDeletedInfo = Info;
 }
 
-void FunctionDecl::ExtraFunctionInfo::setDeletedMessage(
+void FunctionDecl::DefaultedOrDeletedFunctionInfo::setDeletedMessage(
     StringLiteral *Message) {
-  // We should never get here with the ExtraInfo populated, but no space
-  // allocated for the deleted message, since that would require recreating
-  // this, but setExtraFunctionInfo() disallows overwriting an already existing
-  // ExtraFunctionInfo.
-  assert(HasDeletedMessage && "Explicitly deleting defaulted function?");
+  // We should never get here with the DefaultedOrDeletedInfo populated, but
+  // no space allocated for the deleted message, since that would require
+  // recreating this, but setDefaultedOrDeletedInfo() disallows overwriting
+  // an already existing DefaultedOrDeletedFunctionInfo.
+  assert(HasDeletedMessage &&
+         "No space to store a delete message in this DefaultedOrDeletedInfo");
   *getTrailingObjects<StringLiteral *>() = Message;
 }
 
-FunctionDecl::ExtraFunctionInfo *FunctionDecl::getExtraFunctionInfo() const {
-  return FunctionDeclBits.HasExtraFunctionInfo ? ExtraInfo : nullptr;
+FunctionDecl::DefaultedOrDeletedFunctionInfo *
+FunctionDecl::getDefalutedOrDeletedInfo() const {
+  return FunctionDeclBits.HasDefaultedOrDeletedInfo ? DefaultedOrDeletedInfo
+                                                    : nullptr;
 }
 
 void FunctionDecl::setDeletedMessage(StringLiteral *Message) {
   assert(Message && "Should not be called with nullptr");
   assert(isDeletedAsWritten() && "Function must be deleted");
-  if (FunctionDeclBits.HasExtraFunctionInfo)
-    ExtraInfo->setDeletedMessage(Message);
+  if (FunctionDeclBits.HasDefaultedOrDeletedInfo)
+    DefaultedOrDeletedInfo->setDeletedMessage(Message);
   else
-    setExtraFunctionInfo(
-        ExtraFunctionInfo::Create(getASTContext(), {}, Message));
+    setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo::Create(
+        getASTContext(), /*Lookups=*/{}, Message));
 }
 
 bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const {
@@ -3230,7 +3234,7 @@ Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
   if (!hasBody(Definition))
     return nullptr;
 
-  assert(!Definition->FunctionDeclBits.HasExtraFunctionInfo &&
+  assert(!Definition->FunctionDeclBits.HasDefaultedOrDeletedInfo &&
          "definition should not have a body");
   if (Definition->Body)
     return Definition->Body.get(getASTContext().getExternalSource());
@@ -3239,7 +3243,7 @@ Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
 }
 
 void FunctionDecl::setBody(Stmt *B) {
-  FunctionDeclBits.HasExtraFunctionInfo = false;
+  FunctionDeclBits.HasDefaultedOrDeletedInfo = false;
   Body = LazyDeclStmtPtr(B);
   if (B)
     EndRangeLoc = B->getEndLoc();

clang/lib/Sema/SemaDecl.cpp

@@ -16155,8 +16155,15 @@ Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
     // This is meant to pop the context added in ActOnStartOfFunctionDef().
     ExitFunctionBodyRAII ExitRAII(*this, isLambdaCallOperator(FD));
     if (FD) {
-      // Do not overwrite the potentially present ExtraInfo of a deleted
-      // function declaration.
+      // If this is called by Parser::ParseFunctionDefinition() after marking
+      // the declaration as deleted, and if the deleted-function-body contains
+      // a message (C++26), then a DefaultedOrDeletedInfo will have already been
+      // added to store that message; do not overwrite it in that case.
+      //
+      // Since this would always set the body to 'nullptr' in that case anyway,
+      // which is already done when the function decl is initially created,
+      // always skipping this irrespective of whether there is a delete message
+      // should not be a problem.
       if (!FD->isDeletedAsWritten())
         FD->setBody(Body);
       FD->setWillHaveBody(false);

clang/lib/Sema/SemaDeclCXX.cpp

@@ -7962,7 +7962,7 @@ class DefaultedComparisonVisitor {
   DefaultedComparisonVisitor(Sema &S, CXXRecordDecl *RD, FunctionDecl *FD,
                              DefaultedComparisonKind DCK)
       : S(S), RD(RD), FD(FD), DCK(DCK) {
-    if (auto *Info = FD->getExtraFunctionInfo()) {
+    if (auto *Info = FD->getDefalutedOrDeletedInfo()) {
       // FIXME: Change CreateOverloadedBinOp to take an ArrayRef instead of an
       // UnresolvedSet to avoid this copy.
       Fns.assign(Info->getUnqualifiedLookups().begin(),
@@ -8830,8 +8830,9 @@ bool Sema::CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *FD,
     UnresolvedSet<32> Operators;
     lookupOperatorsForDefaultedComparison(*this, S, Operators,
                                           FD->getOverloadedOperator());
-    FD->setExtraFunctionInfo(
-        FunctionDecl::ExtraFunctionInfo::Create(Context, Operators.pairs()));
+    FD->setDefaultedOrDeletedInfo(
+        FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
+            Context, Operators.pairs()));
   }
 
   // C++2a [class.compare.default]p1:

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -4856,7 +4856,7 @@ TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
 bool TemplateDeclInstantiator::SubstDefaultedFunction(FunctionDecl *New,
                                                       FunctionDecl *Tmpl) {
   // Transfer across any unqualified lookups.
-  if (auto *DFI = Tmpl->getExtraFunctionInfo()) {
+  if (auto *DFI = Tmpl->getDefalutedOrDeletedInfo()) {
     SmallVector<DeclAccessPair, 32> Lookups;
     Lookups.reserve(DFI->getUnqualifiedLookups().size());
     bool AnyChanged = false;
@@ -4871,10 +4871,10 @@ bool TemplateDeclInstantiator::SubstDefaultedFunction(FunctionDecl *New,
 
     // It's unlikely that substitution will change any declarations. Don't
     // store an unnecessary copy in that case.
-    New->setExtraFunctionInfo(
-        AnyChanged
-            ? FunctionDecl::ExtraFunctionInfo::Create(SemaRef.Context, Lookups)
-            : DFI);
+    New->setDefaultedOrDeletedInfo(
+        AnyChanged ? FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
+                         SemaRef.Context, Lookups)
+                   : DFI);
   }
 
   SemaRef.SetDeclDefaulted(New, Tmpl->getLocation());

clang/lib/Serialization/ASTReaderDecl.cpp

@@ -1110,9 +1110,9 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   }
 
   if (FD->isDefaulted() || FD->isDeletedAsWritten()) {
-    // If 'Info' is nonzero, we need to read an ExtraFunctionInfo; if,
+    // If 'Info' is nonzero, we need to read an DefaultedOrDeletedInfo; if,
     // additionally, the second bit is also set, we also need to read
-    // a DeletedMessage for the ExtraFunctionInfo.
+    // a DeletedMessage for the DefaultedOrDeletedInfo.
     if (auto Info = Record.readInt()) {
       bool HasMessage = Info & 2;
       StringLiteral *DeletedMessage =
@@ -1126,8 +1126,9 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
         Lookups.push_back(DeclAccessPair::make(ND, AS));
       }
 
-      FD->setExtraFunctionInfo(FunctionDecl::ExtraFunctionInfo::Create(
-          Reader.getContext(), Lookups, DeletedMessage));
+      FD->setDefaultedOrDeletedInfo(
+          FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
+              Reader.getContext(), Lookups, DeletedMessage));
     }
   }
 

clang/lib/Serialization/ASTWriterDecl.cpp

@@ -750,9 +750,9 @@ void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
     Record.push_back(D->getODRHash());
 
   if (D->isDefaulted() || D->isDeletedAsWritten()) {
-    if (auto *FDI = D->getExtraFunctionInfo()) {
-      // Store both that there is an ExtraFunctionInfo and whether it contains
-      // a DeletedMessage.
+    if (auto *FDI = D->getDefalutedOrDeletedInfo()) {
+      // Store both that there is an DefaultedOrDeletedInfo and whether it
+      // contains a DeletedMessage.
       StringLiteral *DeletedMessage = FDI->getDeletedMessage();
       Record.push_back(1 | (DeletedMessage ? 2 : 0));
       if (DeletedMessage)

clang/test/PCH/cxx2a-defaulted-comparison.cpp

@@ -22,7 +22,7 @@ namespace std {
   constexpr strong_ordering strong_ordering::less = {-1};
 }
 
-// Ensure that we can round-trip ExtraFunctionInfo through an AST file.
+// Ensure that we can round-trip DefaultedOrDeletedInfo through an AST file.
 namespace LookupContext {
   struct A {};