gcc/cp/cp-tree.def

   1 /* This file contains the definitions and documentation for the
   2    additional tree codes used in the GNU C++ compiler (see tree.def
   3    for the standard codes).
   4    Copyright (C) 1987-2017 Free Software Foundation, Inc.
   5    Hacked by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23
  24 /* An OFFSET_REF is used in two situations:
  25
  26    1. An expression of the form `A::m' where `A' is a class and `m' is
  27       a non-static member.  In this case, operand 0 will be a TYPE
  28       (corresponding to `A') and operand 1 will be a FIELD_DECL,
  29       BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m').
  30
  31       The expression is a pointer-to-member if its address is taken,
  32       but simply denotes a member of the object if its address is not
  33       taken.
  34
  35       This form is only used during the parsing phase; once semantic
  36       analysis has taken place they are eliminated.
  37
  38    2. An expression of the form `x.*p'.  In this case, operand 0 will
  39       be an expression corresponding to `x' and operand 1 will be an
  40       expression with pointer-to-member type.  */
  41 DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2)
  42
  43 /* A pointer-to-member constant.  For a pointer-to-member constant
  44    `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
  45    PTRMEM_CST_MEMBER is the _DECL for `Y'.  */
  46 DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0)
  47
  48 /* For NEW_EXPR, operand 0 is the placement list.
  49    Operand 1 is the new-declarator.
  50    Operand 2 is the number of elements in the array.
  51    Operand 3 is the initializer.  */
  52 DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
  53 DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3)
  54
  55 /* For DELETE_EXPR, operand 0 is the store to be destroyed.
  56    Operand 1 is the value to pass to the destroying function
  57    saying whether the store should be deallocated as well.  */
  58 DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
  59 DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2)
  60
  61 /* Value is reference to particular overloaded class method.
  62    Operand 0 is the class, operand 1 is the field
  63    The COMPLEXITY field holds the class level (usually 0).  */
  64 DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2)
  65
  66 /* When composing an object with a member, this is the result.
  67    Operand 0 is the object.  Operand 1 is the member (usually
  68    a dereferenced pointer to member).  */
  69 DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2)
  70
  71 /* Type conversion operator in C++.  TREE_TYPE is type that this
  72    operator converts to.  Operand is expression to be converted.  */
  73 DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1)
  74
  75 /* AGGR_INIT_EXPRs have a variably-sized representation similar to
  76    that of CALL_EXPRs.  Operand 0 is an INTEGER_CST node containing the
  77    operand count, operand 1 is the function which performs initialization,
  78    operand 2 is the slot which was allocated for this expression, and
  79    the remaining operands are the arguments to the initialization function.  */
  80 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_vl_exp, 3)
  81
  82 /* Initialization of an array from another array, expressed at a high level
  83    so that it works with TARGET_EXPR.  Operand 0 is the target, operand 1
  84    is the initializer.  */
  85 DEFTREECODE (VEC_INIT_EXPR, "vec_init_expr", tcc_expression, 2)
  86
  87 /* A throw expression.  operand 0 is the expression, if there was one,
  88    else it is NULL_TREE.  */
  89 DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)
  90
  91 /* An empty class object.  The TREE_TYPE gives the class type.  We use
  92    these to avoid actually creating instances of the empty classes.  */
  93 DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)
  94
  95 /* A reference to a member function or member functions from a base
  96    class.  BASELINK_FUNCTIONS gives the FUNCTION_DECL,
  97    TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
  98    functions.  BASELINK_BINFO gives the base from which the functions
  99    come, i.e., the base to which the `this' pointer must be converted
 100    before the functions are called.  BASELINK_ACCESS_BINFO gives the
 101    base used to name the functions.
 102
 103    A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
 104    the type of the expression.  This type is either a FUNCTION_TYPE,
 105    METHOD_TYPE, or `unknown_type_node' indicating that the function is
 106    overloaded.  */
 107 DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)
 108
 109 /* Template definition.  The following fields have the specified uses,
 110    although there are other macros in cp-tree.h that should be used for
 111    accessing this data.
 112         DECL_ARGUMENTS          template parm vector
 113         DECL_TEMPLATE_INFO      template text &c
 114         DECL_VINDEX             list of instantiations already produced;
 115                                 only done for functions so far
 116    For class template:
 117         DECL_INITIAL            associated templates (methods &c)
 118         DECL_TEMPLATE_RESULT    null
 119    For non-class templates:
 120         TREE_TYPE               type of object to be constructed
 121         DECL_TEMPLATE_RESULT    decl for object to be created
 122                                 (e.g., FUNCTION_DECL with tmpl parms used)
 123  */
 124 DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)
 125
 126 /* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
 127    the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
 128    gives the level (from 1) of the parameter.
 129
 130    Here's an example:
 131
 132    template <class T> // Index 0, Level 1.
 133    struct S
 134    {
 135       template <class U, // Index 0, Level 2.
 136                 class V> // Index 1, Level 2.
 137       void f();
 138    };
 139
 140    The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
 141    from this one.  The first descendant will have the same IDX, but
 142    its LEVEL will be one less.  The TREE_CHAIN field is used to chain
 143    together the descendants.  The TEMPLATE_PARM_DECL is the
 144    declaration of this parameter, either a TYPE_DECL or CONST_DECL.
 145    The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
 146    parent, i.e., the LEVEL that the parameter originally had when it
 147    was declared.  For example, if we instantiate S<int>, we will have:
 148
 149    struct S<int>
 150    {
 151      template <class U, // Index 0, Level 1, Orig Level 2
 152                class V> // Index 1, Level 1, Orig Level 2
 153      void f();
 154    };
 155
 156    The LEVEL is the level of the parameter when we are worrying about
 157    the types of things; the ORIG_LEVEL is the level when we are
 158    worrying about instantiating things.  */
 159 DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)
 160
 161 /* Index into a template parameter list for template template parameters.
 162    This parameter must be a type.  The TYPE_FIELDS value will be a
 163    TEMPLATE_PARM_INDEX.
 164
 165    It is used without template arguments like TT in C<TT>,
 166    TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
 167    and TYPE_NAME is a TEMPLATE_DECL.  */
 168 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
 169
 170 /* The ordering of the following codes is optimized for the checking
 171    macros in tree.h.  Changing the order will degrade the speed of the
 172    compiler.  TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
 173    BOUND_TEMPLATE_TEMPLATE_PARM.  */
 174
 175 /* Index into a template parameter list.  This parameter must be a type.
 176    The type.values field will be a TEMPLATE_PARM_INDEX.  */
 177 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
 178
 179 /* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
 180    TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
 181    template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
 182    TREE_TYPE is always NULL.  */
 183 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
 184
 185 /* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
 186    expression in question.  */
 187 DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
 188
 189 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
 190    like TT<int>.
 191    In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
 192    template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
 193 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
 194              tcc_type, 0)
 195
 196 /* For template template argument of the form `T::template C'.
 197    TYPE_CONTEXT is `T', the template parameter dependent object.
 198    TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
 199 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
 200
 201 /* A using declaration.  USING_DECL_SCOPE contains the specified
 202    scope.  In a variadic using-declaration, this is a TYPE_PACK_EXPANSION.
 203    In a member using decl, unless DECL_DEPENDENT_P is true,
 204    USING_DECL_DECLS contains the _DECL or OVERLOAD so named.  This is
 205    not an alias, but is later expanded into multiple aliases.  */
 206 DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
 207
 208 /* A using directive. The operand is USING_STMT_NAMESPACE.  */
 209 DEFTREECODE (USING_STMT, "using_stmt", tcc_statement, 1)
 210
 211 /* An un-parsed default argument.  Holds a vector of input tokens and
 212    a vector of places where the argument was instantiated before
 213    parsing had occurred.  */
 214 DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
 215
 216 /* An uninstantiated/unevaluated noexcept-specification.  For the
 217    uninstantiated case, DEFERRED_NOEXCEPT_PATTERN is the pattern from the
 218    template, and DEFERRED_NOEXCEPT_ARGS are the template arguments to
 219    substitute into the pattern when needed.  For the unevaluated case,
 220    those slots are NULL_TREE and we use get_defaulted_eh_spec to find
 221    the exception-specification.  */
 222 DEFTREECODE (DEFERRED_NOEXCEPT, "deferred_noexcept", tcc_exceptional, 0)
 223
 224 /* A template-id, like foo<int>.  The first operand is the template.
 225    The second is NULL if there are no explicit arguments, or a
 226    TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
 227    TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
 228    member template, the template may be an IDENTIFIER_NODE.  */
 229 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
 230
 231 /* A list-like node for chaining overloading candidates. TREE_TYPE is
 232    the original name, and the parameter is the FUNCTION_DECL.  */
 233 DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
 234
 235 /* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
 236    "OBJECT.SCOPE::~DESTRUCTOR.  The first operand is the OBJECT.  The
 237    second operand (if non-NULL) is the SCOPE.  The third operand is
 238    the TYPE node corresponding to the DESTRUCTOR.  The type of the
 239    first operand will always be a scalar type.
 240
 241    The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
 242    be used as if it were a zero-argument function.  We handle the
 243    function-call case specially, and giving it "void" type prevents it
 244    being used in expressions in ways that are not permitted.  */
 245 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
 246
 247 /* A whole bunch of tree codes for the initial, superficial parsing of
 248    templates.  */
 249 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
 250 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
 251 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
 252 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
 253 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
 254 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
 255 DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1)
 256 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
 257 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
 258 DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1)
 259
 260 /* A placeholder for an expression that is not type-dependent, but
 261    does occur in a template.  When an expression that is not
 262    type-dependent appears in a larger expression, we must compute the
 263    type of that larger expression.  That computation would normally
 264    modify the original expression, which would change the mangling of
 265    that expression if it appeared in a template argument list.  In
 266    that situation, we create a NON_DEPENDENT_EXPR to take the place of
 267    the original expression.  The expression is the only operand -- it
 268    is only needed for diagnostics.  */
 269 DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
 270
 271 /* CTOR_INITIALIZER is a placeholder in template code for a call to
 272    setup_vtbl_pointer (and appears in all functions, not just ctors).  */
 273 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
 274
 275 DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
 276
 277 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
 278
 279 /* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
 280    CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
 281    the catch variable is in HANDLER_PARMS, and the body block in
 282    HANDLER_BODY.  */
 283 DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
 284
 285 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
 286    throw, and must call terminate if it does.  The second argument
 287    is a condition, used in templates to express noexcept (condition).  */
 288 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 2)
 289
 290 /* A CLEANUP_STMT marks the point at which a declaration is fully
 291    constructed.  The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
 292    when CLEANUP_BODY completes.  */
 293 DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
 294
 295 /* Represents an 'if' statement. The operands are IF_COND,
 296    THEN_CLAUSE, and ELSE_CLAUSE, and the current scope, respectively.  */
 297 /* ??? It is currently still necessary to distinguish between IF_STMT
 298    and COND_EXPR for the benefit of templates.  */
 299 DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 4)
 300
 301 /* Used to represent a `for' statement. The operands are
 302    FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively.  */
 303 DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 5)
 304
 305 /* Used to represent a range-based `for' statement. The operands are
 306    RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, and RANGE_FOR_SCOPE,
 307    respectively.  Only used in templates.  */
 308 DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 4)
 309
 310 /* Used to represent a 'while' statement. The operands are WHILE_COND
 311    and WHILE_BODY, respectively.  */
 312 DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2)
 313
 314 /* Used to represent a 'do' statement. The operands are DO_BODY and
 315    DO_COND, respectively.  */
 316 DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2)
 317
 318 /* Used to represent a 'break' statement.  */
 319 DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0)
 320
 321 /* Used to represent a 'continue' statement.  */
 322 DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0)
 323
 324 /* Used to represent a 'switch' statement. The operands are
 325    SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE, and
 326    SWITCH_STMT_SCOPE, respectively.  */
 327 DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 4)
 328
 329 /* Used to represent an expression statement.  Use `EXPR_STMT_EXPR' to
 330    obtain the expression.  */
 331 DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
 332
 333 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
 334
 335 /* Represents an 'offsetof' expression during template expansion.  */
 336 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 2)
 337
 338 /* Represents an '__builtin_addressof' expression during template
 339    expansion.  This is similar to ADDR_EXPR, but it doesn't invoke
 340    overloaded & operators.  */
 341 DEFTREECODE (ADDRESSOF_EXPR, "addressof_expr", tcc_expression, 1)
 342
 343 /* Represents the -> operator during template expansion.  */
 344 DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
 345
 346 /* Represents an '__alignof__' expression during template
 347    expansion.  */
 348 DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)
 349
 350 /* Represents an Objective-C++ '@encode' expression during template
 351    expansion.  */
 352 DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1)
 353
 354 /* A STMT_EXPR represents a statement-expression during template
 355    expansion.  This is the GCC extension { ( ... ) }.  The
 356    STMT_EXPR_STMT is the statement given by the expression.  */
 357 DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
 358
 359 /* Unary plus. Operand 0 is the expression to which the unary plus
 360    is applied.  */
 361 DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
 362
 363 /** C++11 extensions. */
 364
 365 /* A static assertion.  This is a C++11 extension.
 366    STATIC_ASSERT_CONDITION contains the condition that is being
 367    checked.  STATIC_ASSERT_MESSAGE contains the message (a string
 368    literal) to be displayed if the condition fails to hold.  */
 369 DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0)
 370
 371 /* Represents an argument pack of types (or templates). An argument
 372    pack stores zero or more arguments that will be used to instantiate
 373    a parameter pack.
 374
 375    ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument
 376    pack.
 377
 378    Example:
 379      template<typename... Values>
 380      class tuple { ... };
 381
 382      tuple<int, float, double> t;
 383
 384    Values is a (template) parameter pack. When tuple<int, float,
 385    double> is instantiated, the Values parameter pack is instantiated
 386    with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will
 387    be a TREE_VEC containing int, float, and double.  */
 388 DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0)
 389
 390 /* Represents an argument pack of values, which can be used either for
 391    non-type template arguments or function call arguments.
 392
 393    NONTYPE_ARGUMENT_PACK plays precisely the same role as
 394    TYPE_ARGUMENT_PACK, but will be used for packing non-type template
 395    arguments (e.g., "int... Dimensions") or function arguments ("const
 396    Args&... args"). */
 397 DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1)
 398
 399 /* Represents a type expression that will be expanded into a list of
 400    types when instantiated with one or more argument packs.
 401
 402    PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is
 403    the type or expression that we will substitute into with each
 404    argument in an argument pack.
 405
 406    SET_PACK_EXPANSION_PATTERN sets the expansion pattern.
 407
 408    PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter
 409    packs that are used in this pack expansion.
 410
 411    Example:
 412      template<typename... Values>
 413      struct tied : tuple<Values&...> {
 414        // ...
 415      };
 416
 417    The derivation from tuple contains a TYPE_PACK_EXPANSION for the
 418    template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its
 419    PACK_EXPANSION_PARAMETER_PACKS will contain "Values".  */
 420 DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0)
 421
 422 /* Represents an expression that will be expanded into a list of
 423    expressions when instantiated with one or more argument packs.
 424
 425    EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION,
 426    but will be used for expressions.  */
 427 DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 3)
 428
 429 /* Selects the Ith parameter out of an argument pack. This node will
 430    be used when instantiating pack expansions; see
 431    tsubst_pack_expansion.
 432
 433    ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node
 434    from which the argument will be selected.
 435
 436    ARGUMENT_PACK_SELECT_INDEX contains the index into the argument
 437    pack that will be returned by this ARGUMENT_PACK_SELECT node. The
 438    index is a machine integer.  */
 439 DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0)
 440
 441 /* Fold expressions allow the expansion of a template argument pack
 442    over a binary operator.
 443
 444    FOLD_EXPR_MOD_P is true when the fold operation is a compound assignment
 445    operator.
 446
 447    FOLD_EXPR_OP is an INTEGER_CST storing the tree code for the folded
 448    expression. Note that when FOLDEXPR_MOD_P is true, the operator is
 449    a compound assignment operator for that kind of expression.
 450
 451    FOLD_EXPR_PACK is an expression containing an unexpanded parameter pack;
 452    when expanded, each term becomes an argument of the folded expression.
 453
 454    In a BINARY_FOLD_EXPRESSION, FOLD_EXPR_INIT is the non-pack argument. */
 455 DEFTREECODE (UNARY_LEFT_FOLD_EXPR, "unary_left_fold_expr", tcc_expression, 2)
 456 DEFTREECODE (UNARY_RIGHT_FOLD_EXPR, "unary_right_fold_expr", tcc_expression, 2)
 457 DEFTREECODE (BINARY_LEFT_FOLD_EXPR, "binary_left_fold_expr", tcc_expression, 3)
 458 DEFTREECODE (BINARY_RIGHT_FOLD_EXPR, "binary_right_fold_expr", tcc_expression, 3)
 459
 460
 461 /** C++ extensions. */
 462
 463 /* Represents a trait expression during template expansion.  */
 464 DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
 465
 466 /* A lambda expression.  This is a C++0x extension.
 467    LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
 468    none.
 469    LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'.
 470    LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists.
 471    LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to
 472    be pushed once scope returns to the lambda.
 473    LAMBDA_EXPR_MUTABLE_P signals whether this lambda was declared mutable.
 474    LAMBDA_EXPR_RETURN_TYPE holds the return type, if it was specified.  */
 475 DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0)
 476
 477 /* The declared type of an expression.  This is a C++0x extension.
 478    DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
 479    DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the
 480    expression was parsed as an id-expression or a member access
 481    expression. When false, it was parsed as a full expression.
 482    DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics.
 483    DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction.  */
 484 DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
 485
 486 /* A type designated by `__underlying_type (type)'.
 487    UNDERLYING_TYPE_TYPE is the type in question.  */
 488 DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
 489
 490 /* A type designated by one of the bases type traits.
 491    BASES_TYPE is the type in question.  */
 492 DEFTREECODE (BASES, "bases", tcc_type, 0)
 493
 494 /* Used to represent the template information stored by template
 495    specializations.
 496    The accessors are:
 497    TI_TEMPLATE the template declaration associated to the specialization
 498    TI_ARGS the arguments of the template specialization
 499    TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in
 500    the pattern of the template for which access check is needed at template
 501    instantiation time.  */
 502 DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0)
 503
 504 /* Extensions for Concepts. */
 505
 506 /* Used to represent information associated with constrained declarations. */
 507 DEFTREECODE (CONSTRAINT_INFO, "constraint_info", tcc_exceptional, 0)
 508
 509 /* A wildcard declaration is a placeholder for a template parameter
 510    used to resolve constrained-type-names in concepts.  During
 511    resolution, the matching argument is saved as the TREE_TYPE
 512    of the wildcard.  */
 513 DEFTREECODE (WILDCARD_DECL, "wildcard_decl", tcc_declaration, 0)
 514
 515 /* A requires-expr is a binary expression. The first operand is
 516    its parameter list (possibly NULL). The second is a list of
 517    requirements, which are denoted by the _REQ* tree codes
 518    below. */
 519 DEFTREECODE (REQUIRES_EXPR,   "requires_expr", tcc_expression, 2)
 520
 521 /* A requirement for an expression. */
 522 DEFTREECODE (SIMPLE_REQ, "simple_req", tcc_expression, 1)
 523
 524 /* A requirement for a type. */
 525 DEFTREECODE (TYPE_REQ, "type_req", tcc_expression, 1)
 526
 527 /* A requirement for an expression and its properties. The
 528    first operand is the expression, and the 2nd is its type.
 529    The accessor COMPOUND_REQ_NOEXCEPT determines whether
 530    the noexcept keyword was present. */
 531 DEFTREECODE (COMPOUND_REQ, "compound_req", tcc_expression, 2)
 532
 533 /* A requires clause within a requires expression. */
 534 DEFTREECODE (NESTED_REQ, "nested_req", tcc_expression, 1)
 535
 536 /* Constraints are modeled as kinds of expressions.
 537    The operands of a constraint can be either types or expressions.
 538    Unlike expressions, constraints do not have a type. */
 539
 540 /* A predicate constraint evaluates an expression E.
 541
 542    PRED_CONSTR_EXPR has the expression to be evaluated. */
 543 DEFTREECODE (PRED_CONSTR, "pred_constr", tcc_expression, 1)
 544
 545 /* A check constraint represents the checking of a concept
 546    C. It has two operands: the template defining the concept
 547    and a sequence of template arguments.
 548
 549    CHECK_CONSTR_CONCEPT has the concept definition
 550    CHECK_CONSTR_ARGUMENTS are the template arguments */
 551 DEFTREECODE (CHECK_CONSTR, "check_constr", tcc_expression, 2)
 552
 553 /* An expression constraint determines the validity of a expression E.
 554
 555    EXPR_CONST_EXPR has the expression being validated. */
 556 DEFTREECODE (EXPR_CONSTR, "expr_constr", tcc_expression, 1)
 557
 558 /* A type constraint determines the validity of a type T. Note that
 559
 560    TYPE_CONST_TYPE has the type being validated */
 561 DEFTREECODE (TYPE_CONSTR, "type_constr", tcc_expression, 1)
 562
 563 /* An implicit conversion constraint determines if an expression
 564    E is implicitly convertible to a type T. Note that T may
 565    be dependent but does not contain any placeholders.
 566
 567    ICONV_CONSTR_EXPR has the expression E.
 568    ICONV_CONSTR_TYPE has the type T.
 569    */
 570 DEFTREECODE (ICONV_CONSTR, "iconv_constr", tcc_expression, 2)
 571
 572 /* An argument deduction constraint determines if the type of an
 573    expression E can be deduced from a type pattern T. Note that
 574    T must contain at least one place holder.
 575
 576    DEDUCT_CONSTR_EXPR has the expression E
 577    DEDUCT_CONSTR_PATTERN has the type pattern T.
 578    DEDUCT_CONSTR_PLACEHOLDERS has the list of placeholder nodes in T. */
 579 DEFTREECODE (DEDUCT_CONSTR, "deduct_constr", tcc_expression, 3)
 580
 581 /* An exception constraint determines if, for an expression E,
 582    noexcept(E) is true.
 583
 584    EXCEPT_CONSTR_EXPR has the expression E. */
 585 DEFTREECODE (EXCEPT_CONSTR, "except_constr", tcc_expression, 1)
 586
 587 /* A parameterized constraint declares constraint variables, which
 588    are used in expression, type, and exception constraints.
 589
 590    PARM_CONSTR_PARMS has a TREE_LIST of parameter declarations.
 591    PARM_CONSTR_OPERAND has the nested constraint. */
 592 DEFTREECODE (PARM_CONSTR, "parm_constr", tcc_expression, 2)
 593
 594 /* The conjunction and disjunction of two constraints, respectively.
 595    Operands are accessed using TREE_OPERAND. */
 596 DEFTREECODE (CONJ_CONSTR, "conj_constr", tcc_expression, 2)
 597 DEFTREECODE (DISJ_CONSTR, "disj_constr", tcc_expression, 2)
 598
 599
 600 /*
 601 Local variables:
 602 mode:c
 603 End:
 604 */