1 /* Perform the semantic phase of lambda parsing, i.e., the process of
2 building tree structure, checking semantic consistency, and
3 building RTL. These routines are used both during actual parsing
4 and during the instantiation of template functions.
6 Copyright (C) 1998-2014 Free Software Foundation, Inc.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
28 #include "stringpool.h"
30 #include "tree-iterator.h"
35 /* Constructor for a lambda expression. */
38 build_lambda_expr (void)
40 tree lambda
= make_node (LAMBDA_EXPR
);
41 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
42 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
43 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
44 LAMBDA_EXPR_PENDING_PROXIES (lambda
) = NULL
;
45 LAMBDA_EXPR_RETURN_TYPE (lambda
) = NULL_TREE
;
46 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
50 /* Create the closure object for a LAMBDA_EXPR. */
53 build_lambda_object (tree lambda_expr
)
55 /* Build aggregate constructor call.
56 - cp_parser_braced_list
57 - cp_parser_functional_cast */
58 vec
<constructor_elt
, va_gc
> *elts
= NULL
;
59 tree node
, expr
, type
;
62 if (processing_template_decl
)
65 /* Make sure any error messages refer to the lambda-introducer. */
66 saved_loc
= input_location
;
67 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
69 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
71 node
= TREE_CHAIN (node
))
73 tree field
= TREE_PURPOSE (node
);
74 tree val
= TREE_VALUE (node
);
76 if (field
== error_mark_node
)
78 expr
= error_mark_node
;
85 /* Mere mortals can't copy arrays with aggregate initialization, so
86 do some magic to make it work here. */
87 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
88 val
= build_array_copy (val
);
89 else if (DECL_NORMAL_CAPTURE_P (field
)
90 && !DECL_VLA_CAPTURE_P (field
)
91 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
93 /* "the entities that are captured by copy are used to
94 direct-initialize each corresponding non-static data
95 member of the resulting closure object."
97 There's normally no way to express direct-initialization
98 from an element of a CONSTRUCTOR, so we build up a special
99 TARGET_EXPR to bypass the usual copy-initialization. */
100 val
= force_rvalue (val
, tf_warning_or_error
);
101 if (TREE_CODE (val
) == TARGET_EXPR
)
102 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
105 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
108 expr
= build_constructor (init_list_type_node
, elts
);
109 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
111 /* N2927: "[The closure] class type is not an aggregate."
112 But we briefly treat it as an aggregate to make this simpler. */
113 type
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
114 CLASSTYPE_NON_AGGREGATE (type
) = 0;
115 expr
= finish_compound_literal (type
, expr
, tf_warning_or_error
);
116 CLASSTYPE_NON_AGGREGATE (type
) = 1;
119 input_location
= saved_loc
;
123 /* Return an initialized RECORD_TYPE for LAMBDA.
124 LAMBDA must have its explicit captures already. */
127 begin_lambda_type (tree lambda
)
132 /* Unique name. This is just like an unnamed class, but we cannot use
133 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
135 name
= make_lambda_name ();
137 /* Create the new RECORD_TYPE for this lambda. */
138 type
= xref_tag (/*tag_code=*/record_type
,
141 /*template_header_p=*/false);
142 if (type
== error_mark_node
)
143 return error_mark_node
;
146 /* Designate it as a struct so that we can use aggregate initialization. */
147 CLASSTYPE_DECLARED_CLASS (type
) = false;
149 /* Cross-reference the expression and the type. */
150 LAMBDA_EXPR_CLOSURE (lambda
) = type
;
151 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
153 /* Clear base types. */
154 xref_basetypes (type
, /*bases=*/NULL_TREE
);
156 /* Start the class. */
157 type
= begin_class_definition (type
);
162 /* Returns the type to use for the return type of the operator() of a
166 lambda_return_type (tree expr
)
168 if (expr
== NULL_TREE
)
169 return void_type_node
;
170 if (type_unknown_p (expr
)
171 || BRACE_ENCLOSED_INITIALIZER_P (expr
))
173 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
174 return void_type_node
;
176 gcc_checking_assert (!type_dependent_expression_p (expr
));
177 return cv_unqualified (type_decays_to (unlowered_expr_type (expr
)));
180 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
184 lambda_function (tree lambda
)
187 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
188 type
= LAMBDA_EXPR_CLOSURE (lambda
);
191 gcc_assert (LAMBDA_TYPE_P (type
));
192 /* Don't let debug_tree cause instantiation. */
193 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
194 && !COMPLETE_OR_OPEN_TYPE_P (type
))
196 lambda
= lookup_member (type
, ansi_opname (CALL_EXPR
),
197 /*protect=*/0, /*want_type=*/false,
198 tf_warning_or_error
);
200 lambda
= STRIP_TEMPLATE (get_first_fn (lambda
));
204 /* Returns the type to use for the FIELD_DECL corresponding to the
206 The caller should add REFERENCE_TYPE for capture by reference. */
209 lambda_capture_field_type (tree expr
, bool explicit_init_p
)
215 type
= do_auto_deduction (type
, expr
, type
);
218 type
= non_reference (unlowered_expr_type (expr
));
219 if (type_dependent_expression_p (expr
)
220 && !is_this_parameter (tree_strip_nop_conversions (expr
)))
222 type
= cxx_make_type (DECLTYPE_TYPE
);
223 DECLTYPE_TYPE_EXPR (type
) = expr
;
224 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
225 DECLTYPE_FOR_INIT_CAPTURE (type
) = explicit_init_p
;
226 SET_TYPE_STRUCTURAL_EQUALITY (type
);
231 /* Returns true iff DECL is a lambda capture proxy variable created by
232 build_capture_proxy. */
235 is_capture_proxy (tree decl
)
238 && DECL_HAS_VALUE_EXPR_P (decl
)
239 && !DECL_ANON_UNION_VAR_P (decl
)
240 && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl
)));
243 /* Returns true iff DECL is a capture proxy for a normal capture
244 (i.e. without explicit initializer). */
247 is_normal_capture_proxy (tree decl
)
249 if (!is_capture_proxy (decl
))
250 /* It's not a capture proxy. */
253 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
257 /* It is a capture proxy, is it a normal capture? */
258 tree val
= DECL_VALUE_EXPR (decl
);
259 if (val
== error_mark_node
)
262 gcc_assert (TREE_CODE (val
) == COMPONENT_REF
);
263 val
= TREE_OPERAND (val
, 1);
264 return DECL_NORMAL_CAPTURE_P (val
);
267 /* VAR is a capture proxy created by build_capture_proxy; add it to the
268 current function, which is the operator() for the appropriate lambda. */
271 insert_capture_proxy (tree var
)
276 /* Put the capture proxy in the extra body block so that it won't clash
277 with a later local variable. */
278 b
= current_binding_level
;
281 cp_binding_level
*n
= b
->level_chain
;
282 if (n
->kind
== sk_function_parms
)
286 pushdecl_with_scope (var
, b
, false);
288 /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
289 var
= build_stmt (DECL_SOURCE_LOCATION (var
), DECL_EXPR
, var
);
290 stmt_list
= (*stmt_list_stack
)[1];
291 gcc_assert (stmt_list
);
292 append_to_statement_list_force (var
, &stmt_list
);
295 /* We've just finished processing a lambda; if the containing scope is also
296 a lambda, insert any capture proxies that were created while processing
297 the nested lambda. */
300 insert_pending_capture_proxies (void)
303 vec
<tree
, va_gc
> *proxies
;
306 if (!current_function_decl
|| !LAMBDA_FUNCTION_P (current_function_decl
))
309 lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
310 proxies
= LAMBDA_EXPR_PENDING_PROXIES (lam
);
311 for (i
= 0; i
< vec_safe_length (proxies
); ++i
)
313 tree var
= (*proxies
)[i
];
314 insert_capture_proxy (var
);
316 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam
));
317 LAMBDA_EXPR_PENDING_PROXIES (lam
) = NULL
;
320 /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
321 return the type we want the proxy to have: the type of the field itself,
322 with added const-qualification if the lambda isn't mutable and the
323 capture is by value. */
326 lambda_proxy_type (tree ref
)
329 if (ref
== error_mark_node
)
330 return error_mark_node
;
331 if (REFERENCE_REF_P (ref
))
332 ref
= TREE_OPERAND (ref
, 0);
333 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
334 type
= TREE_TYPE (ref
);
335 if (!type
|| WILDCARD_TYPE_P (non_reference (type
)))
337 type
= cxx_make_type (DECLTYPE_TYPE
);
338 DECLTYPE_TYPE_EXPR (type
) = ref
;
339 DECLTYPE_FOR_LAMBDA_PROXY (type
) = true;
340 SET_TYPE_STRUCTURAL_EQUALITY (type
);
342 if (DECL_PACK_P (TREE_OPERAND (ref
, 1)))
343 type
= make_pack_expansion (type
);
347 /* MEMBER is a capture field in a lambda closure class. Now that we're
348 inside the operator(), build a placeholder var for future lookups and
352 build_capture_proxy (tree member
)
354 tree var
, object
, fn
, closure
, name
, lam
, type
;
356 if (PACK_EXPANSION_P (member
))
357 member
= PACK_EXPANSION_PATTERN (member
);
359 closure
= DECL_CONTEXT (member
);
360 fn
= lambda_function (closure
);
361 lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
363 /* The proxy variable forwards to the capture field. */
364 object
= build_fold_indirect_ref (DECL_ARGUMENTS (fn
));
365 object
= finish_non_static_data_member (member
, object
, NULL_TREE
);
366 if (REFERENCE_REF_P (object
))
367 object
= TREE_OPERAND (object
, 0);
369 /* Remove the __ inserted by add_capture. */
370 name
= get_identifier (IDENTIFIER_POINTER (DECL_NAME (member
)) + 2);
372 type
= lambda_proxy_type (object
);
374 if (DECL_VLA_CAPTURE_P (member
))
376 /* Rebuild the VLA type from the pointer and maxindex. */
377 tree field
= next_initializable_field (TYPE_FIELDS (type
));
378 tree ptr
= build_simple_component_ref (object
, field
);
379 field
= next_initializable_field (DECL_CHAIN (field
));
380 tree max
= build_simple_component_ref (object
, field
);
381 type
= build_cplus_array_type (TREE_TYPE (TREE_TYPE (ptr
)),
382 build_index_type (max
));
383 type
= build_reference_type (type
);
384 REFERENCE_VLA_OK (type
) = true;
385 object
= convert (type
, ptr
);
388 var
= build_decl (input_location
, VAR_DECL
, name
, type
);
389 SET_DECL_VALUE_EXPR (var
, object
);
390 DECL_HAS_VALUE_EXPR_P (var
) = 1;
391 DECL_ARTIFICIAL (var
) = 1;
393 DECL_CONTEXT (var
) = fn
;
395 if (name
== this_identifier
)
397 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam
) == member
);
398 LAMBDA_EXPR_THIS_CAPTURE (lam
) = var
;
401 if (fn
== current_function_decl
)
402 insert_capture_proxy (var
);
404 vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam
), var
);
409 /* Return a struct containing a pointer and a length for lambda capture of
410 an array of runtime length. */
413 vla_capture_type (tree array_type
)
415 static tree ptr_id
, max_id
;
416 tree type
= xref_tag (record_type
, make_anon_name (), ts_current
, false);
417 xref_basetypes (type
, NULL_TREE
);
418 type
= begin_class_definition (type
);
421 ptr_id
= get_identifier ("ptr");
422 max_id
= get_identifier ("max");
424 tree ptrtype
= build_pointer_type (TREE_TYPE (array_type
));
425 tree field
= build_decl (input_location
, FIELD_DECL
, ptr_id
, ptrtype
);
426 finish_member_declaration (field
);
427 field
= build_decl (input_location
, FIELD_DECL
, max_id
, sizetype
);
428 finish_member_declaration (field
);
429 return finish_struct (type
, NULL_TREE
);
432 /* From an ID and INITIALIZER, create a capture (by reference if
433 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
437 add_capture (tree lambda
, tree id
, tree orig_init
, bool by_reference_p
,
438 bool explicit_init_p
)
441 tree type
, member
, name
;
443 bool variadic
= false;
444 tree initializer
= orig_init
;
446 if (PACK_EXPANSION_P (initializer
))
448 initializer
= PACK_EXPANSION_PATTERN (initializer
);
452 if (TREE_CODE (initializer
) == TREE_LIST
)
453 initializer
= build_x_compound_expr_from_list (initializer
, ELK_INIT
,
454 tf_warning_or_error
);
455 type
= TREE_TYPE (initializer
);
456 if (type
== error_mark_node
)
457 return error_mark_node
;
459 if (array_of_runtime_bound_p (type
))
463 error ("array of runtime bound cannot be captured by copy, "
464 "only by reference");
466 /* For a VLA, we capture the address of the first element and the
467 maximum index, and then reconstruct the VLA for the proxy. */
468 tree elt
= cp_build_array_ref (input_location
, initializer
,
469 integer_zero_node
, tf_warning_or_error
);
470 initializer
= build_constructor_va (init_list_type_node
, 2,
471 NULL_TREE
, build_address (elt
),
472 NULL_TREE
, array_type_nelts (type
));
473 type
= vla_capture_type (type
);
475 else if (variably_modified_type_p (type
, NULL_TREE
))
477 error ("capture of variable-size type %qT that is not a C++14 array "
478 "of runtime bound", type
);
479 if (TREE_CODE (type
) == ARRAY_TYPE
480 && variably_modified_type_p (TREE_TYPE (type
), NULL_TREE
))
481 inform (input_location
, "because the array element type %qT has "
482 "variable size", TREE_TYPE (type
));
483 type
= error_mark_node
;
487 type
= lambda_capture_field_type (initializer
, explicit_init_p
);
490 type
= build_reference_type (type
);
491 if (!real_lvalue_p (initializer
))
492 error ("cannot capture %qE by reference", initializer
);
496 /* Capture by copy requires a complete type. */
497 type
= complete_type (type
);
498 if (!dependent_type_p (type
) && !COMPLETE_TYPE_P (type
))
500 error ("capture by copy of incomplete type %qT", type
);
501 cxx_incomplete_type_inform (type
);
502 return error_mark_node
;
507 /* Add __ to the beginning of the field name so that user code
508 won't find the field with name lookup. We can't just leave the name
509 unset because template instantiation uses the name to find
510 instantiated fields. */
511 buf
= (char *) alloca (IDENTIFIER_LENGTH (id
) + 3);
512 buf
[1] = buf
[0] = '_';
513 memcpy (buf
+ 2, IDENTIFIER_POINTER (id
),
514 IDENTIFIER_LENGTH (id
) + 1);
515 name
= get_identifier (buf
);
517 /* If TREE_TYPE isn't set, we're still in the introducer, so check
519 if (!LAMBDA_EXPR_CLOSURE (lambda
))
521 if (IDENTIFIER_MARKED (name
))
523 pedwarn (input_location
, 0,
524 "already captured %qD in lambda expression", id
);
527 IDENTIFIER_MARKED (name
) = true;
531 type
= make_pack_expansion (type
);
533 /* Make member variable. */
534 member
= build_decl (input_location
, FIELD_DECL
, name
, type
);
535 DECL_VLA_CAPTURE_P (member
) = vla
;
537 if (!explicit_init_p
)
538 /* Normal captures are invisible to name lookup but uses are replaced
539 with references to the capture field; we implement this by only
540 really making them invisible in unevaluated context; see
541 qualify_lookup. For now, let's make explicitly initialized captures
543 DECL_NORMAL_CAPTURE_P (member
) = true;
545 if (id
== this_identifier
)
546 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
548 /* Add it to the appropriate closure class if we've started it. */
549 if (current_class_type
550 && current_class_type
== LAMBDA_EXPR_CLOSURE (lambda
))
551 finish_member_declaration (member
);
553 tree listmem
= member
;
556 listmem
= make_pack_expansion (member
);
557 initializer
= orig_init
;
559 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
560 = tree_cons (listmem
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
562 if (LAMBDA_EXPR_CLOSURE (lambda
))
563 return build_capture_proxy (member
);
564 /* For explicit captures we haven't started the function yet, so we wait
565 and build the proxy from cp_parser_lambda_body. */
569 /* Register all the capture members on the list CAPTURES, which is the
570 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
573 register_capture_members (tree captures
)
575 if (captures
== NULL_TREE
)
578 register_capture_members (TREE_CHAIN (captures
));
580 tree field
= TREE_PURPOSE (captures
);
581 if (PACK_EXPANSION_P (field
))
582 field
= PACK_EXPANSION_PATTERN (field
);
584 /* We set this in add_capture to avoid duplicates. */
585 IDENTIFIER_MARKED (DECL_NAME (field
)) = false;
586 finish_member_declaration (field
);
589 /* Similar to add_capture, except this works on a stack of nested lambdas.
590 BY_REFERENCE_P in this case is derived from the default capture mode.
591 Returns the capture for the lambda at the bottom of the stack. */
594 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
596 bool this_capture_p
= (id
== this_identifier
);
598 tree var
= NULL_TREE
;
600 tree saved_class_type
= current_class_type
;
604 for (node
= lambda_stack
;
606 node
= TREE_CHAIN (node
))
608 tree lambda
= TREE_VALUE (node
);
610 current_class_type
= LAMBDA_EXPR_CLOSURE (lambda
);
611 if (DECL_PACK_P (initializer
))
612 initializer
= make_pack_expansion (initializer
);
613 var
= add_capture (lambda
,
618 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
620 /*explicit_init_p=*/false);
621 initializer
= convert_from_reference (var
);
624 current_class_type
= saved_class_type
;
629 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the
630 form of an INDIRECT_REF, possibly adding it through default
631 capturing, if ADD_CAPTURE_P is false. */
634 lambda_expr_this_capture (tree lambda
, bool add_capture_p
)
638 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
640 /* In unevaluated context this isn't an odr-use, so just return the
642 if (cp_unevaluated_operand
)
644 /* In an NSDMI the fake 'this' pointer that we're using for
645 parsing is in scope_chain. */
646 if (LAMBDA_EXPR_EXTRA_SCOPE (lambda
)
647 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (lambda
)) == FIELD_DECL
)
648 return scope_chain
->x_current_class_ptr
;
649 return lookup_name (this_identifier
);
652 /* Try to default capture 'this' if we can. */
655 || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
))
657 tree lambda_stack
= NULL_TREE
;
658 tree init
= NULL_TREE
;
660 /* If we are in a lambda function, we can move out until we hit:
661 1. a non-lambda function or NSDMI,
662 2. a lambda function capturing 'this', or
663 3. a non-default capturing lambda function. */
664 for (tree tlambda
= lambda
; ;)
666 lambda_stack
= tree_cons (NULL_TREE
,
670 if (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)
671 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)) == FIELD_DECL
)
673 /* In an NSDMI, we don't have a function to look up the decl in,
674 but the fake 'this' pointer that we're using for parsing is
676 init
= scope_chain
->x_current_class_ptr
;
678 (init
&& (TREE_TYPE (TREE_TYPE (init
))
679 == current_nonlambda_class_type ()));
683 tree closure_decl
= TYPE_NAME (LAMBDA_EXPR_CLOSURE (tlambda
));
684 tree containing_function
= decl_function_context (closure_decl
);
686 if (containing_function
== NULL_TREE
)
687 /* We ran out of scopes; there's no 'this' to capture. */
690 if (!LAMBDA_FUNCTION_P (containing_function
))
692 /* We found a non-lambda function. */
693 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
))
694 /* First parameter is 'this'. */
695 init
= DECL_ARGUMENTS (containing_function
);
700 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
702 if (LAMBDA_EXPR_THIS_CAPTURE (tlambda
))
704 /* An outer lambda has already captured 'this'. */
705 init
= LAMBDA_EXPR_THIS_CAPTURE (tlambda
);
709 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda
) == CPLD_NONE
)
710 /* An outer lambda won't let us capture 'this'. */
717 this_capture
= add_default_capture (lambda_stack
,
718 /*id=*/this_identifier
,
728 error ("%<this%> was not captured for this lambda function");
729 result
= error_mark_node
;
733 /* To make sure that current_class_ref is for the lambda. */
734 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
))
735 == LAMBDA_EXPR_CLOSURE (lambda
));
737 result
= this_capture
;
739 /* If 'this' is captured, each use of 'this' is transformed into an
740 access to the corresponding unnamed data member of the closure
741 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
742 ensures that the transformed expression is an rvalue. ] */
743 result
= rvalue (result
);
749 /* We don't want to capture 'this' until we know we need it, i.e. after
750 overload resolution has chosen a non-static member function. At that
751 point we call this function to turn a dummy object into a use of the
755 maybe_resolve_dummy (tree object
, bool add_capture_p
)
757 if (!is_dummy_object (object
))
760 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (object
));
761 gcc_assert (!TYPE_PTR_P (type
));
763 if (type
!= current_class_type
764 && current_class_type
765 && LAMBDA_TYPE_P (current_class_type
)
766 && lambda_function (current_class_type
)
767 && DERIVED_FROM_P (type
, current_nonlambda_class_type ()))
769 /* In a lambda, need to go through 'this' capture. */
770 tree lam
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
771 tree cap
= lambda_expr_this_capture (lam
, add_capture_p
);
772 if (cap
!= error_mark_node
)
773 object
= build_x_indirect_ref (EXPR_LOCATION (object
), cap
,
774 RO_NULL
, tf_warning_or_error
);
780 /* Returns the method basetype of the innermost non-lambda function, or
781 NULL_TREE if none. */
784 nonlambda_method_basetype (void)
787 if (!current_class_ref
)
790 type
= current_class_type
;
791 if (!LAMBDA_TYPE_P (type
))
794 /* Find the nearest enclosing non-lambda function. */
795 fn
= TYPE_NAME (type
);
797 fn
= decl_function_context (fn
);
798 while (fn
&& LAMBDA_FUNCTION_P (fn
));
800 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
803 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
806 /* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with
807 indicated FN and NARGS, but do not initialize the return type or any of the
811 prepare_op_call (tree fn
, int nargs
)
815 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
816 CALL_EXPR_FN (t
) = fn
;
817 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
822 /* If the closure TYPE has a static op(), also add a conversion to function
826 maybe_add_lambda_conv_op (tree type
)
828 bool nested
= (current_function_decl
!= NULL_TREE
);
829 bool nested_def
= decl_function_context (TYPE_MAIN_DECL (type
));
830 tree callop
= lambda_function (type
);
832 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
835 if (processing_template_decl
)
838 bool const generic_lambda_p
839 = (DECL_TEMPLATE_INFO (callop
)
840 && DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (callop
)) == callop
);
842 if (!generic_lambda_p
&& DECL_INITIAL (callop
) == NULL_TREE
)
844 /* If the op() wasn't instantiated due to errors, give up. */
845 gcc_assert (errorcount
|| sorrycount
);
849 /* Non-template conversion operators are defined directly with build_call_a
850 and using DIRECT_ARGVEC for arguments (including 'this'). Templates are
851 deferred and the CALL is built in-place. In the case of a deduced return
852 call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
853 the return type is also built in-place. The arguments of DECLTYPE_CALL in
854 the return expression may differ in flags from those in the body CALL. In
855 particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
856 the body CALL, but not in DECLTYPE_CALL. */
858 vec
<tree
, va_gc
> *direct_argvec
= 0;
859 tree decltype_call
= 0, call
= 0;
860 tree fn_result
= TREE_TYPE (TREE_TYPE (callop
));
862 if (generic_lambda_p
)
864 /* Prepare the dependent member call for the static member function
865 '_FUN' and, potentially, prepare another call to be used in a decltype
866 return expression for a deduced return call op to allow for simple
867 implementation of the conversion operator. */
869 tree instance
= build_nop (type
, null_pointer_node
);
870 tree objfn
= build_min (COMPONENT_REF
, NULL_TREE
,
871 instance
, DECL_NAME (callop
), NULL_TREE
);
872 int nargs
= list_length (DECL_ARGUMENTS (callop
)) - 1;
874 call
= prepare_op_call (objfn
, nargs
);
875 if (type_uses_auto (fn_result
))
876 decltype_call
= prepare_op_call (objfn
, nargs
);
880 direct_argvec
= make_tree_vector ();
881 direct_argvec
->quick_push (build1 (NOP_EXPR
,
882 TREE_TYPE (DECL_ARGUMENTS (callop
)),
886 /* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to
887 declare the static member function "_FUN" below. For each arg append to
888 DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated
889 call args (for the template case). If a parameter pack is found, expand
890 it, flagging it as PACK_EXPANSION_LOCAL_P for the body call. */
892 tree fn_args
= NULL_TREE
;
895 tree src
= DECL_CHAIN (DECL_ARGUMENTS (callop
));
900 tree new_node
= copy_node (src
);
903 fn_args
= tgt
= new_node
;
906 TREE_CHAIN (tgt
) = new_node
;
912 if (generic_lambda_p
)
914 if (DECL_PACK_P (tgt
))
916 tree a
= make_pack_expansion (tgt
);
918 CALL_EXPR_ARG (decltype_call
, ix
) = copy_node (a
);
919 PACK_EXPANSION_LOCAL_P (a
) = true;
920 CALL_EXPR_ARG (call
, ix
) = a
;
924 tree a
= convert_from_reference (tgt
);
925 CALL_EXPR_ARG (call
, ix
) = a
;
927 CALL_EXPR_ARG (decltype_call
, ix
) = copy_node (a
);
932 vec_safe_push (direct_argvec
, tgt
);
934 src
= TREE_CHAIN (src
);
939 if (generic_lambda_p
)
943 ++processing_template_decl
;
944 fn_result
= finish_decltype_type
945 (decltype_call
, /*id_expression_or_member_access_p=*/false,
946 tf_warning_or_error
);
947 --processing_template_decl
;
951 call
= build_call_a (callop
,
952 direct_argvec
->length (),
953 direct_argvec
->address ());
955 CALL_FROM_THUNK_P (call
) = 1;
957 tree stattype
= build_function_type (fn_result
, FUNCTION_ARG_CHAIN (callop
));
959 /* First build up the conversion op. */
961 tree rettype
= build_pointer_type (stattype
);
962 tree name
= mangle_conv_op_name_for_type (rettype
);
963 tree thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
964 tree fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
965 tree convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
967 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
969 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
970 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
971 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
973 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
974 grokclassfn (type
, fn
, NO_SPECIAL
);
975 set_linkage_according_to_type (type
, fn
);
976 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
977 DECL_IN_AGGR_P (fn
) = 1;
978 DECL_ARTIFICIAL (fn
) = 1;
979 DECL_NOT_REALLY_EXTERN (fn
) = 1;
980 DECL_DECLARED_INLINE_P (fn
) = 1;
981 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
983 DECL_INTERFACE_KNOWN (fn
) = 1;
985 if (generic_lambda_p
)
986 fn
= add_inherited_template_parms (fn
, DECL_TI_TEMPLATE (callop
));
988 add_method (type
, fn
, NULL_TREE
);
990 /* Generic thunk code fails for varargs; we'll complain in mark_used if
991 the conversion op is used. */
992 if (varargs_function_p (callop
))
994 DECL_DELETED_FN (fn
) = 1;
998 /* Now build up the thunk to be returned. */
1000 name
= get_identifier ("_FUN");
1001 tree statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
1003 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
1004 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
1005 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
1006 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
1007 grokclassfn (type
, fn
, NO_SPECIAL
);
1008 set_linkage_according_to_type (type
, fn
);
1009 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1010 DECL_IN_AGGR_P (fn
) = 1;
1011 DECL_ARTIFICIAL (fn
) = 1;
1012 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1013 DECL_DECLARED_INLINE_P (fn
) = 1;
1014 DECL_STATIC_FUNCTION_P (fn
) = 1;
1015 DECL_ARGUMENTS (fn
) = fn_args
;
1016 for (tree arg
= fn_args
; arg
; arg
= DECL_CHAIN (arg
))
1018 /* Avoid duplicate -Wshadow warnings. */
1019 DECL_NAME (arg
) = NULL_TREE
;
1020 DECL_CONTEXT (arg
) = fn
;
1023 DECL_INTERFACE_KNOWN (fn
) = 1;
1025 if (generic_lambda_p
)
1026 fn
= add_inherited_template_parms (fn
, DECL_TI_TEMPLATE (callop
));
1028 add_method (type
, fn
, NULL_TREE
);
1031 push_function_context ();
1033 /* Still increment function_depth so that we don't GC in the
1034 middle of an expression. */
1037 /* Generate the body of the thunk. */
1039 start_preparsed_function (statfn
, NULL_TREE
,
1040 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1041 if (DECL_ONE_ONLY (statfn
))
1043 /* Put the thunk in the same comdat group as the call op. */
1044 cgraph_node::get_create (statfn
)->add_to_same_comdat_group
1045 (cgraph_node::get_create (callop
));
1047 tree body
= begin_function_body ();
1048 tree compound_stmt
= begin_compound_stmt (0);
1049 if (!generic_lambda_p
)
1051 set_flags_from_callee (call
);
1052 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
1053 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
1055 call
= convert_from_reference (call
);
1056 finish_return_stmt (call
);
1058 finish_compound_stmt (compound_stmt
);
1059 finish_function_body (body
);
1061 fn
= finish_function (/*inline*/2);
1062 if (!generic_lambda_p
)
1063 expand_or_defer_fn (fn
);
1065 /* Generate the body of the conversion op. */
1067 start_preparsed_function (convfn
, NULL_TREE
,
1068 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1069 body
= begin_function_body ();
1070 compound_stmt
= begin_compound_stmt (0);
1072 /* decl_needed_p needs to see that it's used. */
1073 TREE_USED (statfn
) = 1;
1074 finish_return_stmt (decay_conversion (statfn
, tf_warning_or_error
));
1076 finish_compound_stmt (compound_stmt
);
1077 finish_function_body (body
);
1079 fn
= finish_function (/*inline*/2);
1080 if (!generic_lambda_p
)
1081 expand_or_defer_fn (fn
);
1084 pop_function_context ();
1089 /* Returns true iff VAL is a lambda-related declaration which should
1090 be ignored by unqualified lookup. */
1093 is_lambda_ignored_entity (tree val
)
1095 /* In unevaluated context, look past normal capture proxies. */
1096 if (cp_unevaluated_operand
&& is_normal_capture_proxy (val
))
1099 /* Always ignore lambda fields, their names are only for debugging. */
1100 if (TREE_CODE (val
) == FIELD_DECL
1101 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val
)))
1104 /* None of the lookups that use qualify_lookup want the op() from the
1105 lambda; they want the one from the enclosing class. */
1106 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))