contrib/gcc-8.0/gcc/cp/lambda.c

   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.
   5
   6    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   7
   8    This file is part of GCC.
   9
  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)
  13    any later version.
  14
  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.
  19
  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/>.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "cp-tree.h"
  28 #include "stringpool.h"
  29 #include "cgraph.h"
  30 #include "tree-iterator.h"
  31 #include "toplev.h"
  32 #include "gimplify.h"
  33
  34 /* Constructor for a lambda expression.  */
  35
  36 tree
  37 build_lambda_expr (void)
  38 {
  39   tree lambda = make_node (LAMBDA_EXPR);
  40   LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) = CPLD_NONE;
  41   LAMBDA_EXPR_CAPTURE_LIST         (lambda) = NULL_TREE;
  42   LAMBDA_EXPR_THIS_CAPTURE         (lambda) = NULL_TREE;
  43   LAMBDA_EXPR_PENDING_PROXIES      (lambda) = NULL;
  44   LAMBDA_EXPR_MUTABLE_P            (lambda) = false;
  45   return lambda;
  46 }
  47
  48 /* Create the closure object for a LAMBDA_EXPR.  */
  49
  50 tree
  51 build_lambda_object (tree lambda_expr)
  52 {
  53   /* Build aggregate constructor call.
  54      - cp_parser_braced_list
  55      - cp_parser_functional_cast  */
  56   vec<constructor_elt, va_gc> *elts = NULL;
  57   tree node, expr, type;
  58   location_t saved_loc;
  59
  60   if (processing_template_decl || lambda_expr == error_mark_node)
  61     return lambda_expr;
  62
  63   /* Make sure any error messages refer to the lambda-introducer.  */
  64   saved_loc = input_location;
  65   input_location = LAMBDA_EXPR_LOCATION (lambda_expr);
  66
  67   for (node = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr);
  68        node;
  69        node = TREE_CHAIN (node))
  70     {
  71       tree field = TREE_PURPOSE (node);
  72       tree val = TREE_VALUE (node);
  73
  74       if (field == error_mark_node)
  75         {
  76           expr = error_mark_node;
  77           goto out;
  78         }
  79
  80       if (TREE_CODE (val) == TREE_LIST)
  81         val = build_x_compound_expr_from_list (val, ELK_INIT,
  82                                                tf_warning_or_error);
  83
  84       if (DECL_P (val))
  85         mark_used (val);
  86
  87       /* Mere mortals can't copy arrays with aggregate initialization, so
  88          do some magic to make it work here.  */
  89       if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE)
  90         val = build_array_copy (val);
  91       else if (DECL_NORMAL_CAPTURE_P (field)
  92                && !DECL_VLA_CAPTURE_P (field)
  93                && TREE_CODE (TREE_TYPE (field)) != REFERENCE_TYPE)
  94         {
  95           /* "the entities that are captured by copy are used to
  96              direct-initialize each corresponding non-static data
  97              member of the resulting closure object."
  98
  99              There's normally no way to express direct-initialization
 100              from an element of a CONSTRUCTOR, so we build up a special
 101              TARGET_EXPR to bypass the usual copy-initialization.  */
 102           val = force_rvalue (val, tf_warning_or_error);
 103           if (TREE_CODE (val) == TARGET_EXPR)
 104             TARGET_EXPR_DIRECT_INIT_P (val) = true;
 105         }
 106
 107       CONSTRUCTOR_APPEND_ELT (elts, DECL_NAME (field), val);
 108     }
 109
 110   expr = build_constructor (init_list_type_node, elts);
 111   CONSTRUCTOR_IS_DIRECT_INIT (expr) = 1;
 112
 113   /* N2927: "[The closure] class type is not an aggregate."
 114      But we briefly treat it as an aggregate to make this simpler.  */
 115   type = LAMBDA_EXPR_CLOSURE (lambda_expr);
 116   CLASSTYPE_NON_AGGREGATE (type) = 0;
 117   expr = finish_compound_literal (type, expr, tf_warning_or_error);
 118   CLASSTYPE_NON_AGGREGATE (type) = 1;
 119
 120  out:
 121   input_location = saved_loc;
 122   return expr;
 123 }
 124
 125 /* Return an initialized RECORD_TYPE for LAMBDA.
 126    LAMBDA must have its explicit captures already.  */
 127
 128 tree
 129 begin_lambda_type (tree lambda)
 130 {
 131   tree type;
 132
 133   {
 134     /* Unique name.  This is just like an unnamed class, but we cannot use
 135        make_anon_name because of certain checks against TYPE_UNNAMED_P.  */
 136     tree name;
 137     name = make_lambda_name ();
 138
 139     /* Create the new RECORD_TYPE for this lambda.  */
 140     type = xref_tag (/*tag_code=*/record_type,
 141                      name,
 142                      /*scope=*/ts_lambda,
 143                      /*template_header_p=*/false);
 144     if (type == error_mark_node)
 145       return error_mark_node;
 146   }
 147
 148   /* Designate it as a struct so that we can use aggregate initialization.  */
 149   CLASSTYPE_DECLARED_CLASS (type) = false;
 150
 151   /* Cross-reference the expression and the type.  */
 152   LAMBDA_EXPR_CLOSURE (lambda) = type;
 153   CLASSTYPE_LAMBDA_EXPR (type) = lambda;
 154
 155   /* In C++17, assume the closure is literal; we'll clear the flag later if
 156      necessary.  */
 157   if (cxx_dialect >= cxx17)
 158     CLASSTYPE_LITERAL_P (type) = true;
 159
 160   /* Clear base types.  */
 161   xref_basetypes (type, /*bases=*/NULL_TREE);
 162
 163   /* Start the class.  */
 164   type = begin_class_definition (type);
 165
 166   return type;
 167 }
 168
 169 /* Returns the type to use for the return type of the operator() of a
 170    closure class.  */
 171
 172 tree
 173 lambda_return_type (tree expr)
 174 {
 175   if (expr == NULL_TREE)
 176     return void_type_node;
 177   if (type_unknown_p (expr)
 178       || BRACE_ENCLOSED_INITIALIZER_P (expr))
 179     {
 180       cxx_incomplete_type_error (expr, TREE_TYPE (expr));
 181       return error_mark_node;
 182     }
 183   gcc_checking_assert (!type_dependent_expression_p (expr));
 184   return cv_unqualified (type_decays_to (unlowered_expr_type (expr)));
 185 }
 186
 187 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
 188    closure type.  */
 189
 190 tree
 191 lambda_function (tree lambda)
 192 {
 193   tree type;
 194   if (TREE_CODE (lambda) == LAMBDA_EXPR)
 195     type = LAMBDA_EXPR_CLOSURE (lambda);
 196   else
 197     type = lambda;
 198   gcc_assert (LAMBDA_TYPE_P (type));
 199   /* Don't let debug_tree cause instantiation.  */
 200   if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
 201       && !COMPLETE_OR_OPEN_TYPE_P (type))
 202     return NULL_TREE;
 203   lambda = lookup_member (type, call_op_identifier,
 204                           /*protect=*/0, /*want_type=*/false,
 205                           tf_warning_or_error);
 206   if (lambda)
 207     lambda = STRIP_TEMPLATE (get_first_fn (lambda));
 208   return lambda;
 209 }
 210
 211 /* Returns the type to use for the FIELD_DECL corresponding to the
 212    capture of EXPR.  EXPLICIT_INIT_P indicates whether this is a
 213    C++14 init capture, and BY_REFERENCE_P indicates whether we're
 214    capturing by reference.  */
 215
 216 tree
 217 lambda_capture_field_type (tree expr, bool explicit_init_p,
 218                            bool by_reference_p)
 219 {
 220   tree type;
 221   bool is_this = is_this_parameter (tree_strip_nop_conversions (expr));
 222
 223   if (!is_this && type_dependent_expression_p (expr))
 224     {
 225       type = cxx_make_type (DECLTYPE_TYPE);
 226       DECLTYPE_TYPE_EXPR (type) = expr;
 227       DECLTYPE_FOR_LAMBDA_CAPTURE (type) = true;
 228       DECLTYPE_FOR_INIT_CAPTURE (type) = explicit_init_p;
 229       DECLTYPE_FOR_REF_CAPTURE (type) = by_reference_p;
 230       SET_TYPE_STRUCTURAL_EQUALITY (type);
 231     }
 232   else if (!is_this && explicit_init_p)
 233     {
 234       tree auto_node = make_auto ();
 235
 236       type = auto_node;
 237       if (by_reference_p)
 238         /* Add the reference now, so deduction doesn't lose
 239            outermost CV qualifiers of EXPR.  */
 240         type = build_reference_type (type);
 241       type = do_auto_deduction (type, expr, auto_node);
 242     }
 243   else
 244     {
 245       type = non_reference (unlowered_expr_type (expr));
 246
 247       if (!is_this
 248           && (by_reference_p || TREE_CODE (type) == FUNCTION_TYPE))
 249         type = build_reference_type (type);
 250     }
 251
 252   return type;
 253 }
 254
 255 /* Returns true iff DECL is a lambda capture proxy variable created by
 256    build_capture_proxy.  */
 257
 258 bool
 259 is_capture_proxy (tree decl)
 260 {
 261   return (VAR_P (decl)
 262           && DECL_HAS_VALUE_EXPR_P (decl)
 263           && !DECL_ANON_UNION_VAR_P (decl)
 264           && !DECL_DECOMPOSITION_P (decl)
 265           && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl)));
 266 }
 267
 268 /* Returns true iff DECL is a capture proxy for a normal capture
 269    (i.e. without explicit initializer).  */
 270
 271 bool
 272 is_normal_capture_proxy (tree decl)
 273 {
 274   if (!is_capture_proxy (decl))
 275     /* It's not a capture proxy.  */
 276     return false;
 277
 278   if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
 279     /* VLA capture.  */
 280     return true;
 281
 282   /* It is a capture proxy, is it a normal capture?  */
 283   tree val = DECL_VALUE_EXPR (decl);
 284   if (val == error_mark_node)
 285     return true;
 286
 287   if (TREE_CODE (val) == ADDR_EXPR)
 288     val = TREE_OPERAND (val, 0);
 289   gcc_assert (TREE_CODE (val) == COMPONENT_REF);
 290   val = TREE_OPERAND (val, 1);
 291   return DECL_NORMAL_CAPTURE_P (val);
 292 }
 293
 294 /* Returns true iff DECL is a capture proxy for a normal capture
 295    of a constant variable.  */
 296
 297 bool
 298 is_constant_capture_proxy (tree decl)
 299 {
 300   if (is_normal_capture_proxy (decl))
 301     return decl_constant_var_p (DECL_CAPTURED_VARIABLE (decl));
 302   return false;
 303 }
 304
 305 /* VAR is a capture proxy created by build_capture_proxy; add it to the
 306    current function, which is the operator() for the appropriate lambda.  */
 307
 308 void
 309 insert_capture_proxy (tree var)
 310 {
 311   if (is_normal_capture_proxy (var))
 312     {
 313       tree cap = DECL_CAPTURED_VARIABLE (var);
 314       if (CHECKING_P)
 315         {
 316           gcc_assert (!is_normal_capture_proxy (cap));
 317           tree old = retrieve_local_specialization (cap);
 318           if (old)
 319             gcc_assert (DECL_CONTEXT (old) != DECL_CONTEXT (var));
 320         }
 321       register_local_specialization (var, cap);
 322     }
 323
 324   /* Put the capture proxy in the extra body block so that it won't clash
 325      with a later local variable.  */
 326   pushdecl_outermost_localscope (var);
 327
 328   /* And put a DECL_EXPR in the STATEMENT_LIST for the same block.  */
 329   var = build_stmt (DECL_SOURCE_LOCATION (var), DECL_EXPR, var);
 330   tree stmt_list = (*stmt_list_stack)[1];
 331   gcc_assert (stmt_list);
 332   append_to_statement_list_force (var, &stmt_list);
 333 }
 334
 335 /* We've just finished processing a lambda; if the containing scope is also
 336    a lambda, insert any capture proxies that were created while processing
 337    the nested lambda.  */
 338
 339 void
 340 insert_pending_capture_proxies (void)
 341 {
 342   tree lam;
 343   vec<tree, va_gc> *proxies;
 344   unsigned i;
 345
 346   if (!current_function_decl || !LAMBDA_FUNCTION_P (current_function_decl))
 347     return;
 348
 349   lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl));
 350   proxies = LAMBDA_EXPR_PENDING_PROXIES (lam);
 351   for (i = 0; i < vec_safe_length (proxies); ++i)
 352     {
 353       tree var = (*proxies)[i];
 354       insert_capture_proxy (var);
 355     }
 356   release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam));
 357   LAMBDA_EXPR_PENDING_PROXIES (lam) = NULL;
 358 }
 359
 360 /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
 361    return the type we want the proxy to have: the type of the field itself,
 362    with added const-qualification if the lambda isn't mutable and the
 363    capture is by value.  */
 364
 365 tree
 366 lambda_proxy_type (tree ref)
 367 {
 368   tree type;
 369   if (ref == error_mark_node)
 370     return error_mark_node;
 371   if (REFERENCE_REF_P (ref))
 372     ref = TREE_OPERAND (ref, 0);
 373   gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
 374   type = TREE_TYPE (ref);
 375   if (!type || WILDCARD_TYPE_P (non_reference (type)))
 376     {
 377       type = cxx_make_type (DECLTYPE_TYPE);
 378       DECLTYPE_TYPE_EXPR (type) = ref;
 379       DECLTYPE_FOR_LAMBDA_PROXY (type) = true;
 380       SET_TYPE_STRUCTURAL_EQUALITY (type);
 381     }
 382   if (DECL_PACK_P (TREE_OPERAND (ref, 1)))
 383     type = make_pack_expansion (type);
 384   return type;
 385 }
 386
 387 /* MEMBER is a capture field in a lambda closure class.  Now that we're
 388    inside the operator(), build a placeholder var for future lookups and
 389    debugging.  */
 390
 391 static tree
 392 build_capture_proxy (tree member, tree init)
 393 {
 394   tree var, object, fn, closure, name, lam, type;
 395
 396   if (PACK_EXPANSION_P (member))
 397     member = PACK_EXPANSION_PATTERN (member);
 398
 399   closure = DECL_CONTEXT (member);
 400   fn = lambda_function (closure);
 401   lam = CLASSTYPE_LAMBDA_EXPR (closure);
 402
 403   /* The proxy variable forwards to the capture field.  */
 404   object = build_fold_indirect_ref (DECL_ARGUMENTS (fn));
 405   object = finish_non_static_data_member (member, object, NULL_TREE);
 406   if (REFERENCE_REF_P (object))
 407     object = TREE_OPERAND (object, 0);
 408
 409   /* Remove the __ inserted by add_capture.  */
 410   name = get_identifier (IDENTIFIER_POINTER (DECL_NAME (member)) + 2);
 411
 412   type = lambda_proxy_type (object);
 413
 414   if (name == this_identifier && !POINTER_TYPE_P (type))
 415     {
 416       type = build_pointer_type (type);
 417       type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
 418       object = build_fold_addr_expr_with_type (object, type);
 419     }
 420
 421   if (DECL_VLA_CAPTURE_P (member))
 422     {
 423       /* Rebuild the VLA type from the pointer and maxindex.  */
 424       tree field = next_initializable_field (TYPE_FIELDS (type));
 425       tree ptr = build_simple_component_ref (object, field);
 426       field = next_initializable_field (DECL_CHAIN (field));
 427       tree max = build_simple_component_ref (object, field);
 428       type = build_cplus_array_type (TREE_TYPE (TREE_TYPE (ptr)),
 429                                      build_index_type (max));
 430       type = build_reference_type (type);
 431       REFERENCE_VLA_OK (type) = true;
 432       object = convert (type, ptr);
 433     }
 434
 435   complete_type (type);
 436
 437   var = build_decl (input_location, VAR_DECL, name, type);
 438   SET_DECL_VALUE_EXPR (var, object);
 439   DECL_HAS_VALUE_EXPR_P (var) = 1;
 440   DECL_ARTIFICIAL (var) = 1;
 441   TREE_USED (var) = 1;
 442   DECL_CONTEXT (var) = fn;
 443
 444   if (DECL_NORMAL_CAPTURE_P (member))
 445     {
 446       if (DECL_VLA_CAPTURE_P (member))
 447         {
 448           init = CONSTRUCTOR_ELT (init, 0)->value;
 449           init = TREE_OPERAND (init, 0); // Strip ADDR_EXPR.
 450           init = TREE_OPERAND (init, 0); // Strip ARRAY_REF.
 451         }
 452       else
 453         {
 454           if (PACK_EXPANSION_P (init))
 455             init = PACK_EXPANSION_PATTERN (init);
 456         }
 457
 458       if (INDIRECT_REF_P (init))
 459         init = TREE_OPERAND (init, 0);
 460       STRIP_NOPS (init);
 461
 462       gcc_assert (VAR_P (init) || TREE_CODE (init) == PARM_DECL);
 463       while (is_normal_capture_proxy (init))
 464         init = DECL_CAPTURED_VARIABLE (init);
 465       retrofit_lang_decl (var);
 466       DECL_CAPTURED_VARIABLE (var) = init;
 467     }
 468
 469   if (name == this_identifier)
 470     {
 471       gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam) == member);
 472       LAMBDA_EXPR_THIS_CAPTURE (lam) = var;
 473     }
 474
 475   if (fn == current_function_decl)
 476     insert_capture_proxy (var);
 477   else
 478     vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam), var);
 479
 480   return var;
 481 }
 482
 483 static GTY(()) tree ptr_id;
 484 static GTY(()) tree max_id;
 485
 486 /* Return a struct containing a pointer and a length for lambda capture of
 487    an array of runtime length.  */
 488
 489 static tree
 490 vla_capture_type (tree array_type)
 491 {
 492   tree type = xref_tag (record_type, make_anon_name (), ts_current, false);
 493   xref_basetypes (type, NULL_TREE);
 494   type = begin_class_definition (type);
 495   if (!ptr_id)
 496     {
 497       ptr_id = get_identifier ("ptr");
 498       max_id = get_identifier ("max");
 499     }
 500   tree ptrtype = build_pointer_type (TREE_TYPE (array_type));
 501   tree field = build_decl (input_location, FIELD_DECL, ptr_id, ptrtype);
 502   finish_member_declaration (field);
 503   field = build_decl (input_location, FIELD_DECL, max_id, sizetype);
 504   finish_member_declaration (field);
 505   return finish_struct (type, NULL_TREE);
 506 }
 507
 508 /* From an ID and INITIALIZER, create a capture (by reference if
 509    BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
 510    and return it.  If ID is `this', BY_REFERENCE_P says whether
 511    `*this' is captured by reference.  */
 512
 513 tree
 514 add_capture (tree lambda, tree id, tree orig_init, bool by_reference_p,
 515              bool explicit_init_p)
 516 {
 517   char *buf;
 518   tree type, member, name;
 519   bool vla = false;
 520   bool variadic = false;
 521   tree initializer = orig_init;
 522
 523   if (PACK_EXPANSION_P (initializer))
 524     {
 525       initializer = PACK_EXPANSION_PATTERN (initializer);
 526       variadic = true;
 527     }
 528
 529   if (TREE_CODE (initializer) == TREE_LIST
 530       /* A pack expansion might end up with multiple elements.  */
 531       && !PACK_EXPANSION_P (TREE_VALUE (initializer)))
 532     initializer = build_x_compound_expr_from_list (initializer, ELK_INIT,
 533                                                    tf_warning_or_error);
 534   type = TREE_TYPE (initializer);
 535   if (type == error_mark_node)
 536     return error_mark_node;
 537
 538   if (array_of_runtime_bound_p (type))
 539     {
 540       vla = true;
 541       if (!by_reference_p)
 542         error ("array of runtime bound cannot be captured by copy, "
 543                "only by reference");
 544
 545       /* For a VLA, we capture the address of the first element and the
 546          maximum index, and then reconstruct the VLA for the proxy.  */
 547       tree elt = cp_build_array_ref (input_location, initializer,
 548                                      integer_zero_node, tf_warning_or_error);
 549       initializer = build_constructor_va (init_list_type_node, 2,
 550                                           NULL_TREE, build_address (elt),
 551                                           NULL_TREE, array_type_nelts (type));
 552       type = vla_capture_type (type);
 553     }
 554   else if (!dependent_type_p (type)
 555            && variably_modified_type_p (type, NULL_TREE))
 556     {
 557       sorry ("capture of variably-modified type %qT that is not an N3639 array "
 558              "of runtime bound", type);
 559       if (TREE_CODE (type) == ARRAY_TYPE
 560           && variably_modified_type_p (TREE_TYPE (type), NULL_TREE))
 561         inform (input_location, "because the array element type %qT has "
 562                 "variable size", TREE_TYPE (type));
 563       return error_mark_node;
 564     }
 565   else
 566     {
 567       type = lambda_capture_field_type (initializer, explicit_init_p,
 568                                         by_reference_p);
 569       if (type == error_mark_node)
 570         return error_mark_node;
 571
 572       if (id == this_identifier && !by_reference_p)
 573         {
 574           gcc_assert (POINTER_TYPE_P (type));
 575           type = TREE_TYPE (type);
 576           initializer = cp_build_fold_indirect_ref (initializer);
 577         }
 578
 579       if (dependent_type_p (type))
 580         ;
 581       else if (id != this_identifier && by_reference_p)
 582         {
 583           if (!lvalue_p (initializer))
 584             {
 585               error ("cannot capture %qE by reference", initializer);
 586               return error_mark_node;
 587             }
 588         }
 589       else
 590         {
 591           /* Capture by copy requires a complete type.  */
 592           type = complete_type (type);
 593           if (!COMPLETE_TYPE_P (type))
 594             {
 595               error ("capture by copy of incomplete type %qT", type);
 596               cxx_incomplete_type_inform (type);
 597               return error_mark_node;
 598             }
 599         }
 600     }
 601
 602   /* Add __ to the beginning of the field name so that user code
 603      won't find the field with name lookup.  We can't just leave the name
 604      unset because template instantiation uses the name to find
 605      instantiated fields.  */
 606   buf = (char *) alloca (IDENTIFIER_LENGTH (id) + 3);
 607   buf[1] = buf[0] = '_';
 608   memcpy (buf + 2, IDENTIFIER_POINTER (id),
 609           IDENTIFIER_LENGTH (id) + 1);
 610   name = get_identifier (buf);
 611
 612   /* If TREE_TYPE isn't set, we're still in the introducer, so check
 613      for duplicates.  */
 614   if (!LAMBDA_EXPR_CLOSURE (lambda))
 615     {
 616       if (IDENTIFIER_MARKED (name))
 617         {
 618           pedwarn (input_location, 0,
 619                    "already captured %qD in lambda expression", id);
 620           return NULL_TREE;
 621         }
 622       IDENTIFIER_MARKED (name) = true;
 623     }
 624
 625   if (variadic)
 626     type = make_pack_expansion (type);
 627
 628   /* Make member variable.  */
 629   member = build_decl (input_location, FIELD_DECL, name, type);
 630   DECL_VLA_CAPTURE_P (member) = vla;
 631
 632   if (!explicit_init_p)
 633     /* Normal captures are invisible to name lookup but uses are replaced
 634        with references to the capture field; we implement this by only
 635        really making them invisible in unevaluated context; see
 636        qualify_lookup.  For now, let's make explicitly initialized captures
 637        always visible.  */
 638     DECL_NORMAL_CAPTURE_P (member) = true;
 639
 640   if (id == this_identifier)
 641     LAMBDA_EXPR_THIS_CAPTURE (lambda) = member;
 642
 643   /* Add it to the appropriate closure class if we've started it.  */
 644   if (current_class_type
 645       && current_class_type == LAMBDA_EXPR_CLOSURE (lambda))
 646     {
 647       if (COMPLETE_TYPE_P (current_class_type))
 648         internal_error ("trying to capture %qD in instantiation of "
 649                         "generic lambda", id);
 650       finish_member_declaration (member);
 651     }
 652
 653   tree listmem = member;
 654   if (variadic)
 655     {
 656       listmem = make_pack_expansion (member);
 657       initializer = orig_init;
 658     }
 659   LAMBDA_EXPR_CAPTURE_LIST (lambda)
 660     = tree_cons (listmem, initializer, LAMBDA_EXPR_CAPTURE_LIST (lambda));
 661
 662   if (LAMBDA_EXPR_CLOSURE (lambda))
 663     return build_capture_proxy (member, initializer);
 664   /* For explicit captures we haven't started the function yet, so we wait
 665      and build the proxy from cp_parser_lambda_body.  */
 666   LAMBDA_CAPTURE_EXPLICIT_P (LAMBDA_EXPR_CAPTURE_LIST (lambda)) = true;
 667   return NULL_TREE;
 668 }
 669
 670 /* Register all the capture members on the list CAPTURES, which is the
 671    LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer.  */
 672
 673 void
 674 register_capture_members (tree captures)
 675 {
 676   if (captures == NULL_TREE)
 677     return;
 678
 679   register_capture_members (TREE_CHAIN (captures));
 680
 681   tree field = TREE_PURPOSE (captures);
 682   if (PACK_EXPANSION_P (field))
 683     field = PACK_EXPANSION_PATTERN (field);
 684
 685   /* We set this in add_capture to avoid duplicates.  */
 686   IDENTIFIER_MARKED (DECL_NAME (field)) = false;
 687   finish_member_declaration (field);
 688 }
 689
 690 /* Similar to add_capture, except this works on a stack of nested lambdas.
 691    BY_REFERENCE_P in this case is derived from the default capture mode.
 692    Returns the capture for the lambda at the bottom of the stack.  */
 693
 694 tree
 695 add_default_capture (tree lambda_stack, tree id, tree initializer)
 696 {
 697   bool this_capture_p = (id == this_identifier);
 698
 699   tree var = NULL_TREE;
 700
 701   tree saved_class_type = current_class_type;
 702
 703   tree node;
 704
 705   for (node = lambda_stack;
 706        node;
 707        node = TREE_CHAIN (node))
 708     {
 709       tree lambda = TREE_VALUE (node);
 710
 711       current_class_type = LAMBDA_EXPR_CLOSURE (lambda);
 712       if (DECL_PACK_P (initializer))
 713         initializer = make_pack_expansion (initializer);
 714       var = add_capture (lambda,
 715                             id,
 716                             initializer,
 717                             /*by_reference_p=*/
 718                             (this_capture_p
 719                              || (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda)
 720                                  == CPLD_REFERENCE)),
 721                             /*explicit_init_p=*/false);
 722       initializer = convert_from_reference (var);
 723     }
 724
 725   current_class_type = saved_class_type;
 726
 727   return var;
 728 }
 729
 730 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the
 731    form of an INDIRECT_REF, possibly adding it through default
 732    capturing, if ADD_CAPTURE_P is true.  */
 733
 734 tree
 735 lambda_expr_this_capture (tree lambda, bool add_capture_p)
 736 {
 737   tree result;
 738
 739   tree this_capture = LAMBDA_EXPR_THIS_CAPTURE (lambda);
 740
 741   /* In unevaluated context this isn't an odr-use, so don't capture.  */
 742   if (cp_unevaluated_operand)
 743     add_capture_p = false;
 744
 745   /* Try to default capture 'this' if we can.  */
 746   if (!this_capture
 747       && (!add_capture_p
 748           || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) != CPLD_NONE))
 749     {
 750       tree lambda_stack = NULL_TREE;
 751       tree init = NULL_TREE;
 752
 753       /* If we are in a lambda function, we can move out until we hit:
 754            1. a non-lambda function or NSDMI,
 755            2. a lambda function capturing 'this', or
 756            3. a non-default capturing lambda function.  */
 757       for (tree tlambda = lambda; ;)
 758         {
 759           lambda_stack = tree_cons (NULL_TREE,
 760                                     tlambda,
 761                                     lambda_stack);
 762
 763           tree closure = LAMBDA_EXPR_CLOSURE (tlambda);
 764           tree containing_function
 765             = decl_function_context (TYPE_NAME (closure));
 766
 767           tree ex = LAMBDA_EXPR_EXTRA_SCOPE (tlambda);
 768           if (ex && TREE_CODE (ex) == FIELD_DECL)
 769             {
 770               /* Lambda in an NSDMI.  We don't have a function to look up
 771                  'this' in, but we can find (or rebuild) the fake one from
 772                  inject_this_parameter.  */
 773               if (!containing_function && !COMPLETE_TYPE_P (closure))
 774                 /* If we're parsing a lambda in a non-local class,
 775                    we can find the fake 'this' in scope_chain.  */
 776                 init = scope_chain->x_current_class_ptr;
 777               else
 778                 /* Otherwise it's either gone or buried in
 779                    function_context_stack, so make another.  */
 780                 init = build_this_parm (NULL_TREE, DECL_CONTEXT (ex),
 781                                         TYPE_UNQUALIFIED);
 782               gcc_checking_assert
 783                 (init && (TREE_TYPE (TREE_TYPE (init))
 784                           == current_nonlambda_class_type ()));
 785               break;
 786             }
 787
 788           if (containing_function == NULL_TREE)
 789             /* We ran out of scopes; there's no 'this' to capture.  */
 790             break;
 791
 792           if (!LAMBDA_FUNCTION_P (containing_function))
 793             {
 794               /* We found a non-lambda function.  */
 795               if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function))
 796                 /* First parameter is 'this'.  */
 797                 init = DECL_ARGUMENTS (containing_function);
 798               break;
 799             }
 800
 801           tlambda
 802             = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function));
 803
 804           if (LAMBDA_EXPR_THIS_CAPTURE (tlambda))
 805             {
 806               /* An outer lambda has already captured 'this'.  */
 807               init = LAMBDA_EXPR_THIS_CAPTURE (tlambda);
 808               break;
 809             }
 810
 811           if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda) == CPLD_NONE)
 812             /* An outer lambda won't let us capture 'this'.  */
 813             break;
 814         }
 815
 816       if (init)
 817         {
 818           if (add_capture_p)
 819             this_capture = add_default_capture (lambda_stack,
 820                                                 /*id=*/this_identifier,
 821                                                 init);
 822           else
 823             this_capture = init;
 824         }
 825     }
 826
 827   if (cp_unevaluated_operand)
 828     result = this_capture;
 829   else if (!this_capture)
 830     {
 831       if (add_capture_p)
 832         {
 833           error ("%<this%> was not captured for this lambda function");
 834           result = error_mark_node;
 835         }
 836       else
 837         result = NULL_TREE;
 838     }
 839   else
 840     {
 841       /* To make sure that current_class_ref is for the lambda.  */
 842       gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref))
 843                   == LAMBDA_EXPR_CLOSURE (lambda));
 844
 845       result = this_capture;
 846
 847       /* If 'this' is captured, each use of 'this' is transformed into an
 848          access to the corresponding unnamed data member of the closure
 849          type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
 850          ensures that the transformed expression is an rvalue. ] */
 851       result = rvalue (result);
 852     }
 853
 854   return result;
 855 }
 856
 857 /* Return the innermost LAMBDA_EXPR we're currently in, if any.  */
 858
 859 tree
 860 current_lambda_expr (void)
 861 {
 862   tree type = current_class_type;
 863   while (type && !LAMBDA_TYPE_P (type))
 864     type = decl_type_context (TYPE_NAME (type));
 865   if (type)
 866     return CLASSTYPE_LAMBDA_EXPR (type);
 867   else
 868     return NULL_TREE;
 869 }
 870
 871 /* Return the current LAMBDA_EXPR, if this is a resolvable dummy
 872    object.  NULL otherwise..  */
 873
 874 static tree
 875 resolvable_dummy_lambda (tree object)
 876 {
 877   if (!is_dummy_object (object))
 878     return NULL_TREE;
 879
 880   tree type = TYPE_MAIN_VARIANT (TREE_TYPE (object));
 881   gcc_assert (!TYPE_PTR_P (type));
 882
 883   if (type != current_class_type
 884       && current_class_type
 885       && LAMBDA_TYPE_P (current_class_type)
 886       && lambda_function (current_class_type)
 887       && DERIVED_FROM_P (type, current_nonlambda_class_type ()))
 888     return CLASSTYPE_LAMBDA_EXPR (current_class_type);
 889
 890   return NULL_TREE;
 891 }
 892
 893 /* We don't want to capture 'this' until we know we need it, i.e. after
 894    overload resolution has chosen a non-static member function.  At that
 895    point we call this function to turn a dummy object into a use of the
 896    'this' capture.  */
 897
 898 tree
 899 maybe_resolve_dummy (tree object, bool add_capture_p)
 900 {
 901   if (tree lam = resolvable_dummy_lambda (object))
 902     if (tree cap = lambda_expr_this_capture (lam, add_capture_p))
 903       if (cap != error_mark_node)
 904         object = build_fold_indirect_ref (cap);
 905
 906   return object;
 907 }
 908
 909 /* When parsing a generic lambda containing an argument-dependent
 910    member function call we defer overload resolution to instantiation
 911    time.  But we have to know now whether to capture this or not.
 912    Do that if FNS contains any non-static fns.
 913    The std doesn't anticipate this case, but I expect this to be the
 914    outcome of discussion.  */
 915
 916 void
 917 maybe_generic_this_capture (tree object, tree fns)
 918 {
 919   if (tree lam = resolvable_dummy_lambda (object))
 920     if (!LAMBDA_EXPR_THIS_CAPTURE (lam))
 921       {
 922         /* We've not yet captured, so look at the function set of
 923            interest.  */
 924         if (BASELINK_P (fns))
 925           fns = BASELINK_FUNCTIONS (fns);
 926         bool id_expr = TREE_CODE (fns) == TEMPLATE_ID_EXPR;
 927         if (id_expr)
 928           fns = TREE_OPERAND (fns, 0);
 929
 930         for (lkp_iterator iter (fns); iter; ++iter)
 931           if ((!id_expr || TREE_CODE (*iter) == TEMPLATE_DECL)
 932               && DECL_NONSTATIC_MEMBER_FUNCTION_P (*iter))
 933             {
 934               /* Found a non-static member.  Capture this.  */
 935               lambda_expr_this_capture (lam, true);
 936               break;
 937             }
 938       }
 939 }
 940
 941 /* Returns the innermost non-lambda function.  */
 942
 943 tree
 944 current_nonlambda_function (void)
 945 {
 946   tree fn = current_function_decl;
 947   while (fn && LAMBDA_FUNCTION_P (fn))
 948     fn = decl_function_context (fn);
 949   return fn;
 950 }
 951
 952 /* Returns the method basetype of the innermost non-lambda function, or
 953    NULL_TREE if none.  */
 954
 955 tree
 956 nonlambda_method_basetype (void)
 957 {
 958   tree fn, type;
 959   if (!current_class_ref)
 960     return NULL_TREE;
 961
 962   type = current_class_type;
 963   if (!type || !LAMBDA_TYPE_P (type))
 964     return type;
 965
 966   /* Find the nearest enclosing non-lambda function.  */
 967   fn = TYPE_NAME (type);
 968   do
 969     fn = decl_function_context (fn);
 970   while (fn && LAMBDA_FUNCTION_P (fn));
 971
 972   if (!fn || !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
 973     return NULL_TREE;
 974
 975   return TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
 976 }
 977
 978 /* Like current_scope, but looking through lambdas.  */
 979
 980 tree
 981 current_nonlambda_scope (void)
 982 {
 983   tree scope = current_scope ();
 984   for (;;)
 985     {
 986       if (TREE_CODE (scope) == FUNCTION_DECL
 987           && LAMBDA_FUNCTION_P (scope))
 988         {
 989           scope = CP_TYPE_CONTEXT (DECL_CONTEXT (scope));
 990           continue;
 991         }
 992       else if (LAMBDA_TYPE_P (scope))
 993         {
 994           scope = CP_TYPE_CONTEXT (scope);
 995           continue;
 996         }
 997       break;
 998     }
 999   return scope;
1000 }
1001
1002 /* Helper function for maybe_add_lambda_conv_op; build a CALL_EXPR with
1003    indicated FN and NARGS, but do not initialize the return type or any of the
1004    argument slots.  */
1005
1006 static tree
1007 prepare_op_call (tree fn, int nargs)
1008 {
1009   tree t;
1010
1011   t = build_vl_exp (CALL_EXPR, nargs + 3);
1012   CALL_EXPR_FN (t) = fn;
1013   CALL_EXPR_STATIC_CHAIN (t) = NULL;
1014
1015   return t;
1016 }
1017
1018 /* Return true iff CALLOP is the op() for a generic lambda.  */
1019
1020 bool
1021 generic_lambda_fn_p (tree callop)
1022 {
1023   return (LAMBDA_FUNCTION_P (callop)
1024           && DECL_TEMPLATE_INFO (callop)
1025           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (callop)));
1026 }
1027
1028 /* If the closure TYPE has a static op(), also add a conversion to function
1029    pointer.  */
1030
1031 void
1032 maybe_add_lambda_conv_op (tree type)
1033 {
1034   bool nested = (cfun != NULL);
1035   bool nested_def = decl_function_context (TYPE_MAIN_DECL (type));
1036   tree callop = lambda_function (type);
1037   tree lam = CLASSTYPE_LAMBDA_EXPR (type);
1038
1039   if (LAMBDA_EXPR_CAPTURE_LIST (lam) != NULL_TREE
1040       || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) != CPLD_NONE)
1041     return;
1042
1043   if (processing_template_decl)
1044     return;
1045
1046   bool const generic_lambda_p = generic_lambda_fn_p (callop);
1047
1048   if (!generic_lambda_p && DECL_INITIAL (callop) == NULL_TREE)
1049     {
1050       /* If the op() wasn't instantiated due to errors, give up.  */
1051       gcc_assert (errorcount || sorrycount);
1052       return;
1053     }
1054
1055   /* Non-template conversion operators are defined directly with build_call_a
1056      and using DIRECT_ARGVEC for arguments (including 'this').  Templates are
1057      deferred and the CALL is built in-place.  In the case of a deduced return
1058      call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
1059      the return type is also built in-place.  The arguments of DECLTYPE_CALL in
1060      the return expression may differ in flags from those in the body CALL.  In
1061      particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
1062      the body CALL, but not in DECLTYPE_CALL.  */
1063
1064   vec<tree, va_gc> *direct_argvec = 0;
1065   tree decltype_call = 0, call = 0;
1066   tree optype = TREE_TYPE (callop);
1067   tree fn_result = TREE_TYPE (optype);
1068
1069   tree thisarg = build_nop (TREE_TYPE (DECL_ARGUMENTS (callop)),
1070                             null_pointer_node);
1071   if (generic_lambda_p)
1072     {
1073       ++processing_template_decl;
1074
1075       /* Prepare the dependent member call for the static member function
1076          '_FUN' and, potentially, prepare another call to be used in a decltype
1077          return expression for a deduced return call op to allow for simple
1078          implementation of the conversion operator.  */
1079
1080       tree instance = cp_build_fold_indirect_ref (thisarg);
1081       tree objfn = build_min (COMPONENT_REF, NULL_TREE,
1082                               instance, DECL_NAME (callop), NULL_TREE);
1083       int nargs = list_length (DECL_ARGUMENTS (callop)) - 1;
1084
1085       call = prepare_op_call (objfn, nargs);
1086       if (type_uses_auto (fn_result))
1087         decltype_call = prepare_op_call (objfn, nargs);
1088     }
1089   else
1090     {
1091       direct_argvec = make_tree_vector ();
1092       direct_argvec->quick_push (thisarg);
1093     }
1094
1095   /* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to
1096      declare the static member function "_FUN" below.  For each arg append to
1097      DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated
1098      call args (for the template case).  If a parameter pack is found, expand
1099      it, flagging it as PACK_EXPANSION_LOCAL_P for the body call.  */
1100
1101   tree fn_args = NULL_TREE;
1102   {
1103     int ix = 0;
1104     tree src = DECL_CHAIN (DECL_ARGUMENTS (callop));
1105     tree tgt = NULL;
1106
1107     while (src)
1108       {
1109         tree new_node = copy_node (src);
1110
1111         if (!fn_args)
1112           fn_args = tgt = new_node;
1113         else
1114           {
1115             TREE_CHAIN (tgt) = new_node;
1116             tgt = new_node;
1117           }
1118
1119         mark_exp_read (tgt);
1120
1121         if (generic_lambda_p)
1122           {
1123             /* Avoid capturing variables in this context.  */
1124             ++cp_unevaluated_operand;
1125             tree a = forward_parm (tgt);
1126             --cp_unevaluated_operand;
1127
1128             CALL_EXPR_ARG (call, ix) = a;
1129             if (decltype_call)
1130               CALL_EXPR_ARG (decltype_call, ix) = unshare_expr (a);
1131
1132             if (PACK_EXPANSION_P (a))
1133               /* Set this after unsharing so it's not in decltype_call.  */
1134               PACK_EXPANSION_LOCAL_P (a) = true;
1135
1136             ++ix;
1137           }
1138         else
1139           vec_safe_push (direct_argvec, tgt);
1140
1141         src = TREE_CHAIN (src);
1142       }
1143   }
1144
1145   if (generic_lambda_p)
1146     {
1147       if (decltype_call)
1148         {
1149           fn_result = finish_decltype_type
1150             (decltype_call, /*id_expression_or_member_access_p=*/false,
1151              tf_warning_or_error);
1152         }
1153     }
1154   else
1155     call = build_call_a (callop,
1156                          direct_argvec->length (),
1157                          direct_argvec->address ());
1158
1159   CALL_FROM_THUNK_P (call) = 1;
1160   SET_EXPR_LOCATION (call, UNKNOWN_LOCATION);
1161
1162   tree stattype = build_function_type (fn_result, FUNCTION_ARG_CHAIN (callop));
1163   stattype = (cp_build_type_attribute_variant
1164               (stattype, TYPE_ATTRIBUTES (optype)));
1165   if (flag_noexcept_type
1166       && TYPE_NOTHROW_P (TREE_TYPE (callop)))
1167     stattype = build_exception_variant (stattype, noexcept_true_spec);
1168
1169   if (generic_lambda_p)
1170     --processing_template_decl;
1171
1172   /* First build up the conversion op.  */
1173
1174   tree rettype = build_pointer_type (stattype);
1175   tree name = make_conv_op_name (rettype);
1176   tree thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1177   tree fntype = build_method_type_directly (thistype, rettype, void_list_node);
1178   tree convfn = build_lang_decl (FUNCTION_DECL, name, fntype);
1179   SET_DECL_LANGUAGE (convfn, lang_cplusplus);
1180   tree fn = convfn;
1181   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
1182   SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
1183   grokclassfn (type, fn, NO_SPECIAL);
1184   set_linkage_according_to_type (type, fn);
1185   rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
1186   DECL_IN_AGGR_P (fn) = 1;
1187   DECL_ARTIFICIAL (fn) = 1;
1188   DECL_NOT_REALLY_EXTERN (fn) = 1;
1189   DECL_DECLARED_INLINE_P (fn) = 1;
1190   DECL_ARGUMENTS (fn) = build_this_parm (fn, fntype, TYPE_QUAL_CONST);
1191
1192   if (nested_def)
1193     DECL_INTERFACE_KNOWN (fn) = 1;
1194
1195   if (generic_lambda_p)
1196     fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
1197
1198   add_method (type, fn, false);
1199
1200   /* Generic thunk code fails for varargs; we'll complain in mark_used if
1201      the conversion op is used.  */
1202   if (varargs_function_p (callop))
1203     {
1204       DECL_DELETED_FN (fn) = 1;
1205       return;
1206     }
1207
1208   /* Now build up the thunk to be returned.  */
1209
1210   name = get_identifier ("_FUN");
1211   tree statfn = build_lang_decl (FUNCTION_DECL, name, stattype);
1212   SET_DECL_LANGUAGE (statfn, lang_cplusplus);
1213   fn = statfn;
1214   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
1215   grokclassfn (type, fn, NO_SPECIAL);
1216   set_linkage_according_to_type (type, fn);
1217   rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
1218   DECL_IN_AGGR_P (fn) = 1;
1219   DECL_ARTIFICIAL (fn) = 1;
1220   DECL_NOT_REALLY_EXTERN (fn) = 1;
1221   DECL_DECLARED_INLINE_P (fn) = 1;
1222   DECL_STATIC_FUNCTION_P (fn) = 1;
1223   DECL_ARGUMENTS (fn) = fn_args;
1224   for (tree arg = fn_args; arg; arg = DECL_CHAIN (arg))
1225     {
1226       /* Avoid duplicate -Wshadow warnings.  */
1227       DECL_NAME (arg) = NULL_TREE;
1228       DECL_CONTEXT (arg) = fn;
1229     }
1230   if (nested_def)
1231     DECL_INTERFACE_KNOWN (fn) = 1;
1232
1233   if (generic_lambda_p)
1234     fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
1235
1236   if (flag_sanitize & SANITIZE_NULL)
1237     /* Don't UBsan this function; we're deliberately calling op() with a null
1238        object argument.  */
1239     add_no_sanitize_value (fn, SANITIZE_UNDEFINED);
1240
1241   add_method (type, fn, false);
1242
1243   if (nested)
1244     push_function_context ();
1245   else
1246     /* Still increment function_depth so that we don't GC in the
1247        middle of an expression.  */
1248     ++function_depth;
1249
1250   /* Generate the body of the thunk.  */
1251
1252   start_preparsed_function (statfn, NULL_TREE,
1253                             SF_PRE_PARSED | SF_INCLASS_INLINE);
1254   if (DECL_ONE_ONLY (statfn))
1255     {
1256       /* Put the thunk in the same comdat group as the call op.  */
1257       cgraph_node::get_create (statfn)->add_to_same_comdat_group
1258         (cgraph_node::get_create (callop));
1259     }
1260   tree body = begin_function_body ();
1261   tree compound_stmt = begin_compound_stmt (0);
1262   if (!generic_lambda_p)
1263     {
1264       set_flags_from_callee (call);
1265       if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call)))
1266         call = build_cplus_new (TREE_TYPE (call), call, tf_warning_or_error);
1267     }
1268   call = convert_from_reference (call);
1269   finish_return_stmt (call);
1270
1271   finish_compound_stmt (compound_stmt);
1272   finish_function_body (body);
1273
1274   fn = finish_function (/*inline_p=*/true);
1275   if (!generic_lambda_p)
1276     expand_or_defer_fn (fn);
1277
1278   /* Generate the body of the conversion op.  */
1279
1280   start_preparsed_function (convfn, NULL_TREE,
1281                             SF_PRE_PARSED | SF_INCLASS_INLINE);
1282   body = begin_function_body ();
1283   compound_stmt = begin_compound_stmt (0);
1284
1285   /* decl_needed_p needs to see that it's used.  */
1286   TREE_USED (statfn) = 1;
1287   finish_return_stmt (decay_conversion (statfn, tf_warning_or_error));
1288
1289   finish_compound_stmt (compound_stmt);
1290   finish_function_body (body);
1291
1292   fn = finish_function (/*inline_p=*/true);
1293   if (!generic_lambda_p)
1294     expand_or_defer_fn (fn);
1295
1296   if (nested)
1297     pop_function_context ();
1298   else
1299     --function_depth;
1300 }
1301
1302 /* True if FN is the static function "_FUN" that gets returned from the lambda
1303    conversion operator.  */
1304
1305 bool
1306 lambda_static_thunk_p (tree fn)
1307 {
1308   return (fn && TREE_CODE (fn) == FUNCTION_DECL
1309           && DECL_ARTIFICIAL (fn)
1310           && DECL_STATIC_FUNCTION_P (fn)
1311           && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fn)));
1312 }
1313
1314 /* Returns true iff VAL is a lambda-related declaration which should
1315    be ignored by unqualified lookup.  */
1316
1317 bool
1318 is_lambda_ignored_entity (tree val)
1319 {
1320   /* Look past normal capture proxies.  */
1321   if (is_normal_capture_proxy (val))
1322     return true;
1323
1324   /* Always ignore lambda fields, their names are only for debugging.  */
1325   if (TREE_CODE (val) == FIELD_DECL
1326       && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val)))
1327     return true;
1328
1329   /* None of the lookups that use qualify_lookup want the op() from the
1330      lambda; they want the one from the enclosing class.  */
1331   if (TREE_CODE (val) == FUNCTION_DECL && LAMBDA_FUNCTION_P (val))
1332     return true;
1333
1334   return false;
1335 }
1336
1337 /* Lambdas that appear in variable initializer or default argument scope
1338    get that in their mangling, so we need to record it.  We might as well
1339    use the count for function and namespace scopes as well.  */
1340 static GTY(()) tree lambda_scope;
1341 static GTY(()) int lambda_count;
1342 struct GTY(()) tree_int
1343 {
1344   tree t;
1345   int i;
1346 };
1347 static GTY(()) vec<tree_int, va_gc> *lambda_scope_stack;
1348
1349 void
1350 start_lambda_scope (tree decl)
1351 {
1352   tree_int ti;
1353   gcc_assert (decl);
1354   /* Once we're inside a function, we ignore variable scope and just push
1355      the function again so that popping works properly.  */
1356   if (current_function_decl && TREE_CODE (decl) == VAR_DECL)
1357     decl = current_function_decl;
1358   ti.t = lambda_scope;
1359   ti.i = lambda_count;
1360   vec_safe_push (lambda_scope_stack, ti);
1361   if (lambda_scope != decl)
1362     {
1363       /* Don't reset the count if we're still in the same function.  */
1364       lambda_scope = decl;
1365       lambda_count = 0;
1366     }
1367 }
1368
1369 void
1370 record_lambda_scope (tree lambda)
1371 {
1372   LAMBDA_EXPR_EXTRA_SCOPE (lambda) = lambda_scope;
1373   LAMBDA_EXPR_DISCRIMINATOR (lambda) = lambda_count++;
1374 }
1375
1376 void
1377 finish_lambda_scope (void)
1378 {
1379   tree_int *p = &lambda_scope_stack->last ();
1380   if (lambda_scope != p->t)
1381     {
1382       lambda_scope = p->t;
1383       lambda_count = p->i;
1384     }
1385   lambda_scope_stack->pop ();
1386 }
1387
1388 tree
1389 start_lambda_function (tree fco, tree lambda_expr)
1390 {
1391   /* Let the front end know that we are going to be defining this
1392      function.  */
1393   start_preparsed_function (fco,
1394                             NULL_TREE,
1395                             SF_PRE_PARSED | SF_INCLASS_INLINE);
1396
1397   tree body = begin_function_body ();
1398
1399   /* Push the proxies for any explicit captures.  */
1400   for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap;
1401        cap = TREE_CHAIN (cap))
1402     build_capture_proxy (TREE_PURPOSE (cap), TREE_VALUE (cap));
1403
1404   return body;
1405 }
1406
1407 /* Subroutine of prune_lambda_captures: CAP is a node in
1408    LAMBDA_EXPR_CAPTURE_LIST.  Return the variable it captures for which we
1409    might optimize away the capture, or NULL_TREE if there is no such
1410    variable.  */
1411
1412 static tree
1413 var_to_maybe_prune (tree cap)
1414 {
1415   if (LAMBDA_CAPTURE_EXPLICIT_P (cap))
1416     /* Don't prune explicit captures.  */
1417     return NULL_TREE;
1418
1419   tree mem = TREE_PURPOSE (cap);
1420   if (!DECL_P (mem) || !DECL_NORMAL_CAPTURE_P (mem))
1421     /* Packs and init-captures aren't captures of constant vars.  */
1422     return NULL_TREE;
1423
1424   tree init = TREE_VALUE (cap);
1425   if (is_normal_capture_proxy (init))
1426     init = DECL_CAPTURED_VARIABLE (init);
1427   if (decl_constant_var_p (init))
1428     return init;
1429
1430   return NULL_TREE;
1431 }
1432
1433 /* walk_tree helper for prune_lambda_captures: Remember which capture proxies
1434    for constant variables are actually used in the lambda body.
1435
1436    There will always be a DECL_EXPR for the capture proxy; remember it when we
1437    see it, but replace it with any other use.  */
1438
1439 static tree
1440 mark_const_cap_r (tree *t, int *walk_subtrees, void *data)
1441 {
1442   hash_map<tree,tree*> &const_vars = *(hash_map<tree,tree*>*)data;
1443
1444   tree var = NULL_TREE;
1445   if (TREE_CODE (*t) == DECL_EXPR)
1446     {
1447       tree decl = DECL_EXPR_DECL (*t);
1448       if (is_constant_capture_proxy (decl))
1449         var = DECL_CAPTURED_VARIABLE (decl);
1450       *walk_subtrees = 0;
1451     }
1452   else if (is_constant_capture_proxy (*t))
1453     var = DECL_CAPTURED_VARIABLE (*t);
1454
1455   if (var)
1456     {
1457       tree *&slot = const_vars.get_or_insert (var);
1458       if (!slot || VAR_P (*t))
1459         slot = t;
1460     }
1461
1462   return NULL_TREE;
1463 }
1464
1465 /* We're at the end of processing a lambda; go back and remove any captures of
1466    constant variables for which we've folded away all uses.  */
1467
1468 static void
1469 prune_lambda_captures (tree body)
1470 {
1471   tree lam = current_lambda_expr ();
1472   if (!LAMBDA_EXPR_CAPTURE_OPTIMIZED (lam))
1473     /* No uses were optimized away.  */
1474     return;
1475   if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) == CPLD_NONE)
1476     /* No default captures, and we don't prune explicit captures.  */
1477     return;
1478
1479   hash_map<tree,tree*> const_vars;
1480
1481   cp_walk_tree_without_duplicates (&body, mark_const_cap_r, &const_vars);
1482
1483   tree *fieldp = &TYPE_FIELDS (LAMBDA_EXPR_CLOSURE (lam));
1484   for (tree *capp = &LAMBDA_EXPR_CAPTURE_LIST (lam); *capp; )
1485     {
1486       tree cap = *capp;
1487       if (tree var = var_to_maybe_prune (cap))
1488         {
1489           tree *use = *const_vars.get (var);
1490           if (TREE_CODE (*use) == DECL_EXPR)
1491             {
1492               /* All uses of this capture were folded away, leaving only the
1493                  proxy declaration.  */
1494
1495               /* Splice the capture out of LAMBDA_EXPR_CAPTURE_LIST.  */
1496               *capp = TREE_CHAIN (cap);
1497
1498               /* And out of TYPE_FIELDS.  */
1499               tree field = TREE_PURPOSE (cap);
1500               while (*fieldp != field)
1501                 fieldp = &DECL_CHAIN (*fieldp);
1502               *fieldp = DECL_CHAIN (*fieldp);
1503
1504               /* And remove the capture proxy declaration.  */
1505               *use = void_node;
1506               continue;
1507             }
1508         }
1509
1510       capp = &TREE_CHAIN (cap);
1511     }
1512 }
1513
1514 void
1515 finish_lambda_function (tree body)
1516 {
1517   finish_function_body (body);
1518
1519   prune_lambda_captures (body);
1520
1521   /* Finish the function and generate code for it if necessary.  */
1522   tree fn = finish_function (/*inline_p=*/true);
1523
1524   /* Only expand if the call op is not a template.  */
1525   if (!DECL_TEMPLATE_INFO (fn))
1526     expand_or_defer_fn (fn);
1527 }
1528
1529 #include "gt-cp-lambda.h"