Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Tooling/Syntax/Nodes.h
Line
Count
Source
1
//===- Nodes.h - syntax nodes for C/C++ grammar constructs ----*- C++ -*-=====//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
// Syntax tree nodes for C, C++ and Objective-C grammar constructs.
9
//
10
// Nodes provide access to their syntactic components, e.g. IfStatement provides
11
// a way to get its condition, then and else branches, tokens for 'if' and
12
// 'else' keywords.
13
// When using the accessors, please assume they can return null. This happens
14
// because:
15
//   - the corresponding subnode is optional in the C++ grammar, e.g. an else
16
//     branch of an if statement,
17
//   - syntactic errors occurred while parsing the corresponding subnode.
18
// One notable exception is "introducer" keywords, e.g. the accessor for the
19
// 'if' keyword of an if statement will never return null.
20
//===----------------------------------------------------------------------===//
21
#ifndef LLVM_CLANG_TOOLING_SYNTAX_NODES_H
22
#define LLVM_CLANG_TOOLING_SYNTAX_NODES_H
23
24
#include "clang/Basic/LLVM.h"
25
#include "clang/Tooling/Syntax/Tree.h"
26
namespace clang {
27
namespace syntax {
28
29
/// A kind of a syntax node, used for implementing casts. The ordering and
30
/// blocks of enumerator constants must correspond to the inheritance hierarchy
31
/// of syntax::Node.
32
enum class NodeKind : uint16_t {
33
#define CONCRETE_NODE(Kind, Base) Kind,
34
#include "clang/Tooling/Syntax/Nodes.inc"
35
};
36
/// For debugging purposes.
37
raw_ostream &operator<<(raw_ostream &OS, NodeKind K);
38
39
/// A relation between a parent and child node, e.g. 'left-hand-side of
40
/// a binary expression'. Used for implementing accessors.
41
///
42
/// In general `NodeRole`s should be named the same as their accessors.
43
///
44
/// Some roles describe parent/child relations that occur multiple times in
45
/// language grammar. We define only one role to describe all instances of such
46
/// recurring relations. For example, grammar for both "if" and "while"
47
/// statements requires an opening paren and a closing paren. The opening
48
/// paren token is assigned the OpenParen role regardless of whether it appears
49
/// as a child of IfStatement or WhileStatement node. More generally, when
50
/// grammar requires a certain fixed token (like a specific keyword, or an
51
/// opening paren), we define a role for this token and use it across all
52
/// grammar rules with the same requirement. Names of such reusable roles end
53
/// with a ~Token or a ~Keyword suffix.
54
enum class NodeRole : uint8_t {
55
  // Roles common to multiple node kinds.
56
  /// A node without a parent
57
  Detached,
58
  /// Children of an unknown semantic nature, e.g. skipped tokens, comments.
59
  Unknown,
60
  /// An opening parenthesis in argument lists and blocks, e.g. '{', '(', etc.
61
  OpenParen,
62
  /// A closing parenthesis in argument lists and blocks, e.g. '}', ')', etc.
63
  CloseParen,
64
  /// A keywords that introduces some grammar construct, e.g. 'if', 'try', etc.
65
  IntroducerKeyword,
66
  /// A token that represents a literal, e.g. 'nullptr', '1', 'true', etc.
67
  LiteralToken,
68
  /// Tokens or Keywords.
69
  ArrowToken,
70
  ExternKeyword,
71
  TemplateKeyword,
72
  /// An inner statement for those that have only a single child of kind
73
  /// statement, e.g. loop body for while, for, etc; inner statement for case,
74
  /// default, etc.
75
  BodyStatement,
76
  /// List API roles.
77
  ListElement,
78
  ListDelimiter,
79
80
  // Roles specific to particular node kinds.
81
  OperatorToken,
82
  Operand,
83
  LeftHandSide,
84
  RightHandSide,
85
  ReturnValue,
86
  CaseValue,
87
  ThenStatement,
88
  ElseKeyword,
89
  ElseStatement,
90
  Expression,
91
  Statement,
92
  Condition,
93
  Message,
94
  Declarator,
95
  Declaration,
96
  Size,
97
  Parameters,
98
  TrailingReturn,
99
  UnqualifiedId,
100
  Qualifier,
101
  SubExpression,
102
  Object,
103
  AccessToken,
104
  Member,
105
  Callee,
106
  Arguments,
107
  Declarators
108
};
109
/// For debugging purposes.
110
raw_ostream &operator<<(raw_ostream &OS, NodeRole R);
111
112
#include "clang/Tooling/Syntax/NodeClasses.inc"
113
114
/// Models a `nested-name-specifier`. C++ [expr.prim.id.qual]
115
/// e.g. the `std::vector<int>::` in `std::vector<int>::size`.
116
class NestedNameSpecifier final : public List {
117
public:
118
241
  NestedNameSpecifier() : List(NodeKind::NestedNameSpecifier) {}
119
  static bool classof(const Node *N);
120
  std::vector<NameSpecifier *> getSpecifiers();
121
  std::vector<List::ElementAndDelimiter<syntax::NameSpecifier>>
122
  getSpecifiersAndDoubleColons();
123
};
124
125
/// Models an `unqualified-id`. C++ [expr.prim.id.unqual]
126
/// e.g. the `size` in `std::vector<int>::size`.
127
class UnqualifiedId final : public Tree {
128
public:
129
1.25k
  UnqualifiedId() : Tree(NodeKind::UnqualifiedId) {}
130
  static bool classof(const Node *N);
131
};
132
133
/// An expression of an unknown kind, i.e. one not currently handled by the
134
/// syntax tree.
135
class UnknownExpression final : public Expression {
136
public:
137
1.44k
  UnknownExpression() : Expression(NodeKind::UnknownExpression) {}
138
  static bool classof(const Node *N);
139
};
140
141
/// Models arguments of a function call.
142
///   call-arguments:
143
///     delimited_list(expression, ',')
144
/// Note: This construct is a simplification of the grammar rule for
145
/// `expression-list`, that is used in the definition of `call-expression`
146
class CallArguments final : public List {
147
public:
148
521
  CallArguments() : List(NodeKind::CallArguments) {}
149
  static bool classof(const Node *N);
150
  std::vector<Expression *> getArguments();
151
  std::vector<List::ElementAndDelimiter<Expression>> getArgumentsAndCommas();
152
};
153
154
/// An abstract class for prefix and postfix unary operators.
155
class UnaryOperatorExpression : public Expression {
156
public:
157
262
  UnaryOperatorExpression(NodeKind K) : Expression(K) {}
158
  static bool classof(const Node *N);
159
  Leaf *getOperatorToken();
160
  Expression *getOperand();
161
};
162
163
/// <operator> <operand>
164
///
165
/// For example:
166
///   +a          -b
167
///   !c          not c
168
///   ~d          compl d
169
///   *e          &f
170
///   ++h         --h
171
///   __real i    __imag i
172
class PrefixUnaryOperatorExpression final : public UnaryOperatorExpression {
173
public:
174
  PrefixUnaryOperatorExpression()
175
224
      : UnaryOperatorExpression(NodeKind::PrefixUnaryOperatorExpression) {}
176
  static bool classof(const Node *N);
177
};
178
179
/// <operand> <operator>
180
///
181
/// For example:
182
///   a++
183
///   b--
184
class PostfixUnaryOperatorExpression final : public UnaryOperatorExpression {
185
public:
186
  PostfixUnaryOperatorExpression()
187
38
      : UnaryOperatorExpression(NodeKind::PostfixUnaryOperatorExpression) {}
188
  static bool classof(const Node *N);
189
};
190
191
/// <lhs> <operator> <rhs>
192
///
193
/// For example:
194
///   a + b
195
///   a bitor 1
196
///   a |= b
197
///   a and_eq b
198
class BinaryOperatorExpression final : public Expression {
199
public:
200
526
  BinaryOperatorExpression() : Expression(NodeKind::BinaryOperatorExpression) {}
201
  static bool classof(const Node *N);
202
  Expression *getLhs();
203
  Leaf *getOperatorToken();
204
  Expression *getRhs();
205
};
206
207
/// An abstract node for C++ statements, e.g. 'while', 'if', etc.
208
/// FIXME: add accessors for semicolon of statements that have it.
209
class Statement : public Tree {
210
public:
211
3.75k
  Statement(NodeKind K) : Tree(K) {}
212
  static bool classof(const Node *N);
213
};
214
215
/// A statement of an unknown kind, i.e. one not currently handled by the syntax
216
/// tree.
217
class UnknownStatement final : public Statement {
218
public:
219
14
  UnknownStatement() : Statement(NodeKind::UnknownStatement) {}
220
  static bool classof(const Node *N);
221
};
222
223
/// E.g. 'int a, b = 10;'
224
class DeclarationStatement final : public Statement {
225
public:
226
196
  DeclarationStatement() : Statement(NodeKind::DeclarationStatement) {}
227
  static bool classof(const Node *N);
228
};
229
230
/// The no-op statement, i.e. ';'.
231
class EmptyStatement final : public Statement {
232
public:
233
64
  EmptyStatement() : Statement(NodeKind::EmptyStatement) {}
234
  static bool classof(const Node *N);
235
};
236
237
/// switch (<cond>) <body>
238
class SwitchStatement final : public Statement {
239
public:
240
14
  SwitchStatement() : Statement(NodeKind::SwitchStatement) {}
241
  static bool classof(const Node *N);
242
  Leaf *getSwitchKeyword();
243
  Statement *getBody();
244
};
245
246
/// case <value>: <body>
247
class CaseStatement final : public Statement {
248
public:
249
14
  CaseStatement() : Statement(NodeKind::CaseStatement) {}
250
  static bool classof(const Node *N);
251
  Leaf *getCaseKeyword();
252
  Expression *getCaseValue();
253
  Statement *getBody();
254
};
255
256
/// default: <body>
257
class DefaultStatement final : public Statement {
258
public:
259
14
  DefaultStatement() : Statement(NodeKind::DefaultStatement) {}
260
  static bool classof(const Node *N);
261
  Leaf *getDefaultKeyword();
262
  Statement *getBody();
263
};
264
265
/// if (cond) <then-statement> else <else-statement>
266
/// FIXME: add condition that models 'expression  or variable declaration'
267
class IfStatement final : public Statement {
268
public:
269
134
  IfStatement() : Statement(NodeKind::IfStatement) {}
270
  static bool classof(const Node *N);
271
  Leaf *getIfKeyword();
272
  Statement *getThenStatement();
273
  Leaf *getElseKeyword();
274
  Statement *getElseStatement();
275
};
276
277
/// for (<init>; <cond>; <increment>) <body>
278
class ForStatement final : public Statement {
279
public:
280
14
  ForStatement() : Statement(NodeKind::ForStatement) {}
281
  static bool classof(const Node *N);
282
  Leaf *getForKeyword();
283
  Statement *getBody();
284
};
285
286
/// while (<cond>) <body>
287
class WhileStatement final : public Statement {
288
public:
289
14
  WhileStatement() : Statement(NodeKind::WhileStatement) {}
290
  static bool classof(const Node *N);
291
  Leaf *getWhileKeyword();
292
  Statement *getBody();
293
};
294
295
/// continue;
296
class ContinueStatement final : public Statement {
297
public:
298
42
  ContinueStatement() : Statement(NodeKind::ContinueStatement) {}
299
  static bool classof(const Node *N);
300
  Leaf *getContinueKeyword();
301
};
302
303
/// break;
304
class BreakStatement final : public Statement {
305
public:
306
14
  BreakStatement() : Statement(NodeKind::BreakStatement) {}
307
  static bool classof(const Node *N);
308
  Leaf *getBreakKeyword();
309
};
310
311
/// return <expr>;
312
/// return;
313
class ReturnStatement final : public Statement {
314
public:
315
74
  ReturnStatement() : Statement(NodeKind::ReturnStatement) {}
316
  static bool classof(const Node *N);
317
  Leaf *getReturnKeyword();
318
  Expression *getReturnValue();
319
};
320
321
/// for (<decl> : <init>) <body>
322
class RangeBasedForStatement final : public Statement {
323
public:
324
8
  RangeBasedForStatement() : Statement(NodeKind::RangeBasedForStatement) {}
325
  static bool classof(const Node *N);
326
  Leaf *getForKeyword();
327
  Statement *getBody();
328
};
329
330
/// Expression in a statement position, e.g. functions calls inside compound
331
/// statements or inside a loop body.
332
class ExpressionStatement final : public Statement {
333
public:
334
1.66k
  ExpressionStatement() : Statement(NodeKind::ExpressionStatement) {}
335
  static bool classof(const Node *N);
336
  Expression *getExpression();
337
};
338
339
/// { statement1; statement2; … }
340
class CompoundStatement final : public Statement {
341
public:
342
1.47k
  CompoundStatement() : Statement(NodeKind::CompoundStatement) {}
343
  static bool classof(const Node *N);
344
  Leaf *getLbrace();
345
  /// FIXME: use custom iterator instead of 'vector'.
346
  std::vector<Statement *> getStatements();
347
  Leaf *getRbrace();
348
};
349
350
/// A declaration that can appear at the top-level. Note that this does *not*
351
/// correspond 1-to-1 to clang::Decl. Syntax trees distinguish between top-level
352
/// declarations (e.g. namespace definitions) and declarators (e.g. variables,
353
/// typedefs, etc.). Declarators are stored inside SimpleDeclaration.
354
class Declaration : public Tree {
355
public:
356
6.28k
  Declaration(NodeKind K) : Tree(K) {}
357
  static bool classof(const Node *N);
358
};
359
360
/// Declaration of an unknown kind, e.g. not yet supported in syntax trees.
361
class UnknownDeclaration final : public Declaration {
362
public:
363
331
  UnknownDeclaration() : Declaration(NodeKind::UnknownDeclaration) {}
364
  static bool classof(const Node *N);
365
};
366
367
/// A semicolon in the top-level context. Does not declare anything.
368
class EmptyDeclaration final : public Declaration {
369
public:
370
14
  EmptyDeclaration() : Declaration(NodeKind::EmptyDeclaration) {}
371
  static bool classof(const Node *N);
372
};
373
374
/// static_assert(<condition>, <message>)
375
/// static_assert(<condition>)
376
class StaticAssertDeclaration final : public Declaration {
377
public:
378
12
  StaticAssertDeclaration() : Declaration(NodeKind::StaticAssertDeclaration) {}
379
  static bool classof(const Node *N);
380
  Expression *getCondition();
381
  Expression *getMessage();
382
};
383
384
/// extern <string-literal> declaration
385
/// extern <string-literal> { <decls>  }
386
class LinkageSpecificationDeclaration final : public Declaration {
387
public:
388
  LinkageSpecificationDeclaration()
389
20
      : Declaration(NodeKind::LinkageSpecificationDeclaration) {}
390
  static bool classof(const Node *N);
391
};
392
393
class DeclaratorList final : public List {
394
public:
395
4.56k
  DeclaratorList() : List(NodeKind::DeclaratorList) {}
396
  static bool classof(const Node *N);
397
  std::vector<SimpleDeclarator *> getDeclarators();
398
  std::vector<List::ElementAndDelimiter<syntax::SimpleDeclarator>>
399
  getDeclaratorsAndCommas();
400
};
401
402
/// Groups multiple declarators (e.g. variables, typedefs, etc.) together. All
403
/// grouped declarators share the same declaration specifiers (e.g. 'int' or
404
/// 'typedef').
405
class SimpleDeclaration final : public Declaration {
406
public:
407
5.43k
  SimpleDeclaration() : Declaration(NodeKind::SimpleDeclaration) {}
408
  static bool classof(const Node *N);
409
  /// FIXME: use custom iterator instead of 'vector'.
410
  std::vector<SimpleDeclarator *> getDeclarators();
411
};
412
413
/// template <template-parameters> <declaration>
414
class TemplateDeclaration final : public Declaration {
415
public:
416
303
  TemplateDeclaration() : Declaration(NodeKind::TemplateDeclaration) {}
417
  static bool classof(const Node *N);
418
  Leaf *getTemplateKeyword();
419
  Declaration *getDeclaration();
420
};
421
422
/// template <declaration>
423
/// Examples:
424
///     template struct X<int>
425
///     template void foo<int>()
426
///     template int var<double>
427
class ExplicitTemplateInstantiation final : public Declaration {
428
public:
429
  ExplicitTemplateInstantiation()
430
20
      : Declaration(NodeKind::ExplicitTemplateInstantiation) {}
431
  static bool classof(const Node *N);
432
  Leaf *getTemplateKeyword();
433
  Leaf *getExternKeyword();
434
  Declaration *getDeclaration();
435
};
436
437
/// namespace <name> { <decls> }
438
class NamespaceDefinition final : public Declaration {
439
public:
440
94
  NamespaceDefinition() : Declaration(NodeKind::NamespaceDefinition) {}
441
  static bool classof(const Node *N);
442
};
443
444
/// namespace <name> = <namespace-reference>
445
class NamespaceAliasDefinition final : public Declaration {
446
public:
447
  NamespaceAliasDefinition()
448
10
      : Declaration(NodeKind::NamespaceAliasDefinition) {}
449
  static bool classof(const Node *N);
450
};
451
452
/// using namespace <name>
453
class UsingNamespaceDirective final : public Declaration {
454
public:
455
10
  UsingNamespaceDirective() : Declaration(NodeKind::UsingNamespaceDirective) {}
456
  static bool classof(const Node *N);
457
};
458
459
/// using <scope>::<name>
460
/// using typename <scope>::<name>
461
class UsingDeclaration final : public Declaration {
462
public:
463
30
  UsingDeclaration() : Declaration(NodeKind::UsingDeclaration) {}
464
  static bool classof(const Node *N);
465
};
466
467
/// using <name> = <type>
468
class TypeAliasDeclaration final : public Declaration {
469
public:
470
8
  TypeAliasDeclaration() : Declaration(NodeKind::TypeAliasDeclaration) {}
471
  static bool classof(const Node *N);
472
};
473
474
/// Covers a name, an initializer and a part of the type outside declaration
475
/// specifiers. Examples are:
476
///     `*a` in `int *a`
477
///     `a[10]` in `int a[10]`
478
///     `*a = nullptr` in `int *a = nullptr`
479
/// Declarators can be unnamed too:
480
///     `**` in `new int**`
481
///     `* = nullptr` in `void foo(int* = nullptr)`
482
/// Most declarators you encounter are instances of SimpleDeclarator. They may
483
/// contain an inner declarator inside parentheses, we represent it as
484
/// ParenDeclarator. E.g.
485
///     `(*a)` in `int (*a) = 10`
486
class Declarator : public Tree {
487
public:
488
4.28k
  Declarator(NodeKind K) : Tree(K) {}
489
  static bool classof(const Node *N);
490
};
491
492
/// A top-level declarator without parentheses. See comment of Declarator for
493
/// more details.
494
class SimpleDeclarator final : public Declarator {
495
public:
496
4.12k
  SimpleDeclarator() : Declarator(NodeKind::SimpleDeclarator) {}
497
  static bool classof(const Node *N);
498
};
499
500
/// Declarator inside parentheses.
501
/// E.g. `(***a)` from `int (***a) = nullptr;`
502
/// See comment of Declarator for more details.
503
class ParenDeclarator final : public Declarator {
504
public:
505
156
  ParenDeclarator() : Declarator(NodeKind::ParenDeclarator) {}
506
  static bool classof(const Node *N);
507
  Leaf *getLparen();
508
  Leaf *getRparen();
509
};
510
511
/// Array size specified inside a declarator.
512
/// E.g:
513
///   `[10]` in `int a[10];`
514
///   `[static 10]` in `void f(int xs[static 10]);`
515
class ArraySubscript final : public Tree {
516
public:
517
88
  ArraySubscript() : Tree(NodeKind::ArraySubscript) {}
518
  static bool classof(const Node *N);
519
  // TODO: add an accessor for the "static" keyword.
520
  Leaf *getLbracket();
521
  Expression *getSize();
522
  Leaf *getRbracket();
523
};
524
525
/// Trailing return type after the parameter list, including the arrow token.
526
/// E.g. `-> int***`.
527
class TrailingReturnType final : public Tree {
528
public:
529
24
  TrailingReturnType() : Tree(NodeKind::TrailingReturnType) {}
530
  static bool classof(const Node *N);
531
  // TODO: add accessors for specifiers.
532
  Leaf *getArrowToken();
533
  // FIXME: This should be a `type-id` following the grammar. Fix this once we
534
  // have a representation of `type-id`s.
535
  SimpleDeclarator *getDeclarator();
536
};
537
538
/// Models a `parameter-declaration-list` which appears within
539
/// `parameters-and-qualifiers`. See C++ [dcl.fct]
540
class ParameterDeclarationList final : public List {
541
public:
542
2.33k
  ParameterDeclarationList() : List(NodeKind::ParameterDeclarationList) {}
543
  static bool classof(const Node *N);
544
  std::vector<SimpleDeclaration *> getParameterDeclarations();
545
  std::vector<List::ElementAndDelimiter<syntax::SimpleDeclaration>>
546
  getParametersAndCommas();
547
};
548
549
/// Parameter list for a function type and a trailing return type, if the
550
/// function has one.
551
/// E.g.:
552
///  `(int a) volatile ` in `int foo(int a) volatile;`
553
///  `(int a) &&` in `int foo(int a) &&;`
554
///  `() -> int` in `auto foo() -> int;`
555
///  `() const` in `int foo() const;`
556
///  `() noexcept` in `int foo() noexcept;`
557
///  `() throw()` in `int foo() throw();`
558
///
559
/// (!) override doesn't belong here.
560
class ParametersAndQualifiers final : public Tree {
561
public:
562
2.35k
  ParametersAndQualifiers() : Tree(NodeKind::ParametersAndQualifiers) {}
563
  static bool classof(const Node *N);
564
  Leaf *getLparen();
565
  ParameterDeclarationList *getParameters();
566
  Leaf *getRparen();
567
  TrailingReturnType *getTrailingReturn();
568
};
569
570
/// Member pointer inside a declarator
571
/// E.g. `X::*` in `int X::* a = 0;`
572
class MemberPointer final : public Tree {
573
public:
574
70
  MemberPointer() : Tree(NodeKind::MemberPointer) {}
575
  static bool classof(const Node *N);
576
};
577
578
#define CONCRETE_NODE(Kind, Base)                                              \
579
225k
  inline bool Kind::classof(const Node *N) {                                   \
580
225k
    return N->getKind() == NodeKind::Kind;                                     \
581
225k
  }
clang::syntax::Leaf::classof(clang::syntax::Node const*)
Line
Count
Source
579
222k
  inline bool Kind::classof(const Node *N) {                                   \
580
222k
    return N->getKind() == NodeKind::Kind;                                     \
581
222k
  }
Unexecuted instantiation: clang::syntax::ArraySubscript::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::EmptyDeclaration::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ExplicitTemplateInstantiation::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::LinkageSpecificationDeclaration::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::NamespaceAliasDefinition::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::NamespaceDefinition::classof(clang::syntax::Node const*)
clang::syntax::SimpleDeclaration::classof(clang::syntax::Node const*)
Line
Count
Source
579
20
  inline bool Kind::classof(const Node *N) {                                   \
580
20
    return N->getKind() == NodeKind::Kind;                                     \
581
20
  }
Unexecuted instantiation: clang::syntax::StaticAssertDeclaration::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::TemplateDeclaration::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::TypeAliasDeclaration::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::UnknownDeclaration::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::UsingDeclaration::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::UsingNamespaceDirective::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ParenDeclarator::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::SimpleDeclarator::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::BinaryOperatorExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::CallExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::IdExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::BoolLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::CharacterLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::CxxNullPtrExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::FloatingLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::IntegerLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::StringLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::CharUserDefinedLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::FloatUserDefinedLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::IntegerUserDefinedLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::StringUserDefinedLiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::MemberExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ParenExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ThisExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::UnknownExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::CallArguments::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::DeclaratorList::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::NestedNameSpecifier::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ParameterDeclarationList::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::MemberPointer::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::DecltypeNameSpecifier::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::GlobalNameSpecifier::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::IdentifierNameSpecifier::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::SimpleTemplateNameSpecifier::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ParametersAndQualifiers::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::BreakStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::CaseStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ContinueStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::DeclarationStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::DefaultStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ExpressionStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ForStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::IfStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::RangeBasedForStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::ReturnStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::SwitchStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::UnknownStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::WhileStatement::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::TrailingReturnType::classof(clang::syntax::Node const*)
clang::syntax::TranslationUnit::classof(clang::syntax::Node const*)
Line
Count
Source
579
2.16k
  inline bool Kind::classof(const Node *N) {                                   \
580
2.16k
    return N->getKind() == NodeKind::Kind;                                     \
581
2.16k
  }
Unexecuted instantiation: clang::syntax::PostfixUnaryOperatorExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::PrefixUnaryOperatorExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::UnqualifiedId::classof(clang::syntax::Node const*)
clang::syntax::CompoundStatement::classof(clang::syntax::Node const*)
Line
Count
Source
579
42
  inline bool Kind::classof(const Node *N) {                                   \
580
42
    return N->getKind() == NodeKind::Kind;                                     \
581
42
  }
clang::syntax::EmptyStatement::classof(clang::syntax::Node const*)
Line
Count
Source
579
42
  inline bool Kind::classof(const Node *N) {                                   \
580
42
    return N->getKind() == NodeKind::Kind;                                     \
581
42
  }
582
#define ABSTRACT_NODE(Kind, Base, First, Last)                                 \
583
337k
  inline bool Kind::classof(const Node *N) {                                   \
584
337k
    return N->getKind() >= NodeKind::First && 
N->getKind() <= NodeKind::Last209k
; \
585
337k
  }
clang::syntax::Tree::classof(clang::syntax::Node const*)
Line
Count
Source
583
305k
  inline bool Kind::classof(const Node *N) {                                   \
584
305k
    return N->getKind() >= NodeKind::First && 
N->getKind() <= NodeKind::Last193k
; \
585
305k
  }
Unexecuted instantiation: clang::syntax::Declaration::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::Declarator::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::Expression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::LiteralExpression::classof(clang::syntax::Node const*)
Unexecuted instantiation: clang::syntax::UserDefinedLiteralExpression::classof(clang::syntax::Node const*)
clang::syntax::List::classof(clang::syntax::Node const*)
Line
Count
Source
583
32.4k
  inline bool Kind::classof(const Node *N) {                                   \
584
32.4k
    return N->getKind() >= NodeKind::First && 
N->getKind() <= NodeKind::Last15.8k
; \
585
32.4k
  }
Unexecuted instantiation: clang::syntax::NameSpecifier::classof(clang::syntax::Node const*)
clang::syntax::Statement::classof(clang::syntax::Node const*)
Line
Count
Source
583
42
  inline bool Kind::classof(const Node *N) {                                   \
584
42
    return N->getKind() >= NodeKind::First && N->getKind() <= NodeKind::Last;  \
585
42
  }
Unexecuted instantiation: clang::syntax::UnaryOperatorExpression::classof(clang::syntax::Node const*)
586
#include "clang/Tooling/Syntax/Nodes.inc"
587
588
} // namespace syntax
589
} // namespace clang
590
#endif