Comments AST: refactor DeclInfo to use an enum for decl kind instead of

separate flags.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@161217 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/Comment.h b/include/clang/AST/Comment.h
index 32c96a59ecd6b1ace5f116f973798964c24b13cf..a4ba14dbcb204a877f76911b649a2c38342244cc 100644 (file)
--- a/include/clang/AST/Comment.h
+++ b/include/clang/AST/Comment.h
@@ -923,14 +923,43 @@ struct DeclInfo {
   /// a template.
   const TemplateParameterList *TemplateParameters;
 
+  /// A simplified description of \c ThisDecl kind that should be good enough
+  /// for documentation rendering purposes.
+  enum DeclKind {
+    /// Something that we consider a "function":
+    /// \li function,
+    /// \li function template,
+    /// \li function template specialization,
+    /// \li member function,
+    /// \li member function template,
+    /// \li member function template specialization,
+    /// \li ObjC method.
+    FunctionKind,
+
+    /// Something that we consider a "class":
+    /// \li class/struct,
+    /// \li class template,
+    /// \li class template (partial) specialization.
+    ClassKind,
+
+    /// Something that we consider a "variable":
+    /// \li namespace scope variables;
+    /// \li static and non-static class data members.
+    VariableKind,
+
+    /// A C++ namespace.
+    NamespaceKind,
+
+    /// A C++ typedef-name (a 'typedef' decl specifier or alias-declaration),
+    /// see \c TypedefNameDecl.
+    TypedefKind
+  };
+
   /// If false, only \c ThisDecl is valid.
   unsigned IsFilled : 1;
 
-  /// Is \c ThisDecl something that we consider a "function".
-  unsigned IsFunctionDecl : 1;
-
-  /// Is \c ThisDecl something that we consider a "class".
-  unsigned IsClassDecl : 1;
+  /// Simplified kind of \c ThisDecl, see\c DeclKind enum.
+  unsigned Kind : 3;
 
   /// Is \c ThisDecl a template declaration.
   unsigned IsTemplateDecl : 1;
@@ -953,6 +982,10 @@ struct DeclInfo {
   unsigned IsClassMethod : 1;
 
   void fill();
+
+  DeclKind getKind() const LLVM_READONLY {
+    return static_cast<DeclKind>(Kind);
+  }
 };
 
 /// A full comment attached to a declaration, contains block content.

diff --git a/lib/AST/Comment.cpp b/lib/AST/Comment.cpp
index ecf6d2a553207fa5a8a007f4b7c96eab3d2fcf8f..ba68cee734c7925cbafc2ae67346c4d5eac46926 100644 (file)
--- a/lib/AST/Comment.cpp
+++ b/lib/AST/Comment.cpp
@@ -141,7 +141,7 @@ void DeclInfo::fill() {
   assert(!IsFilled);
 
   // Set defaults.
-  IsFunctionDecl = false;
+  Kind = FunctionKind;
   IsTemplateDecl = false;
   IsTemplateSpecialization = false;
   IsTemplatePartialSpecialization = false;
@@ -153,7 +153,7 @@ void DeclInfo::fill() {
   if (!ThisDecl) {
     // Defaults are OK.
   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ThisDecl)) {
-    IsFunctionDecl = true;
+    Kind = FunctionKind;
     ParamVars = ArrayRef<const ParmVarDecl *>(FD->param_begin(),
                                               FD->getNumParams());
     unsigned NumLists = FD->getNumTemplateParameterLists();
@@ -169,14 +169,14 @@ void DeclInfo::fill() {
       IsClassMethod = !IsInstanceMethod;
     }
   } else if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ThisDecl)) {
-    IsFunctionDecl = true;
+    Kind = FunctionKind;
     ParamVars = ArrayRef<const ParmVarDecl *>(MD->param_begin(),
                                               MD->param_size());
     IsInstanceMethod = MD->isInstanceMethod();
     IsClassMethod = !IsInstanceMethod;
   } else if (const FunctionTemplateDecl *FTD =
                  dyn_cast<FunctionTemplateDecl>(ThisDecl)) {
-    IsFunctionDecl = true;
+    Kind = FunctionKind;
     IsTemplateDecl = true;
     const FunctionDecl *FD = FTD->getTemplatedDecl();
     ParamVars = ArrayRef<const ParmVarDecl *>(FD->param_begin(),
@@ -184,18 +184,30 @@ void DeclInfo::fill() {
     TemplateParameters = FTD->getTemplateParameters();
   } else if (const ClassTemplateDecl *CTD =
                  dyn_cast<ClassTemplateDecl>(ThisDecl)) {
+    Kind = ClassKind;
     IsTemplateDecl = true;
     TemplateParameters = CTD->getTemplateParameters();
   } else if (const ClassTemplatePartialSpecializationDecl *CTPSD =
                  dyn_cast<ClassTemplatePartialSpecializationDecl>(ThisDecl)) {
+    Kind = ClassKind;
     IsTemplateDecl = true;
     IsTemplatePartialSpecialization = true;
     TemplateParameters = CTPSD->getTemplateParameters();
   } else if (isa<ClassTemplateSpecializationDecl>(ThisDecl)) {
+    Kind = ClassKind;
     IsTemplateDecl = true;
     IsTemplateSpecialization = true;
+  } else if (isa<RecordDecl>(ThisDecl)) {
+    Kind = ClassKind;
+  } else if (isa<VarDecl>(ThisDecl) || isa<FieldDecl>(ThisDecl)) {
+    Kind = VariableKind;
+  } else if (isa<NamespaceDecl>(ThisDecl)) {
+    Kind = NamespaceKind;
+  } else if (isa<TypedefNameDecl>(ThisDecl)) {
+    Kind = TypedefKind;
   } else if (const TypeAliasTemplateDecl *TAT =
                  dyn_cast<TypeAliasTemplateDecl>(ThisDecl)) {
+    Kind = TypedefKind;
     IsTemplateDecl = true;
     TemplateParameters = TAT->getTemplateParameters();
   }
@@ -204,3 +216,4 @@ void DeclInfo::fill() {
 
 } // end namespace comments
 } // end namespace clang
+

diff --git a/lib/AST/CommentSema.cpp b/lib/AST/CommentSema.cpp
index cedc72a988c6eb5c1ef287d1da0905e083aea8d9..cbfbc4eb24dcea419709a41a866e787746b861e8 100644 (file)
--- a/lib/AST/CommentSema.cpp
+++ b/lib/AST/CommentSema.cpp
@@ -477,7 +477,7 @@ bool Sema::isFunctionDecl() {
     return false;
   if (!ThisDeclInfo->IsFilled)
     inspectThisDecl();
-  return ThisDeclInfo->IsFunctionDecl;
+  return ThisDeclInfo->getKind() == DeclInfo::FunctionKind;
 }
 
 bool Sema::isTemplateDecl() {