Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 1 | //===--- Comment.cpp - Comment AST node implementation --------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
Dmitri Gribenko | e4330a3 | 2012-09-10 20:32:42 +0000 | [diff] [blame] | 10 | #include "clang/AST/ASTContext.h" |
Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 11 | #include "clang/AST/Comment.h" |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 12 | #include "clang/AST/Decl.h" |
| 13 | #include "clang/AST/DeclObjC.h" |
| 14 | #include "clang/AST/DeclTemplate.h" |
Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 15 | #include "llvm/Support/ErrorHandling.h" |
Dmitri Gribenko | fb3643a | 2012-07-18 16:30:42 +0000 | [diff] [blame] | 16 | #include "llvm/Support/raw_ostream.h" |
Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 17 | |
| 18 | namespace clang { |
| 19 | namespace comments { |
| 20 | |
| 21 | const char *Comment::getCommentKindName() const { |
| 22 | switch (getCommentKind()) { |
| 23 | case NoCommentKind: return "NoCommentKind"; |
| 24 | #define ABSTRACT_COMMENT(COMMENT) |
| 25 | #define COMMENT(CLASS, PARENT) \ |
| 26 | case CLASS##Kind: \ |
| 27 | return #CLASS; |
| 28 | #include "clang/AST/CommentNodes.inc" |
| 29 | #undef COMMENT |
| 30 | #undef ABSTRACT_COMMENT |
| 31 | } |
| 32 | llvm_unreachable("Unknown comment kind!"); |
| 33 | } |
| 34 | |
Dmitri Gribenko | fb3643a | 2012-07-18 16:30:42 +0000 | [diff] [blame] | 35 | void Comment::dump() const { |
| 36 | // It is important that Comment::dump() is defined in a different TU than |
| 37 | // Comment::dump(raw_ostream, SourceManager). If both functions were defined |
| 38 | // in CommentDumper.cpp, that object file would be removed by linker because |
| 39 | // none of its functions are referenced by other object files, despite the |
| 40 | // LLVM_ATTRIBUTE_USED. |
Dmitri Gribenko | e4330a3 | 2012-09-10 20:32:42 +0000 | [diff] [blame] | 41 | dump(llvm::errs(), NULL, NULL); |
Dmitri Gribenko | fb3643a | 2012-07-18 16:30:42 +0000 | [diff] [blame] | 42 | } |
| 43 | |
Dmitri Gribenko | e4330a3 | 2012-09-10 20:32:42 +0000 | [diff] [blame] | 44 | void Comment::dump(const ASTContext &Context) const { |
| 45 | dump(llvm::errs(), &Context.getCommentCommandTraits(), |
| 46 | &Context.getSourceManager()); |
Dmitri Gribenko | fb3643a | 2012-07-18 16:30:42 +0000 | [diff] [blame] | 47 | } |
| 48 | |
Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 49 | namespace { |
| 50 | struct good {}; |
| 51 | struct bad {}; |
| 52 | |
| 53 | template <typename T> |
| 54 | good implements_child_begin_end(Comment::child_iterator (T::*)() const) { |
| 55 | return good(); |
| 56 | } |
| 57 | |
| 58 | static inline bad implements_child_begin_end( |
| 59 | Comment::child_iterator (Comment::*)() const) { |
| 60 | return bad(); |
| 61 | } |
| 62 | |
| 63 | #define ASSERT_IMPLEMENTS_child_begin(function) \ |
| 64 | (void) sizeof(good(implements_child_begin_end(function))) |
| 65 | |
| 66 | static inline void CheckCommentASTNodes() { |
| 67 | #define ABSTRACT_COMMENT(COMMENT) |
| 68 | #define COMMENT(CLASS, PARENT) \ |
| 69 | ASSERT_IMPLEMENTS_child_begin(&CLASS::child_begin); \ |
| 70 | ASSERT_IMPLEMENTS_child_begin(&CLASS::child_end); |
| 71 | #include "clang/AST/CommentNodes.inc" |
| 72 | #undef COMMENT |
| 73 | #undef ABSTRACT_COMMENT |
| 74 | } |
| 75 | |
| 76 | #undef ASSERT_IMPLEMENTS_child_begin |
| 77 | |
| 78 | } // end unnamed namespace |
| 79 | |
| 80 | Comment::child_iterator Comment::child_begin() const { |
| 81 | switch (getCommentKind()) { |
| 82 | case NoCommentKind: llvm_unreachable("comment without a kind"); |
| 83 | #define ABSTRACT_COMMENT(COMMENT) |
| 84 | #define COMMENT(CLASS, PARENT) \ |
| 85 | case CLASS##Kind: \ |
| 86 | return static_cast<const CLASS *>(this)->child_begin(); |
| 87 | #include "clang/AST/CommentNodes.inc" |
| 88 | #undef COMMENT |
| 89 | #undef ABSTRACT_COMMENT |
| 90 | } |
Matt Beaumont-Gay | 4d48b5c | 2012-07-06 21:13:09 +0000 | [diff] [blame] | 91 | llvm_unreachable("Unknown comment kind!"); |
Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 92 | } |
| 93 | |
| 94 | Comment::child_iterator Comment::child_end() const { |
| 95 | switch (getCommentKind()) { |
| 96 | case NoCommentKind: llvm_unreachable("comment without a kind"); |
| 97 | #define ABSTRACT_COMMENT(COMMENT) |
| 98 | #define COMMENT(CLASS, PARENT) \ |
| 99 | case CLASS##Kind: \ |
| 100 | return static_cast<const CLASS *>(this)->child_end(); |
| 101 | #include "clang/AST/CommentNodes.inc" |
| 102 | #undef COMMENT |
| 103 | #undef ABSTRACT_COMMENT |
| 104 | } |
Matt Beaumont-Gay | 4d48b5c | 2012-07-06 21:13:09 +0000 | [diff] [blame] | 105 | llvm_unreachable("Unknown comment kind!"); |
Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 106 | } |
| 107 | |
Dmitri Gribenko | 0f7f10b | 2012-07-18 20:54:32 +0000 | [diff] [blame] | 108 | bool TextComment::isWhitespaceNoCache() const { |
Dmitri Gribenko | a5ef44f | 2012-07-11 21:38:39 +0000 | [diff] [blame] | 109 | for (StringRef::const_iterator I = Text.begin(), E = Text.end(); |
| 110 | I != E; ++I) { |
| 111 | const char C = *I; |
| 112 | if (C != ' ' && C != '\n' && C != '\r' && |
| 113 | C != '\t' && C != '\f' && C != '\v') |
| 114 | return false; |
| 115 | } |
| 116 | return true; |
| 117 | } |
| 118 | |
Dmitri Gribenko | 0f7f10b | 2012-07-18 20:54:32 +0000 | [diff] [blame] | 119 | bool ParagraphComment::isWhitespaceNoCache() const { |
Dmitri Gribenko | a5ef44f | 2012-07-11 21:38:39 +0000 | [diff] [blame] | 120 | for (child_iterator I = child_begin(), E = child_end(); I != E; ++I) { |
| 121 | if (const TextComment *TC = dyn_cast<TextComment>(*I)) { |
| 122 | if (!TC->isWhitespace()) |
| 123 | return false; |
Dmitri Gribenko | 858e69f | 2012-07-19 00:01:56 +0000 | [diff] [blame] | 124 | } else |
| 125 | return false; |
Dmitri Gribenko | a5ef44f | 2012-07-11 21:38:39 +0000 | [diff] [blame] | 126 | } |
| 127 | return true; |
| 128 | } |
| 129 | |
| 130 | const char *ParamCommandComment::getDirectionAsString(PassDirection D) { |
| 131 | switch (D) { |
| 132 | case ParamCommandComment::In: |
| 133 | return "[in]"; |
| 134 | case ParamCommandComment::Out: |
| 135 | return "[out]"; |
| 136 | case ParamCommandComment::InOut: |
| 137 | return "[in,out]"; |
| 138 | } |
| 139 | llvm_unreachable("unknown PassDirection"); |
| 140 | } |
Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 141 | |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 142 | void DeclInfo::fill() { |
| 143 | assert(!IsFilled); |
| 144 | |
| 145 | // Set defaults. |
Dmitri Gribenko | 89ab7d0 | 2012-08-03 21:15:32 +0000 | [diff] [blame] | 146 | Kind = OtherKind; |
Dmitri Gribenko | 04bf29e | 2012-08-06 21:31:15 +0000 | [diff] [blame] | 147 | TemplateKind = NotTemplate; |
Dmitri Gribenko | 88815f3 | 2012-08-06 16:29:26 +0000 | [diff] [blame] | 148 | IsObjCMethod = false; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 149 | IsInstanceMethod = false; |
| 150 | IsClassMethod = false; |
| 151 | ParamVars = ArrayRef<const ParmVarDecl *>(); |
| 152 | TemplateParameters = NULL; |
| 153 | |
| 154 | if (!ThisDecl) { |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 155 | // If there is no declaration, the defaults is our only guess. |
| 156 | IsFilled = true; |
| 157 | return; |
| 158 | } |
| 159 | |
| 160 | Decl::Kind K = ThisDecl->getKind(); |
| 161 | switch (K) { |
| 162 | default: |
| 163 | // Defaults are should be good for declarations we don't handle explicitly. |
| 164 | break; |
| 165 | case Decl::Function: |
| 166 | case Decl::CXXMethod: |
| 167 | case Decl::CXXConstructor: |
| 168 | case Decl::CXXDestructor: |
| 169 | case Decl::CXXConversion: { |
| 170 | const FunctionDecl *FD = cast<FunctionDecl>(ThisDecl); |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 171 | Kind = FunctionKind; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 172 | ParamVars = ArrayRef<const ParmVarDecl *>(FD->param_begin(), |
| 173 | FD->getNumParams()); |
Dmitri Gribenko | 89ab7d0 | 2012-08-03 21:15:32 +0000 | [diff] [blame] | 174 | ResultType = FD->getResultType(); |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 175 | unsigned NumLists = FD->getNumTemplateParameterLists(); |
| 176 | if (NumLists != 0) { |
Dmitri Gribenko | 04bf29e | 2012-08-06 21:31:15 +0000 | [diff] [blame] | 177 | TemplateKind = TemplateSpecialization; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 178 | TemplateParameters = |
| 179 | FD->getTemplateParameterList(NumLists - 1); |
| 180 | } |
| 181 | |
Dmitri Gribenko | 89ab7d0 | 2012-08-03 21:15:32 +0000 | [diff] [blame] | 182 | if (K == Decl::CXXMethod || K == Decl::CXXConstructor || |
| 183 | K == Decl::CXXDestructor || K == Decl::CXXConversion) { |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 184 | const CXXMethodDecl *MD = cast<CXXMethodDecl>(ThisDecl); |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 185 | IsInstanceMethod = MD->isInstance(); |
| 186 | IsClassMethod = !IsInstanceMethod; |
| 187 | } |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 188 | break; |
| 189 | } |
| 190 | case Decl::ObjCMethod: { |
| 191 | const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(ThisDecl); |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 192 | Kind = FunctionKind; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 193 | ParamVars = ArrayRef<const ParmVarDecl *>(MD->param_begin(), |
| 194 | MD->param_size()); |
Dmitri Gribenko | 89ab7d0 | 2012-08-03 21:15:32 +0000 | [diff] [blame] | 195 | ResultType = MD->getResultType(); |
Dmitri Gribenko | 88815f3 | 2012-08-06 16:29:26 +0000 | [diff] [blame] | 196 | IsObjCMethod = true; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 197 | IsInstanceMethod = MD->isInstanceMethod(); |
| 198 | IsClassMethod = !IsInstanceMethod; |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 199 | break; |
| 200 | } |
| 201 | case Decl::FunctionTemplate: { |
| 202 | const FunctionTemplateDecl *FTD = cast<FunctionTemplateDecl>(ThisDecl); |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 203 | Kind = FunctionKind; |
Dmitri Gribenko | 04bf29e | 2012-08-06 21:31:15 +0000 | [diff] [blame] | 204 | TemplateKind = Template; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 205 | const FunctionDecl *FD = FTD->getTemplatedDecl(); |
| 206 | ParamVars = ArrayRef<const ParmVarDecl *>(FD->param_begin(), |
| 207 | FD->getNumParams()); |
Dmitri Gribenko | 89ab7d0 | 2012-08-03 21:15:32 +0000 | [diff] [blame] | 208 | ResultType = FD->getResultType(); |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 209 | TemplateParameters = FTD->getTemplateParameters(); |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 210 | break; |
| 211 | } |
| 212 | case Decl::ClassTemplate: { |
| 213 | const ClassTemplateDecl *CTD = cast<ClassTemplateDecl>(ThisDecl); |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 214 | Kind = ClassKind; |
Dmitri Gribenko | 04bf29e | 2012-08-06 21:31:15 +0000 | [diff] [blame] | 215 | TemplateKind = Template; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 216 | TemplateParameters = CTD->getTemplateParameters(); |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 217 | break; |
| 218 | } |
| 219 | case Decl::ClassTemplatePartialSpecialization: { |
| 220 | const ClassTemplatePartialSpecializationDecl *CTPSD = |
| 221 | cast<ClassTemplatePartialSpecializationDecl>(ThisDecl); |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 222 | Kind = ClassKind; |
Dmitri Gribenko | 04bf29e | 2012-08-06 21:31:15 +0000 | [diff] [blame] | 223 | TemplateKind = TemplatePartialSpecialization; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 224 | TemplateParameters = CTPSD->getTemplateParameters(); |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 225 | break; |
| 226 | } |
| 227 | case Decl::ClassTemplateSpecialization: |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 228 | Kind = ClassKind; |
Dmitri Gribenko | 04bf29e | 2012-08-06 21:31:15 +0000 | [diff] [blame] | 229 | TemplateKind = TemplateSpecialization; |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 230 | break; |
| 231 | case Decl::Record: |
Dmitri Gribenko | 89ab7d0 | 2012-08-03 21:15:32 +0000 | [diff] [blame] | 232 | case Decl::CXXRecord: |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 233 | Kind = ClassKind; |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 234 | break; |
| 235 | case Decl::Var: |
| 236 | case Decl::Field: |
Dmitri Gribenko | dd7b803 | 2012-08-07 18:12:22 +0000 | [diff] [blame] | 237 | case Decl::EnumConstant: |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 238 | case Decl::ObjCIvar: |
| 239 | case Decl::ObjCAtDefsField: |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 240 | Kind = VariableKind; |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 241 | break; |
| 242 | case Decl::Namespace: |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 243 | Kind = NamespaceKind; |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 244 | break; |
Dmitri Gribenko | 70ff109 | 2012-08-24 00:05:30 +0000 | [diff] [blame] | 245 | case Decl::Typedef: { |
| 246 | Kind = TypedefKind; |
| 247 | // If this is a typedef to something we consider a function, extract |
| 248 | // arguments and return type. |
| 249 | const TypedefDecl *TD = cast<TypedefDecl>(ThisDecl); |
| 250 | const TypeSourceInfo *TSI = TD->getTypeSourceInfo(); |
| 251 | if (!TSI) |
| 252 | break; |
| 253 | TypeLoc TL = TSI->getTypeLoc().getUnqualifiedLoc(); |
| 254 | while (true) { |
| 255 | TL = TL.IgnoreParens(); |
Dmitri Gribenko | 70ff109 | 2012-08-24 00:05:30 +0000 | [diff] [blame] | 256 | // Look through qualified types. |
| 257 | if (QualifiedTypeLoc *QualifiedTL = dyn_cast<QualifiedTypeLoc>(&TL)) { |
| 258 | TL = QualifiedTL->getUnqualifiedLoc(); |
| 259 | continue; |
| 260 | } |
| 261 | // Look through pointer types. |
| 262 | if (PointerTypeLoc *PointerTL = dyn_cast<PointerTypeLoc>(&TL)) { |
| 263 | TL = PointerTL->getPointeeLoc().getUnqualifiedLoc(); |
| 264 | continue; |
| 265 | } |
| 266 | if (BlockPointerTypeLoc *BlockPointerTL = |
| 267 | dyn_cast<BlockPointerTypeLoc>(&TL)) { |
| 268 | TL = BlockPointerTL->getPointeeLoc().getUnqualifiedLoc(); |
| 269 | continue; |
| 270 | } |
| 271 | if (MemberPointerTypeLoc *MemberPointerTL = |
| 272 | dyn_cast<MemberPointerTypeLoc>(&TL)) { |
| 273 | TL = MemberPointerTL->getPointeeLoc().getUnqualifiedLoc(); |
| 274 | continue; |
| 275 | } |
| 276 | // Is this a typedef for a function type? |
| 277 | if (FunctionTypeLoc *FTL = dyn_cast<FunctionTypeLoc>(&TL)) { |
| 278 | Kind = FunctionKind; |
| 279 | ArrayRef<ParmVarDecl *> Params = FTL->getParams(); |
| 280 | ParamVars = ArrayRef<const ParmVarDecl *>(Params.data(), |
| 281 | Params.size()); |
| 282 | ResultType = FTL->getResultLoc().getType(); |
| 283 | break; |
| 284 | } |
| 285 | break; |
| 286 | } |
| 287 | break; |
| 288 | } |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 289 | case Decl::TypeAlias: |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 290 | Kind = TypedefKind; |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 291 | break; |
| 292 | case Decl::TypeAliasTemplate: { |
| 293 | const TypeAliasTemplateDecl *TAT = cast<TypeAliasTemplateDecl>(ThisDecl); |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 294 | Kind = TypedefKind; |
Dmitri Gribenko | 04bf29e | 2012-08-06 21:31:15 +0000 | [diff] [blame] | 295 | TemplateKind = Template; |
Dmitri Gribenko | 967e5d7 | 2012-08-02 21:36:57 +0000 | [diff] [blame] | 296 | TemplateParameters = TAT->getTemplateParameters(); |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 297 | break; |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 298 | } |
Dmitri Gribenko | cff339a | 2012-08-07 18:59:04 +0000 | [diff] [blame] | 299 | case Decl::Enum: |
| 300 | Kind = EnumKind; |
| 301 | break; |
Dmitri Gribenko | 5b32a08 | 2012-08-03 00:01:01 +0000 | [diff] [blame] | 302 | } |
| 303 | |
Dmitri Gribenko | 1ca7ecc | 2012-08-01 23:08:09 +0000 | [diff] [blame] | 304 | IsFilled = true; |
| 305 | } |
| 306 | |
Dmitri Gribenko | 8d3ba23 | 2012-07-06 00:28:32 +0000 | [diff] [blame] | 307 | } // end namespace comments |
| 308 | } // end namespace clang |
Dmitri Gribenko | af19a6a | 2012-08-02 21:45:39 +0000 | [diff] [blame] | 309 | |