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 if (DECL_NORMAL_CAPTURE_P (member
))
371 name
= get_identifier (IDENTIFIER_POINTER (DECL_NAME (member
)) + 2);
373 name
= DECL_NAME (member
);
375 type
= lambda_proxy_type (object
);
377 if (DECL_VLA_CAPTURE_P (member
))
379 /* Rebuild the VLA type from the pointer and maxindex. */
380 tree field
= next_initializable_field (TYPE_FIELDS (type
));
381 tree ptr
= build_simple_component_ref (object
, field
);
382 field
= next_initializable_field (DECL_CHAIN (field
));
383 tree max
= build_simple_component_ref (object
, field
);
384 type
= build_cplus_array_type (TREE_TYPE (TREE_TYPE (ptr
)),
385 build_index_type (max
));
386 type
= build_reference_type (type
);
387 REFERENCE_VLA_OK (type
) = true;
388 object
= convert (type
, ptr
);
391 var
= build_decl (input_location
, VAR_DECL
, name
, type
);
392 SET_DECL_VALUE_EXPR (var
, object
);
393 DECL_HAS_VALUE_EXPR_P (var
) = 1;
394 DECL_ARTIFICIAL (var
) = 1;
396 DECL_CONTEXT (var
) = fn
;
398 if (name
== this_identifier
)
400 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam
) == member
);
401 LAMBDA_EXPR_THIS_CAPTURE (lam
) = var
;
404 if (fn
== current_function_decl
)
405 insert_capture_proxy (var
);
407 vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam
), var
);
412 /* Return a struct containing a pointer and a length for lambda capture of
413 an array of runtime length. */
416 vla_capture_type (tree array_type
)
418 static tree ptr_id
, max_id
;
419 tree type
= xref_tag (record_type
, make_anon_name (), ts_current
, false);
420 xref_basetypes (type
, NULL_TREE
);
421 type
= begin_class_definition (type
);
424 ptr_id
= get_identifier ("ptr");
425 max_id
= get_identifier ("max");
427 tree ptrtype
= build_pointer_type (TREE_TYPE (array_type
));
428 tree field
= build_decl (input_location
, FIELD_DECL
, ptr_id
, ptrtype
);
429 finish_member_declaration (field
);
430 field
= build_decl (input_location
, FIELD_DECL
, max_id
, sizetype
);
431 finish_member_declaration (field
);
432 return finish_struct (type
, NULL_TREE
);
435 /* From an ID and INITIALIZER, create a capture (by reference if
436 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
440 add_capture (tree lambda
, tree id
, tree orig_init
, bool by_reference_p
,
441 bool explicit_init_p
)
444 tree type
, member
, name
;
446 bool variadic
= false;
447 tree initializer
= orig_init
;
449 if (PACK_EXPANSION_P (initializer
))
451 initializer
= PACK_EXPANSION_PATTERN (initializer
);
455 if (TREE_CODE (initializer
) == TREE_LIST
)
456 initializer
= build_x_compound_expr_from_list (initializer
, ELK_INIT
,
457 tf_warning_or_error
);
458 type
= TREE_TYPE (initializer
);
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++1y 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
);
495 /* Capture by copy requires a complete type. */
496 type
= complete_type (type
);
499 /* Add __ to the beginning of the field name so that user code
500 won't find the field with name lookup. We can't just leave the name
501 unset because template instantiation uses the name to find
502 instantiated fields. */
503 if (!explicit_init_p
)
505 buf
= (char *) alloca (IDENTIFIER_LENGTH (id
) + 3);
506 buf
[1] = buf
[0] = '_';
507 memcpy (buf
+ 2, IDENTIFIER_POINTER (id
),
508 IDENTIFIER_LENGTH (id
) + 1);
509 name
= get_identifier (buf
);
512 /* But captures with explicit initializers are named. */
515 /* If TREE_TYPE isn't set, we're still in the introducer, so check
517 if (!LAMBDA_EXPR_CLOSURE (lambda
))
519 if (IDENTIFIER_MARKED (name
))
521 pedwarn (input_location
, 0,
522 "already captured %qD in lambda expression", id
);
525 IDENTIFIER_MARKED (name
) = true;
529 type
= make_pack_expansion (type
);
531 /* Make member variable. */
532 member
= build_decl (input_location
, FIELD_DECL
, name
, type
);
533 DECL_VLA_CAPTURE_P (member
) = vla
;
535 if (!explicit_init_p
)
536 /* Normal captures are invisible to name lookup but uses are replaced
537 with references to the capture field; we implement this by only
538 really making them invisible in unevaluated context; see
539 qualify_lookup. For now, let's make explicitly initialized captures
541 DECL_NORMAL_CAPTURE_P (member
) = true;
543 if (id
== this_identifier
)
544 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
546 /* Add it to the appropriate closure class if we've started it. */
547 if (current_class_type
548 && current_class_type
== LAMBDA_EXPR_CLOSURE (lambda
))
549 finish_member_declaration (member
);
551 tree listmem
= member
;
554 listmem
= make_pack_expansion (member
);
555 initializer
= orig_init
;
557 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
558 = tree_cons (listmem
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
560 if (LAMBDA_EXPR_CLOSURE (lambda
))
561 return build_capture_proxy (member
);
562 /* For explicit captures we haven't started the function yet, so we wait
563 and build the proxy from cp_parser_lambda_body. */
567 /* Register all the capture members on the list CAPTURES, which is the
568 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
571 register_capture_members (tree captures
)
573 if (captures
== NULL_TREE
)
576 register_capture_members (TREE_CHAIN (captures
));
578 tree field
= TREE_PURPOSE (captures
);
579 if (PACK_EXPANSION_P (field
))
580 field
= PACK_EXPANSION_PATTERN (field
);
582 /* We set this in add_capture to avoid duplicates. */
583 IDENTIFIER_MARKED (DECL_NAME (field
)) = false;
584 finish_member_declaration (field
);
587 /* Similar to add_capture, except this works on a stack of nested lambdas.
588 BY_REFERENCE_P in this case is derived from the default capture mode.
589 Returns the capture for the lambda at the bottom of the stack. */
592 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
594 bool this_capture_p
= (id
== this_identifier
);
596 tree var
= NULL_TREE
;
598 tree saved_class_type
= current_class_type
;
602 for (node
= lambda_stack
;
604 node
= TREE_CHAIN (node
))
606 tree lambda
= TREE_VALUE (node
);
608 current_class_type
= LAMBDA_EXPR_CLOSURE (lambda
);
609 if (DECL_PACK_P (initializer
))
610 initializer
= make_pack_expansion (initializer
);
611 var
= add_capture (lambda
,
616 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
618 /*explicit_init_p=*/false);
619 initializer
= convert_from_reference (var
);
622 current_class_type
= saved_class_type
;
627 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
628 INDIRECT_REF, possibly adding it through default capturing. */
631 lambda_expr_this_capture (tree lambda
)
635 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
637 /* In unevaluated context this isn't an odr-use, so just return the
639 if (cp_unevaluated_operand
)
641 /* In an NSDMI the fake 'this' pointer that we're using for
642 parsing is in scope_chain. */
643 if (LAMBDA_EXPR_EXTRA_SCOPE (lambda
)
644 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (lambda
)) == FIELD_DECL
)
645 return scope_chain
->x_current_class_ptr
;
646 return lookup_name (this_identifier
);
649 /* Try to default capture 'this' if we can. */
651 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
)
653 tree lambda_stack
= NULL_TREE
;
654 tree init
= NULL_TREE
;
656 /* If we are in a lambda function, we can move out until we hit:
657 1. a non-lambda function or NSDMI,
658 2. a lambda function capturing 'this', or
659 3. a non-default capturing lambda function. */
660 for (tree tlambda
= lambda
; ;)
662 lambda_stack
= tree_cons (NULL_TREE
,
666 if (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)
667 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)) == FIELD_DECL
)
669 /* In an NSDMI, we don't have a function to look up the decl in,
670 but the fake 'this' pointer that we're using for parsing is
672 init
= scope_chain
->x_current_class_ptr
;
674 (init
&& (TREE_TYPE (TREE_TYPE (init
))
675 == current_nonlambda_class_type ()));
679 tree closure_decl
= TYPE_NAME (LAMBDA_EXPR_CLOSURE (tlambda
));
680 tree containing_function
= decl_function_context (closure_decl
);
682 if (containing_function
== NULL_TREE
)
683 /* We ran out of scopes; there's no 'this' to capture. */
686 if (!LAMBDA_FUNCTION_P (containing_function
))
688 /* We found a non-lambda function. */
689 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
))
690 /* First parameter is 'this'. */
691 init
= DECL_ARGUMENTS (containing_function
);
696 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
698 if (LAMBDA_EXPR_THIS_CAPTURE (tlambda
))
700 /* An outer lambda has already captured 'this'. */
701 init
= LAMBDA_EXPR_THIS_CAPTURE (tlambda
);
705 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda
) == CPLD_NONE
)
706 /* An outer lambda won't let us capture 'this'. */
711 this_capture
= add_default_capture (lambda_stack
,
712 /*id=*/this_identifier
,
718 error ("%<this%> was not captured for this lambda function");
719 result
= error_mark_node
;
723 /* To make sure that current_class_ref is for the lambda. */
724 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
))
725 == LAMBDA_EXPR_CLOSURE (lambda
));
727 result
= this_capture
;
729 /* If 'this' is captured, each use of 'this' is transformed into an
730 access to the corresponding unnamed data member of the closure
731 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
732 ensures that the transformed expression is an rvalue. ] */
733 result
= rvalue (result
);
739 /* We don't want to capture 'this' until we know we need it, i.e. after
740 overload resolution has chosen a non-static member function. At that
741 point we call this function to turn a dummy object into a use of the
745 maybe_resolve_dummy (tree object
)
747 if (!is_dummy_object (object
))
750 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (object
));
751 gcc_assert (!TYPE_PTR_P (type
));
753 if (type
!= current_class_type
754 && current_class_type
755 && LAMBDA_TYPE_P (current_class_type
)
756 && lambda_function (current_class_type
)
757 && DERIVED_FROM_P (type
, current_nonlambda_class_type ()))
759 /* In a lambda, need to go through 'this' capture. */
760 tree lam
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
761 tree cap
= lambda_expr_this_capture (lam
);
762 object
= build_x_indirect_ref (EXPR_LOCATION (object
), cap
,
763 RO_NULL
, tf_warning_or_error
);
769 /* Returns the method basetype of the innermost non-lambda function, or
770 NULL_TREE if none. */
773 nonlambda_method_basetype (void)
776 if (!current_class_ref
)
779 type
= current_class_type
;
780 if (!LAMBDA_TYPE_P (type
))
783 /* Find the nearest enclosing non-lambda function. */
784 fn
= TYPE_NAME (type
);
786 fn
= decl_function_context (fn
);
787 while (fn
&& LAMBDA_FUNCTION_P (fn
));
789 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
792 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
795 /* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with
796 indicated FN and NARGS, but do not initialize the return type or any of the
800 prepare_op_call (tree fn
, int nargs
)
804 t
= build_vl_exp (CALL_EXPR
, nargs
+ 3);
805 CALL_EXPR_FN (t
) = fn
;
806 CALL_EXPR_STATIC_CHAIN (t
) = NULL
;
811 /* If the closure TYPE has a static op(), also add a conversion to function
815 maybe_add_lambda_conv_op (tree type
)
817 bool nested
= (current_function_decl
!= NULL_TREE
);
818 tree callop
= lambda_function (type
);
820 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
823 if (processing_template_decl
)
826 bool const generic_lambda_p
827 = (DECL_TEMPLATE_INFO (callop
)
828 && DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (callop
)) == callop
);
830 if (!generic_lambda_p
&& DECL_INITIAL (callop
) == NULL_TREE
)
832 /* If the op() wasn't instantiated due to errors, give up. */
833 gcc_assert (errorcount
|| sorrycount
);
837 /* Non-template conversion operators are defined directly with build_call_a
838 and using DIRECT_ARGVEC for arguments (including 'this'). Templates are
839 deferred and the CALL is built in-place. In the case of a deduced return
840 call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
841 the return type is also built in-place. The arguments of DECLTYPE_CALL in
842 the return expression may differ in flags from those in the body CALL. In
843 particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
844 the body CALL, but not in DECLTYPE_CALL. */
846 vec
<tree
, va_gc
> *direct_argvec
= 0;
847 tree decltype_call
= 0, call
= 0;
848 tree fn_result
= TREE_TYPE (TREE_TYPE (callop
));
850 if (generic_lambda_p
)
852 /* Prepare the dependent member call for the static member function
853 '_FUN' and, potentially, prepare another call to be used in a decltype
854 return expression for a deduced return call op to allow for simple
855 implementation of the conversion operator. */
857 tree instance
= build_nop (type
, null_pointer_node
);
858 tree objfn
= build_min (COMPONENT_REF
, NULL_TREE
,
859 instance
, DECL_NAME (callop
), NULL_TREE
);
860 int nargs
= list_length (DECL_ARGUMENTS (callop
)) - 1;
862 call
= prepare_op_call (objfn
, nargs
);
863 if (type_uses_auto (fn_result
))
864 decltype_call
= prepare_op_call (objfn
, nargs
);
868 direct_argvec
= make_tree_vector ();
869 direct_argvec
->quick_push (build1 (NOP_EXPR
,
870 TREE_TYPE (DECL_ARGUMENTS (callop
)),
874 /* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to
875 declare the static member function "_FUN" below. For each arg append to
876 DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated
877 call args (for the template case). If a parameter pack is found, expand
878 it, flagging it as PACK_EXPANSION_LOCAL_P for the body call. */
880 tree fn_args
= NULL_TREE
;
883 tree src
= DECL_CHAIN (DECL_ARGUMENTS (callop
));
888 tree new_node
= copy_node (src
);
891 fn_args
= tgt
= new_node
;
894 TREE_CHAIN (tgt
) = new_node
;
900 if (generic_lambda_p
)
902 if (DECL_PACK_P (tgt
))
904 tree a
= make_pack_expansion (tgt
);
906 CALL_EXPR_ARG (decltype_call
, ix
) = copy_node (a
);
907 PACK_EXPANSION_LOCAL_P (a
) = true;
908 CALL_EXPR_ARG (call
, ix
) = a
;
912 tree a
= convert_from_reference (tgt
);
913 CALL_EXPR_ARG (call
, ix
) = a
;
915 CALL_EXPR_ARG (decltype_call
, ix
) = copy_node (a
);
920 vec_safe_push (direct_argvec
, tgt
);
922 src
= TREE_CHAIN (src
);
927 if (generic_lambda_p
)
931 ++processing_template_decl
;
932 fn_result
= finish_decltype_type
933 (decltype_call
, /*id_expression_or_member_access_p=*/false,
934 tf_warning_or_error
);
935 --processing_template_decl
;
939 call
= build_call_a (callop
,
940 direct_argvec
->length (),
941 direct_argvec
->address ());
943 CALL_FROM_THUNK_P (call
) = 1;
945 tree stattype
= build_function_type (fn_result
, FUNCTION_ARG_CHAIN (callop
));
947 /* First build up the conversion op. */
949 tree rettype
= build_pointer_type (stattype
);
950 tree name
= mangle_conv_op_name_for_type (rettype
);
951 tree thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
952 tree fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
953 tree convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
955 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
957 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
958 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
959 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
961 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
962 grokclassfn (type
, fn
, NO_SPECIAL
);
963 set_linkage_according_to_type (type
, fn
);
964 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
965 DECL_IN_AGGR_P (fn
) = 1;
966 DECL_ARTIFICIAL (fn
) = 1;
967 DECL_NOT_REALLY_EXTERN (fn
) = 1;
968 DECL_DECLARED_INLINE_P (fn
) = 1;
969 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
971 DECL_INTERFACE_KNOWN (fn
) = 1;
973 if (generic_lambda_p
)
974 fn
= add_inherited_template_parms (fn
, DECL_TI_TEMPLATE (callop
));
976 add_method (type
, fn
, NULL_TREE
);
978 /* Generic thunk code fails for varargs; we'll complain in mark_used if
979 the conversion op is used. */
980 if (varargs_function_p (callop
))
982 DECL_DELETED_FN (fn
) = 1;
986 /* Now build up the thunk to be returned. */
988 name
= get_identifier ("_FUN");
989 tree statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
991 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
992 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
993 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
994 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
995 grokclassfn (type
, fn
, NO_SPECIAL
);
996 set_linkage_according_to_type (type
, fn
);
997 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
998 DECL_IN_AGGR_P (fn
) = 1;
999 DECL_ARTIFICIAL (fn
) = 1;
1000 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1001 DECL_DECLARED_INLINE_P (fn
) = 1;
1002 DECL_STATIC_FUNCTION_P (fn
) = 1;
1003 DECL_ARGUMENTS (fn
) = fn_args
;
1004 for (tree arg
= fn_args
; arg
; arg
= DECL_CHAIN (arg
))
1006 /* Avoid duplicate -Wshadow warnings. */
1007 DECL_NAME (arg
) = NULL_TREE
;
1008 DECL_CONTEXT (arg
) = fn
;
1011 DECL_INTERFACE_KNOWN (fn
) = 1;
1013 if (generic_lambda_p
)
1014 fn
= add_inherited_template_parms (fn
, DECL_TI_TEMPLATE (callop
));
1016 add_method (type
, fn
, NULL_TREE
);
1019 push_function_context ();
1021 /* Still increment function_depth so that we don't GC in the
1022 middle of an expression. */
1025 /* Generate the body of the thunk. */
1027 start_preparsed_function (statfn
, NULL_TREE
,
1028 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1029 if (DECL_ONE_ONLY (statfn
))
1031 /* Put the thunk in the same comdat group as the call op. */
1032 symtab_add_to_same_comdat_group
1033 (cgraph_get_create_node (statfn
),
1034 cgraph_get_create_node (callop
));
1036 tree body
= begin_function_body ();
1037 tree compound_stmt
= begin_compound_stmt (0);
1038 if (!generic_lambda_p
)
1040 set_flags_from_callee (call
);
1041 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
1042 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
1044 call
= convert_from_reference (call
);
1045 finish_return_stmt (call
);
1047 finish_compound_stmt (compound_stmt
);
1048 finish_function_body (body
);
1050 fn
= finish_function (/*inline*/2);
1051 if (!generic_lambda_p
)
1052 expand_or_defer_fn (fn
);
1054 /* Generate the body of the conversion op. */
1056 start_preparsed_function (convfn
, NULL_TREE
,
1057 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
1058 body
= begin_function_body ();
1059 compound_stmt
= begin_compound_stmt (0);
1061 /* decl_needed_p needs to see that it's used. */
1062 TREE_USED (statfn
) = 1;
1063 finish_return_stmt (decay_conversion (statfn
, tf_warning_or_error
));
1065 finish_compound_stmt (compound_stmt
);
1066 finish_function_body (body
);
1068 fn
= finish_function (/*inline*/2);
1069 if (!generic_lambda_p
)
1070 expand_or_defer_fn (fn
);
1073 pop_function_context ();
1078 /* Returns true iff VAL is a lambda-related declaration which should
1079 be ignored by unqualified lookup. */
1082 is_lambda_ignored_entity (tree val
)
1084 /* In unevaluated context, look past normal capture proxies. */
1085 if (cp_unevaluated_operand
&& is_normal_capture_proxy (val
))
1088 /* Always ignore lambda fields, their names are only for debugging. */
1089 if (TREE_CODE (val
) == FIELD_DECL
1090 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val
)))
1093 /* None of the lookups that use qualify_lookup want the op() from the
1094 lambda; they want the one from the enclosing class. */
1095 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))