llvm/tools/clang/include/clang/Tooling/Syntax/NodeClasses.inc

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Syntax tree node list                                                      *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: Nodes.td                                                             *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/


// Forward-declare node types so we don't have to carefully sequence definitions.
class Node;
class Leaf;
class Tree;
class ArraySubscript;
class Declaration;
class EmptyDeclaration;
class ExplicitTemplateInstantiation;
class LinkageSpecificationDeclaration;
class NamespaceAliasDefinition;
class NamespaceDefinition;
class SimpleDeclaration;
class StaticAssertDeclaration;
class TemplateDeclaration;
class TypeAliasDeclaration;
class UnknownDeclaration;
class UsingDeclaration;
class UsingNamespaceDirective;
class Declarator;
class ParenDeclarator;
class SimpleDeclarator;
class Expression;
class BinaryOperatorExpression;
class CallExpression;
class IdExpression;
class LiteralExpression;
class BoolLiteralExpression;
class CharacterLiteralExpression;
class CxxNullPtrExpression;
class FloatingLiteralExpression;
class IntegerLiteralExpression;
class StringLiteralExpression;
class UserDefinedLiteralExpression;
class CharUserDefinedLiteralExpression;
class FloatUserDefinedLiteralExpression;
class IntegerUserDefinedLiteralExpression;
class StringUserDefinedLiteralExpression;
class MemberExpression;
class ParenExpression;
class ThisExpression;
class UnknownExpression;
class List;
class CallArguments;
class DeclaratorList;
class NestedNameSpecifier;
class ParameterDeclarationList;
class MemberPointer;
class NameSpecifier;
class DecltypeNameSpecifier;
class GlobalNameSpecifier;
class IdentifierNameSpecifier;
class SimpleTemplateNameSpecifier;
class ParametersAndQualifiers;
class Statement;
class BreakStatement;
class CaseStatement;
class CompoundStatement;
class ContinueStatement;
class DeclarationStatement;
class DefaultStatement;
class EmptyStatement;
class ExpressionStatement;
class ForStatement;
class IfStatement;
class RangeBasedForStatement;
class ReturnStatement;
class SwitchStatement;
class UnknownStatement;
class WhileStatement;
class TrailingReturnType;
class TranslationUnit;
class UnaryOperatorExpression;
class PostfixUnaryOperatorExpression;
class PrefixUnaryOperatorExpression;
class UnqualifiedId;

// Node definitions

/// A base class for all expressions. Note that expressions are not statements,
/// even though they are in clang.
class Expression : public Tree { … };

/// A function call. C++ [expr.call]
/// call-expression:
///   expression '(' call-arguments ')'
/// e.g `f(1, '2')` or `this->Base::f()`
class CallExpression final : public Expression { … };

/// Models an `id-expression`, e.g. `std::vector<int>::size`.
/// C++ [expr.prim.id]
/// id-expression:
///   unqualified-id
///   qualified-id
/// qualified-id:
///   nested-name-specifier template_opt unqualified-id
class IdExpression final : public Expression { … };

/// Expression for literals. C++ [lex.literal]
class LiteralExpression : public Expression { … };

/// Expression for boolean literals. C++ [lex.bool]
class BoolLiteralExpression final : public LiteralExpression { … };

/// Expression for character literals. C++ [lex.ccon]
class CharacterLiteralExpression final : public LiteralExpression { … };

/// Expression for the `nullptr` literal. C++ [lex.nullptr]
class CxxNullPtrExpression final : public LiteralExpression { … };

/// Expression for floating-point literals. C++ [lex.fcon]
class FloatingLiteralExpression final : public LiteralExpression { … };

/// Expression for integer literals. C++ [lex.icon]
class IntegerLiteralExpression final : public LiteralExpression { … };

/// Expression for string-literals. C++ [lex.string]
class StringLiteralExpression final : public LiteralExpression { … };

/// Expression for user-defined literal. C++ [lex.ext]
/// user-defined-literal:
///   user-defined-integer-literal
///   user-defined-floating-point-literal
///   user-defined-string-literal
///   user-defined-character-literal
class UserDefinedLiteralExpression : public LiteralExpression { … };

/// Expression for user-defined-character-literal. C++ [lex.ext]
class CharUserDefinedLiteralExpression final : public UserDefinedLiteralExpression { … };

/// Expression for user-defined-floating-point-literal. C++ [lex.ext]
class FloatUserDefinedLiteralExpression final : public UserDefinedLiteralExpression { … };

/// Expression for user-defined-integer-literal. C++ [lex.ext]
class IntegerUserDefinedLiteralExpression final : public UserDefinedLiteralExpression { … };

/// Expression for user-defined-string-literal. C++ [lex.ext]
class StringUserDefinedLiteralExpression final : public UserDefinedLiteralExpression { … };

/// Models a class member access. C++ [expr.ref]
/// member-expression:
///   expression -> template_opt id-expression
///   expression .  template_opt id-expression
/// e.g. `x.a`, `xp->a`
/// 
/// Note: An implicit member access inside a class, i.e. `a` instead of
/// `this->a`, is an `id-expression`.
class MemberExpression final : public Expression { … };

/// Models a parenthesized expression `(E)`. C++ [expr.prim.paren]
/// e.g. `(3 + 2)` in `a = 1 + (3 + 2);`
class ParenExpression final : public Expression { … };

/// Models a this expression `this`. C++ [expr.prim.this]
class ThisExpression final : public Expression { … };

/// A sequence of these specifiers make a `nested-name-specifier`.
/// e.g. the `std` or `vector<int>` in `std::vector<int>::size`.
class NameSpecifier : public Tree { … };

/// A name specifier holding a decltype, of the form: `decltype ( expression ) `
/// e.g. the `decltype(s)` in `decltype(s)::size`.
class DecltypeNameSpecifier final : public NameSpecifier { … };

/// The global namespace name specifier, this specifier doesn't correspond to a
/// token instead an absence of tokens before a `::` characterizes it, in
/// `::std::vector<int>` it would be characterized by the absence of a token
/// before the first `::`
class GlobalNameSpecifier final : public NameSpecifier { … };

/// A identifier name specifier, of the form `identifier`
/// e.g. the `std` in `std::vector<int>::size`.
class IdentifierNameSpecifier final : public NameSpecifier { … };

/// A name specifier with a simple-template-id, of the form `template_opt
/// identifier < template-args >` e.g. the `vector<int>` in
/// `std::vector<int>::size`.
class SimpleTemplateNameSpecifier final : public NameSpecifier { … };

/// A root node for a translation unit. Parent is always null.
class TranslationUnit final : public Tree { … };