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
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 3, or (at your option)
12any later version.
13
14GCC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along 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. */
41DEFTREECODE (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'. */
46DEFTREECODE (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. */
52DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
53DEFTREECODE (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. */
58DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
59DEFTREECODE (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). */
64DEFTREECODE (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). */
69DEFTREECODE (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. */
73DEFTREECODE (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. */
80DEFTREECODE (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. */
85DEFTREECODE (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. */
89DEFTREECODE (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. */
93DEFTREECODE (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. */
107DEFTREECODE (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 */
124DEFTREECODE (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. */
159DEFTREECODE (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 TYPE_NAME is a TEMPLATE_DECL. */
167DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
168
169/* The ordering of the following codes is optimized for the checking
170 macros in tree.h. Changing the order will degrade the speed of the
171 compiler. TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
172 BOUND_TEMPLATE_TEMPLATE_PARM. */
173
174/* Index into a template parameter list. This parameter must be a type.
175 The type.values field will be a TEMPLATE_PARM_INDEX. */
176DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
177
178/* A type designated by `typename T::t'. TYPE_CONTEXT is `T',
179 TYPE_NAME is an IDENTIFIER_NODE for `t'. If the type was named via
180 template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
181 TREE_TYPE is always NULL. */
182DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
183
184/* A type designated by `__typeof (expr)'. TYPEOF_TYPE_EXPR is the
185 expression in question. */
186DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
187
188/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
189 like TT<int>.
190 In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
191 template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */
192DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
193 tcc_type, 0)
194
195/* For template template argument of the form `T::template C'.
196 TYPE_CONTEXT is `T', the template parameter dependent object.
197 TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template. */
198DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
199
200/* A using declaration. USING_DECL_SCOPE contains the specified
201 scope. In a variadic using-declaration, this is a TYPE_PACK_EXPANSION.
202 In a member using decl, unless DECL_DEPENDENT_P is true,
203 USING_DECL_DECLS contains the _DECL or OVERLOAD so named. This is
204 not an alias, but is later expanded into multiple aliases. */
205DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
206
207/* A using directive. The operand is USING_STMT_NAMESPACE. */
208DEFTREECODE (USING_STMT, "using_stmt", tcc_statement, 1)
209
210/* An un-parsed default argument. Holds a vector of input tokens and
211 a vector of places where the argument was instantiated before
212 parsing had occurred. */
213DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
214
215/* An uninstantiated/unevaluated noexcept-specification. For the
216 uninstantiated case, DEFERRED_NOEXCEPT_PATTERN is the pattern from the
217 template, and DEFERRED_NOEXCEPT_ARGS are the template arguments to
218 substitute into the pattern when needed. For the unevaluated case,
219 those slots are NULL_TREE and we use get_defaulted_eh_spec to find
220 the exception-specification. */
221DEFTREECODE (DEFERRED_NOEXCEPT, "deferred_noexcept", tcc_exceptional, 0)
222
223/* A template-id, like foo<int>. The first operand is the template.
224 The second is NULL if there are no explicit arguments, or a
225 TREE_VEC of arguments. The template will be a FUNCTION_DECL,
226 TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a
227 member template, the template may be an IDENTIFIER_NODE. */
228DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
229
230/* One of a set of overloaded functions. */
231DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
232
233/* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
234 "OBJECT.SCOPE::~DESTRUCTOR. The first operand is the OBJECT. The
235 second operand (if non-NULL) is the SCOPE. The third operand is
236 the TYPE node corresponding to the DESTRUCTOR. The type of the
237 first operand will always be a scalar type.
238
239 The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
240 be used as if it were a zero-argument function. We handle the
241 function-call case specially, and giving it "void" type prevents it
242 being used in expressions in ways that are not permitted. */
243DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
244
245/* A whole bunch of tree codes for the initial, superficial parsing of
246 templates. */
247DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
248DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
249DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
250DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
251DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
252DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
253DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1)
254DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
255DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
256DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1)
257
258/* A placeholder for an expression that is not type-dependent, but
259 does occur in a template. When an expression that is not
260 type-dependent appears in a larger expression, we must compute the
261 type of that larger expression. That computation would normally
262 modify the original expression, which would change the mangling of
263 that expression if it appeared in a template argument list. In
264 that situation, we create a NON_DEPENDENT_EXPR to take the place of
265 the original expression. The expression is the only operand -- it
266 is only needed for diagnostics. */
267DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
268
269/* CTOR_INITIALIZER is a placeholder in template code for a call to
270 setup_vtbl_pointer (and appears in all functions, not just ctors). */
271DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
272
273DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
274
275DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
276
277/* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is
278 CATCH_ALL_TYPE, then the handler catches all types. The declaration of
279 the catch variable is in HANDLER_PARMS, and the body block in
280 HANDLER_BODY. */
281DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
282
283/* A MUST_NOT_THROW_EXPR wraps an expression that may not
284 throw, and must call terminate if it does. The second argument
285 is a condition, used in templates to express noexcept (condition). */
286DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 2)
287
288/* A CLEANUP_STMT marks the point at which a declaration is fully
289 constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
290 when CLEANUP_BODY completes. */
291DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
292
293/* Represents an 'if' statement. The operands are IF_COND,
294 THEN_CLAUSE, and ELSE_CLAUSE, and the current scope, respectively. */
295/* ??? It is currently still necessary to distinguish between IF_STMT
296 and COND_EXPR for the benefit of templates. */
297DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 4)
298
299/* Used to represent a `for' statement. The operands are
300 FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively. */
301DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 5)
302
303/* Used to represent a range-based `for' statement. The operands are
304 RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, and RANGE_FOR_SCOPE,
305 respectively. Only used in templates. */
306DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 4)
307
308/* Used to represent a 'while' statement. The operands are WHILE_COND
309 and WHILE_BODY, respectively. */
310DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2)
311
312/* Used to represent a 'do' statement. The operands are DO_BODY and
313 DO_COND, respectively. */
314DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2)
315
316/* Used to represent a 'break' statement. */
317DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0)
318
319/* Used to represent a 'continue' statement. */
320DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0)
321
322/* Used to represent a 'switch' statement. The operands are
323 SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE, and
324 SWITCH_STMT_SCOPE, respectively. */
325DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 4)
326
327/* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to
328 obtain the expression. */
329DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
330
331DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
332
333/* Represents an 'offsetof' expression during template expansion. */
334DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 2)
335
336/* Represents an '__builtin_addressof' expression during template
337 expansion. This is similar to ADDR_EXPR, but it doesn't invoke
338 overloaded & operators. */
339DEFTREECODE (ADDRESSOF_EXPR, "addressof_expr", tcc_expression, 1)
340
341/* Represents the -> operator during template expansion. */
342DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
343
344/* Represents an '__alignof__' expression during template
345 expansion. */
346DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)
347
348/* Represents an Objective-C++ '@encode' expression during template
349 expansion. */
350DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1)
351
352/* A STMT_EXPR represents a statement-expression during template
353 expansion. This is the GCC extension { ( ... ) }. The
354 STMT_EXPR_STMT is the statement given by the expression. */
355DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
356
357/* Unary plus. Operand 0 is the expression to which the unary plus
358 is applied. */
359DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
360
361/** C++11 extensions. */
362
363/* A static assertion. This is a C++11 extension.
364 STATIC_ASSERT_CONDITION contains the condition that is being
365 checked. STATIC_ASSERT_MESSAGE contains the message (a string
366 literal) to be displayed if the condition fails to hold. */
367DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0)
368
369/* Represents an argument pack of types (or templates). An argument
370 pack stores zero or more arguments that will be used to instantiate
371 a parameter pack.
372
373 ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument
374 pack.
375
376 Example:
377 template<typename... Values>
378 class tuple { ... };
379
380 tuple<int, float, double> t;
381
382 Values is a (template) parameter pack. When tuple<int, float,
383 double> is instantiated, the Values parameter pack is instantiated
384 with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will
385 be a TREE_VEC containing int, float, and double. */
386DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0)
387
388/* Represents an argument pack of values, which can be used either for
389 non-type template arguments or function call arguments.
390
391 NONTYPE_ARGUMENT_PACK plays precisely the same role as
392 TYPE_ARGUMENT_PACK, but will be used for packing non-type template
393 arguments (e.g., "int... Dimensions") or function arguments ("const
394 Args&... args"). */
395DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1)
396
397/* Represents a type expression that will be expanded into a list of
398 types when instantiated with one or more argument packs.
399
400 PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is
401 the type or expression that we will substitute into with each
402 argument in an argument pack.
403
404 SET_PACK_EXPANSION_PATTERN sets the expansion pattern.
405
406 PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter
407 packs that are used in this pack expansion.
408
409 Example:
410 template<typename... Values>
411 struct tied : tuple<Values&...> {
412 // ...
413 };
414
415 The derivation from tuple contains a TYPE_PACK_EXPANSION for the
416 template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its
417 PACK_EXPANSION_PARAMETER_PACKS will contain "Values". */
418DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0)
419
420/* Represents an expression that will be expanded into a list of
421 expressions when instantiated with one or more argument packs.
422
423 EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION,
424 but will be used for expressions. */
425DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 3)
426
427/* Selects the Ith parameter out of an argument pack. This node will
428 be used when instantiating pack expansions; see
429 tsubst_pack_expansion.
430
431 ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node
432 from which the argument will be selected.
433
434 ARGUMENT_PACK_SELECT_INDEX contains the index into the argument
435 pack that will be returned by this ARGUMENT_PACK_SELECT node. The
436 index is a machine integer. */
437DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0)
438
439/* Fold expressions allow the expansion of a template argument pack
440 over a binary operator.
441
442 FOLD_EXPR_MOD_P is true when the fold operation is a compound assignment
443 operator.
444
445 FOLD_EXPR_OP is an INTEGER_CST storing the tree code for the folded
446 expression. Note that when FOLDEXPR_MOD_P is true, the operator is
447 a compound assignment operator for that kind of expression.
448
449 FOLD_EXPR_PACK is an expression containing an unexpanded parameter pack;
450 when expanded, each term becomes an argument of the folded expression.
451
452 In a BINARY_FOLD_EXPRESSION, FOLD_EXPR_INIT is the non-pack argument. */
453DEFTREECODE (UNARY_LEFT_FOLD_EXPR, "unary_left_fold_expr", tcc_expression, 2)
454DEFTREECODE (UNARY_RIGHT_FOLD_EXPR, "unary_right_fold_expr", tcc_expression, 2)
455DEFTREECODE (BINARY_LEFT_FOLD_EXPR, "binary_left_fold_expr", tcc_expression, 3)
456DEFTREECODE (BINARY_RIGHT_FOLD_EXPR, "binary_right_fold_expr", tcc_expression, 3)
457
458
459/** C++ extensions. */
460
461/* Represents a trait expression during template expansion. */
462DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
463
464/* A lambda expression. This is a C++0x extension.
465 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
466 none.
467 LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'.
468 LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists.
469 LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to
470 be pushed once scope returns to the lambda.
471 LAMBDA_EXPR_MUTABLE_P signals whether this lambda was declared mutable. */
472DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0)
473
474/* The declared type of an expression. This is a C++0x extension.
475 DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
476 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the
477 expression was parsed as an id-expression or a member access
478 expression. When false, it was parsed as a full expression.
479 DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics.
480 DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction. */
481DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
482
483/* A type designated by `__underlying_type (type)'.
484 UNDERLYING_TYPE_TYPE is the type in question. */
485DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
486
487/* A type designated by one of the bases type traits.
488 BASES_TYPE is the type in question. */
489DEFTREECODE (BASES, "bases", tcc_type, 0)
490
491/* Used to represent the template information stored by template
492 specializations.
493 The accessors are:
494 TI_TEMPLATE the template declaration associated to the specialization
495 TI_ARGS the arguments of the template specialization
496 TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in
497 the pattern of the template for which access check is needed at template
498 instantiation time. */
499DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0)
500
501/* Extensions for Concepts. */
502
503/* Used to represent information associated with constrained declarations. */
504DEFTREECODE (CONSTRAINT_INFO, "constraint_info", tcc_exceptional, 0)
505
506/* A wildcard declaration is a placeholder for a template parameter
507 used to resolve constrained-type-names in concepts. During
508 resolution, the matching argument is saved as the TREE_TYPE
509 of the wildcard. */
510DEFTREECODE (WILDCARD_DECL, "wildcard_decl", tcc_declaration, 0)
511
512/* A requires-expr is a binary expression. The first operand is
513 its parameter list (possibly NULL). The second is a list of
514 requirements, which are denoted by the _REQ* tree codes
515 below. */
516DEFTREECODE (REQUIRES_EXPR, "requires_expr", tcc_expression, 2)
517
518/* A requirement for an expression. */
519DEFTREECODE (SIMPLE_REQ, "simple_req", tcc_expression, 1)
520
521/* A requirement for a type. */
522DEFTREECODE (TYPE_REQ, "type_req", tcc_expression, 1)
523
524/* A requirement for an expression and its properties. The
525 first operand is the expression, and the 2nd is its type.
526 The accessor COMPOUND_REQ_NOEXCEPT determines whether
527 the noexcept keyword was present. */
528DEFTREECODE (COMPOUND_REQ, "compound_req", tcc_expression, 2)
529
530/* A requires clause within a requires expression. */
531DEFTREECODE (NESTED_REQ, "nested_req", tcc_expression, 1)
532
533/* Constraints are modeled as kinds of expressions.
534 The operands of a constraint can be either types or expressions.
535 Unlike expressions, constraints do not have a type. */
536
537/* A predicate constraint evaluates an expression E.
538
539 PRED_CONSTR_EXPR has the expression to be evaluated. */
540DEFTREECODE (PRED_CONSTR, "pred_constr", tcc_expression, 1)
541
542/* A check constraint represents the checking of a concept
543 C. It has two operands: the template defining the concept
544 and a sequence of template arguments.
545
546 CHECK_CONSTR_CONCEPT has the concept definition
547 CHECK_CONSTR_ARGUMENTS are the template arguments */
548DEFTREECODE (CHECK_CONSTR, "check_constr", tcc_expression, 2)
549
550/* An expression constraint determines the validity of a expression E.
551
552 EXPR_CONST_EXPR has the expression being validated. */
553DEFTREECODE (EXPR_CONSTR, "expr_constr", tcc_expression, 1)
554
555/* A type constraint determines the validity of a type T. Note that
556
557 TYPE_CONST_TYPE has the type being validated */
558DEFTREECODE (TYPE_CONSTR, "type_constr", tcc_expression, 1)
559
560/* An implicit conversion constraint determines if an expression
561 E is implicitly convertible to a type T. Note that T may
562 be dependent but does not contain any placeholders.
563
564 ICONV_CONSTR_EXPR has the expression E.
565 ICONV_CONSTR_TYPE has the type T.
566 */
567DEFTREECODE (ICONV_CONSTR, "iconv_constr", tcc_expression, 2)
568
569/* An argument deduction constraint determines if the type of an
570 expression E can be deduced from a type pattern T. Note that
571 T must contain at least one place holder.
572
573 DEDUCT_CONSTR_EXPR has the expression E
574 DEDUCT_CONSTR_PATTERN has the type pattern T.
575 DEDUCT_CONSTR_PLACEHOLDERS has the list of placeholder nodes in T. */
576DEFTREECODE (DEDUCT_CONSTR, "deduct_constr", tcc_expression, 3)
577
578/* An exception constraint determines if, for an expression E,
579 noexcept(E) is true.
580
581 EXCEPT_CONSTR_EXPR has the expression E. */
582DEFTREECODE (EXCEPT_CONSTR, "except_constr", tcc_expression, 1)
583
584/* A parameterized constraint declares constraint variables, which
585 are used in expression, type, and exception constraints.
586
587 PARM_CONSTR_PARMS has a TREE_LIST of parameter declarations.
588 PARM_CONSTR_OPERAND has the nested constraint. */
589DEFTREECODE (PARM_CONSTR, "parm_constr", tcc_expression, 2)
590
591/* The conjunction and disjunction of two constraints, respectively.
592 Operands are accessed using TREE_OPERAND. */
593DEFTREECODE (CONJ_CONSTR, "conj_constr", tcc_expression, 2)
594DEFTREECODE (DISJ_CONSTR, "disj_constr", tcc_expression, 2)
595
596
597/*
598Local variables:
599mode:c
600End:
601*/
602