Comment.cpp Source File (original) (raw)

15#include "llvm/Support/ErrorHandling.h"

16#include <type_traits>

19namespace comments {

23#define ABSTRACT_COMMENT(COMMENT)

24#define COMMENT(CLASS, PARENT) \

25 static_assert(std::is_trivially_destructible::value, \

26 #CLASS " should be trivially destructible!");

27#include "clang/AST/CommentNodes.inc"

28#undef COMMENT

29#undef ABSTRACT_COMMENT

32static_assert(std::is_trivially_destructible_v,

33 "DeclInfo should be trivially destructible!");

38 return "None";

39#define ABSTRACT_COMMENT(COMMENT)

40#define COMMENT(CLASS, PARENT) \

41 case CommentKind::CLASS: \

42 return #CLASS;

43#include "clang/AST/CommentNodes.inc"

44#undef COMMENT

45#undef ABSTRACT_COMMENT

46 }

47 llvm_unreachable("Unknown comment kind!");

48}

50namespace {

51struct good {};

52struct bad {};

54template

56 return good();

57}

59LLVM_ATTRIBUTE_UNUSED

60static inline bad implements_child_begin_end(

62 return bad();

63}

65#define ASSERT_IMPLEMENTS_child_begin(function) \

66 (void) good(implements_child_begin_end(function))

68LLVM_ATTRIBUTE_UNUSED

69static inline void CheckCommentASTNodes() {

70#define ABSTRACT_COMMENT(COMMENT)

71#define COMMENT(CLASS, PARENT) \

72 ASSERT_IMPLEMENTS_child_begin(&CLASS::child_begin); \

73 ASSERT_IMPLEMENTS_child_begin(&CLASS::child_end);

74#include "clang/AST/CommentNodes.inc"

75#undef COMMENT

76#undef ABSTRACT_COMMENT

77}

79#undef ASSERT_IMPLEMENTS_child_begin

81}

86 llvm_unreachable("comment without a kind");

87#define ABSTRACT_COMMENT(COMMENT)

88#define COMMENT(CLASS, PARENT) \

89 case CommentKind::CLASS: \

90 return static_cast<const CLASS *>(this)->child_begin();

91#include "clang/AST/CommentNodes.inc"

92#undef COMMENT

93#undef ABSTRACT_COMMENT

94 }

95 llvm_unreachable("Unknown comment kind!");

96}

101 llvm_unreachable("comment without a kind");

102#define ABSTRACT_COMMENT(COMMENT)

103#define COMMENT(CLASS, PARENT) \

104 case CommentKind::CLASS: \

105 return static_cast<const CLASS *>(this)->child_end();

106#include "clang/AST/CommentNodes.inc"

107#undef COMMENT

108#undef ABSTRACT_COMMENT

109 }

110 llvm_unreachable("Unknown comment kind!");

111}

112

113bool TextComment::isWhitespaceNoCache() const {

115}

116

117bool ParagraphComment::isWhitespaceNoCache() const {

119 if (const TextComment *TC = dyn_cast(*I)) {

120 if (!TC->isWhitespace())

121 return false;

122 } else

123 return false;

124 }

125 return true;

126}

127

130

131

133 return AttributeTL.getModifiedLoc();

134

137

140

143

145 return ATL.getOriginalLoc();

151 return ETL.getNamedTypeLoc();

152

153 return TL;

154}

155

158 while (PrevTL != TL) {

159 PrevTL = TL;

161 }

162

164 ResFTL = FTL;

165 return true;

166 }

167

170

171

172

173

174 if (STL.getNumArgs() != 1)

175 return false;

178 return false;

182 ResFTL = FTL;

183 return true;

184 }

185 }

186

187 return false;

188}

189

190const char *

192 switch (D) {

194 return "[in]";

196 return "[out]";

198 return "[in,out]";

199 }

200 llvm_unreachable("unknown PassDirection");

201}

202

205

206

215

217

219 return;

220 }

222

