Comment.cpp revision 88815f3f81361692dd281000e3e46bf163b2f28b 
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
10#include "clang/AST/Comment.h"
11#include "clang/AST/Decl.h"
12#include "clang/AST/DeclObjC.h"
13#include "clang/AST/DeclTemplate.h"
14#include "llvm/Support/ErrorHandling.h"
15#include "llvm/Support/raw_ostream.h"
16
17namespace clang {
18namespace comments {
19
20const char *Comment::getCommentKindName() const {
21  switch (getCommentKind()) {
22  case NoCommentKind: return "NoCommentKind";
23#define ABSTRACT_COMMENT(COMMENT)
24#define COMMENT(CLASS, PARENT) \
25  case CLASS##Kind: \
26    return #CLASS;
27#include "clang/AST/CommentNodes.inc"
28#undef COMMENT
29#undef ABSTRACT_COMMENT
30  }
31  llvm_unreachable("Unknown comment kind!");
32}
33
34void Comment::dump() const {
35  // It is important that Comment::dump() is defined in a different TU than
36  // Comment::dump(raw_ostream, SourceManager).  If both functions were defined
37  // in CommentDumper.cpp, that object file would be removed by linker because
38  // none of its functions are referenced by other object files, despite the
39  // LLVM_ATTRIBUTE_USED.
40  dump(llvm::errs(), NULL);
41}
42
43void Comment::dump(SourceManager &SM) const {
44  dump(llvm::errs(), &SM);
45}
46
47namespace {
48struct good {};
49struct bad {};
50
51template <typename T>
52good implements_child_begin_end(Comment::child_iterator (T::*)() const) {
53  return good();
54}
55
56static inline bad implements_child_begin_end(
57                      Comment::child_iterator (Comment::*)() const) {
58  return bad();
59}
60
61#define ASSERT_IMPLEMENTS_child_begin(function) \
62  (void) sizeof(good(implements_child_begin_end(function)))
63
64static inline void CheckCommentASTNodes() {
65#define ABSTRACT_COMMENT(COMMENT)
66#define COMMENT(CLASS, PARENT) \
67  ASSERT_IMPLEMENTS_child_begin(&CLASS::child_begin); \
68  ASSERT_IMPLEMENTS_child_begin(&CLASS::child_end);
69#include "clang/AST/CommentNodes.inc"
70#undef COMMENT
71#undef ABSTRACT_COMMENT
72}
73
74#undef ASSERT_IMPLEMENTS_child_begin
75
76} // end unnamed namespace
77
78Comment::child_iterator Comment::child_begin() const {
79  switch (getCommentKind()) {
80  case NoCommentKind: llvm_unreachable("comment without a kind");
81#define ABSTRACT_COMMENT(COMMENT)
82#define COMMENT(CLASS, PARENT) \
83  case CLASS##Kind: \
84    return static_cast<const CLASS *>(this)->child_begin();
85#include "clang/AST/CommentNodes.inc"
86#undef COMMENT
87#undef ABSTRACT_COMMENT
88  }
89  llvm_unreachable("Unknown comment kind!");
90}
91
92Comment::child_iterator Comment::child_end() const {
93  switch (getCommentKind()) {
94  case NoCommentKind: llvm_unreachable("comment without a kind");
95#define ABSTRACT_COMMENT(COMMENT)
96#define COMMENT(CLASS, PARENT) \
97  case CLASS##Kind: \
98    return static_cast<const CLASS *>(this)->child_end();
99#include "clang/AST/CommentNodes.inc"
100#undef COMMENT
101#undef ABSTRACT_COMMENT
102  }
103  llvm_unreachable("Unknown comment kind!");
104}
105
106bool TextComment::isWhitespaceNoCache() const {
107  for (StringRef::const_iterator I = Text.begin(), E = Text.end();
108       I != E; ++I) {
109    const char C = *I;
110    if (C != ' ' && C != '\n' && C != '\r' &&
111        C != '\t' && C != '\f' && C != '\v')
112      return false;
113  }
114  return true;
115}
116
117bool ParagraphComment::isWhitespaceNoCache() const {
118  for (child_iterator I = child_begin(), E = child_end(); I != E; ++I) {
119    if (const TextComment *TC = dyn_cast<TextComment>(*I)) {
120      if (!TC->isWhitespace())
121        return false;
122    } else
123      return false;
124  }
125  return true;
126}
127
128const char *ParamCommandComment::getDirectionAsString(PassDirection D) {
129  switch (D) {
130  case ParamCommandComment::In:
131    return "[in]";
132  case ParamCommandComment::Out:
133    return "[out]";
134  case ParamCommandComment::InOut:
135    return "[in,out]";
136  }
137  llvm_unreachable("unknown PassDirection");
138}
139
140void DeclInfo::fill() {
141  assert(!IsFilled);
142
143  // Set defaults.
144  Kind = OtherKind;
145  IsTemplateDecl = false;
146  IsTemplateSpecialization = false;
147  IsTemplatePartialSpecialization = false;
148  IsObjCMethod = false;
149  IsInstanceMethod = false;
150  IsClassMethod = false;
151  ParamVars = ArrayRef<const ParmVarDecl *>();
152  TemplateParameters = NULL;
153
154  if (!ThisDecl) {
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);
171    Kind = FunctionKind;
172    ParamVars = ArrayRef<const ParmVarDecl *>(FD->param_begin(),
173                                              FD->getNumParams());
174    ResultType = FD->getResultType();
175    unsigned NumLists = FD->getNumTemplateParameterLists();
176    if (NumLists != 0) {
177      IsTemplateDecl = true;
178      IsTemplateSpecialization = true;
179      TemplateParameters =
180          FD->getTemplateParameterList(NumLists - 1);
181    }
182
183    if (K == Decl::CXXMethod || K == Decl::CXXConstructor ||
184        K == Decl::CXXDestructor || K == Decl::CXXConversion) {
185      const CXXMethodDecl *MD = cast<CXXMethodDecl>(ThisDecl);
186      IsInstanceMethod = MD->isInstance();
187      IsClassMethod = !IsInstanceMethod;
188    }
189    break;
190  }
191  case Decl::ObjCMethod: {
192    const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(ThisDecl);
193    Kind = FunctionKind;
194    ParamVars = ArrayRef<const ParmVarDecl *>(MD->param_begin(),
195                                              MD->param_size());
196    ResultType = MD->getResultType();
197    IsObjCMethod = true;
198    IsInstanceMethod = MD->isInstanceMethod();
199    IsClassMethod = !IsInstanceMethod;
200    break;
201  }
202  case Decl::FunctionTemplate: {
203    const FunctionTemplateDecl *FTD = cast<FunctionTemplateDecl>(ThisDecl);
204    Kind = FunctionKind;
205    IsTemplateDecl = true;
206    const FunctionDecl *FD = FTD->getTemplatedDecl();
207    ParamVars = ArrayRef<const ParmVarDecl *>(FD->param_begin(),
208                                              FD->getNumParams());
209    ResultType = FD->getResultType();
210    TemplateParameters = FTD->getTemplateParameters();
211    break;
212  }
213  case Decl::ClassTemplate: {
214    const ClassTemplateDecl *CTD = cast<ClassTemplateDecl>(ThisDecl);
215    Kind = ClassKind;
216    IsTemplateDecl = true;
217    TemplateParameters = CTD->getTemplateParameters();
218    break;
219  }
220  case Decl::ClassTemplatePartialSpecialization: {
221    const ClassTemplatePartialSpecializationDecl *CTPSD =
222        cast<ClassTemplatePartialSpecializationDecl>(ThisDecl);
223    Kind = ClassKind;
224    IsTemplateDecl = true;
225    IsTemplatePartialSpecialization = true;
226    TemplateParameters = CTPSD->getTemplateParameters();
227    break;
228  }
229  case Decl::ClassTemplateSpecialization:
230    Kind = ClassKind;
231    IsTemplateDecl = true;
232    IsTemplateSpecialization = true;
233    break;
234  case Decl::Record:
235  case Decl::CXXRecord:
236    Kind = ClassKind;
237    break;
238  case Decl::Var:
239  case Decl::Field:
240  case Decl::ObjCIvar:
241  case Decl::ObjCAtDefsField:
242    Kind = VariableKind;
243    break;
244  case Decl::Namespace:
245    Kind = NamespaceKind;
246    break;
247  case Decl::Typedef:
248  case Decl::TypeAlias:
249    Kind = TypedefKind;
250    break;
251  case Decl::TypeAliasTemplate: {
252    const TypeAliasTemplateDecl *TAT = cast<TypeAliasTemplateDecl>(ThisDecl);
253    Kind = TypedefKind;
254    IsTemplateDecl = true;
255    TemplateParameters = TAT->getTemplateParameters();
256    break;
257  }
258  }
259
260  IsFilled = true;
261}
262
263} // end namespace comments
264} // end namespace clang
265
266