225 switch (K) {

226 default:

227

228 break;

229 case Decl::Function:

230 case Decl::CXXMethod:

231 case Decl::CXXConstructor:

232 case Decl::CXXDestructor:

233 case Decl::CXXConversion: {

239 if (NumLists != 0) {

243 }

244

245 if (K == Decl::CXXMethod || K == Decl::CXXConstructor ||

246 K == Decl::CXXDestructor || K == Decl::CXXConversion) {

250 }

253 break;

254 }

255 case Decl::ObjCMethod: {

265 break;

266 }

267 case Decl::FunctionTemplate: {

277 break;

278 }

279 case Decl::ClassTemplate: {

284 break;

285 }

286 case Decl::ClassTemplatePartialSpecialization: {

288 cast(CommentDecl);

292 break;

293 }

294 case Decl::ClassTemplateSpecialization:

297 break;

298 case Decl::Record:

299 case Decl::CXXRecord:

301 break;

302 case Decl::Var:

304 cast(CommentDecl)->getDescribedVarTemplate()) {

307 }

308 [[fallthrough]];

309 case Decl::Field:

310 case Decl::EnumConstant:

311 case Decl::ObjCIvar:

312 case Decl::ObjCAtDefsField:

313 case Decl::ObjCProperty:

314 if (const auto *VD = dyn_cast(CommentDecl))

315 TSI = VD->getTypeSourceInfo();

316 else if (const auto *PD = dyn_cast(CommentDecl))

317 TSI = PD->getTypeSourceInfo();

319 break;

320 case Decl::VarTemplate: {

326 TSI = VD->getTypeSourceInfo();

327 break;

328 }

329 case Decl::Namespace:

331 break;

332 case Decl::TypeAlias:

333 case Decl::Typedef:

335 TSI = cast(CommentDecl)->getTypeSourceInfo();

336 break;

337 case Decl::TypeAliasTemplate: {

343 TSI = TAD->getTypeSourceInfo();

344 break;

345 }

346 case Decl::Enum:

348 break;

349 }

350

351

352

353 if (TSI) {

359 if (const auto *FPT = dyn_cast(FTL.getTypePtr()))

362 }

363 }

364

366}

367

371 return "...";

373}

374

378 for (unsigned i = 0, e = getDepth(); i != e; ++i) {

379 assert(TPL && "Unknown TemplateParameterList");

380 if (i == e - 1)

383 if (auto *TTP = dyn_cast(Param))

384 TPL = TTP->getTemplateParameters();

385 }

386 return "";

387}

388

389}

390}

391

Defines the clang::ASTContext interface.

Defines the C++ template declaration subclasses.

Type source information for an attributed type.

Wrapper for source info for block pointers.

Represents a static or instance method of a struct/union/class.

Declaration of a class template.

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

const TypeClass * getTypePtr() const

Kind

Lists the kind of concrete classes of Decl.

TemplateParameterList * getTemplateParameterList(unsigned index) const

unsigned getNumTemplateParameterLists() const

Represents a function declaration or definition.

QualType getReturnType() const

ArrayRef< ParmVarDecl * > parameters() const

bool isVariadic() const

Whether this function is variadic.

Declaration of a template function.

FunctionDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

Wrapper for source info for functions.

ArrayRef< ParmVarDecl * > getParams() const

TypeLoc getReturnLoc() const

Wrapper for source info for member pointers.

This represents a decl that may have a name.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

ObjCMethodDecl - Represents an instance or class method declaration.

ArrayRef< ParmVarDecl * > parameters() const

bool isInstanceMethod() const

QualType getReturnType() const

Wrapper for source info for pointers.

Wrapper of type source information for a type with non-trivial direct qualifiers.

Location wrapper for a TemplateArgument.

const TemplateArgument & getArgument() const

TypeSourceInfo * getTypeSourceInfo() const

@ Type

The template argument is a type.

ArgKind getKind() const

Return the kind of stored template argument.

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

Stores a list of template parameters for a TemplateDecl and its derived classes.

NamedDecl * getParam(unsigned Idx)

Represents the declaration of a typedef-name via a C++11 alias-declaration.

Declaration of an alias template.

TypeAliasDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

Base wrapper for a particular "section" of type source info.

UnqualTypeLoc getUnqualifiedLoc() const

Skips past any qualifiers, if this is qualified.

QualType getType() const

Get the type for which this source info wrapper provides information.

T getAs() const

Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...

TypeLoc IgnoreParens() const

A container of type source information.

TypeLoc getTypeLoc() const

Return the TypeLoc wrapper for the type source info.

Represents a variable declaration or definition.

Declaration of a variable template.

VarDecl * getTemplatedDecl() const

Get the underlying variable declarations of the template.

The JSON file list parser is used to communicate input to InstallAPI.

LLVM_READONLY bool isWhitespace(unsigned char c)

Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...

const FunctionProtoType * T