Re: [pushed] c++: constant, array, lambda, template [PR108975]

[Patrick Palka <ppalka@redhat.com>]

On Fri, 17 Mar 2023, Jason Merrill via Gcc-patches wrote:

> Tested x86_64-pc-linux-gnu, applying to trunk.
> 
> -- 8< --
> 
> When a lambda refers to a constant local variable in the enclosing scope, we
> tentatively capture it, but if we end up pulling out its constant value, we
> go back at the end of the lambda and prune any unneeded captures.  Here
> while parsing the template we decided that the dim capture was unneeded,
> because we folded it away, but then we brought back the use in the template
> trees that try to preserve the source representation with added type info.
> So then when we tried to instantiate that use, we couldn't find what it was
> trying to use, and crashed.
> 
> Fixed by not trying to prune when parsing a template; we'll prune at
> instantiation time.
> 
> 	PR c++/108975
> 
> gcc/cp/ChangeLog:
> 
> 	* lambda.cc (prune_lambda_captures): Don't bother in a template.
> 
> gcc/testsuite/ChangeLog:
> 
> 	* g++.dg/cpp0x/lambda/lambda-const11.C: New test.
> ---
>  gcc/cp/lambda.cc                                   |  3 +++
>  gcc/testsuite/g++.dg/cpp0x/lambda/lambda-const11.C | 14 ++++++++++++++
>  2 files changed, 17 insertions(+)
>  create mode 100644 gcc/testsuite/g++.dg/cpp0x/lambda/lambda-const11.C
> 
> diff --git a/gcc/cp/lambda.cc b/gcc/cp/lambda.cc
> index 212990a21bf..9925209b2ed 100644
> --- a/gcc/cp/lambda.cc
> +++ b/gcc/cp/lambda.cc
> @@ -1760,6 +1760,9 @@ prune_lambda_captures (tree body)
>    if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) == CPLD_NONE)
>      /* No default captures, and we don't prune explicit captures.  */
>      return;
> +  /* Don't bother pruning in a template, we'll prune at instantiation time.  */
> +  if (dependent_type_p (TREE_TYPE (lam)))
> +    return;
>  
>    hash_map<tree,tree*> const_vars;
>  
> diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-const11.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-const11.C
> new file mode 100644
> index 00000000000..26af75bf132
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-const11.C
> @@ -0,0 +1,14 @@
> +// PR c++/108975
> +// { dg-do compile { target c++11 } }
> +
> +template<class T>
> +void f() {
> +  constexpr int dim = 1;
> +  auto l = [&] {
> +    int n[dim * 1];
> +  };
> +  // In f<int>, we shouldn't actually capture dim.
> +  static_assert (sizeof(l) == 1, "");
> +}
> +
> +template void f<int>();

Sadly I think more is needed to fix the generic lambda case, we still
crash for:

  template<class T>
  void f() {
    constexpr int dim = 1;
    auto l = [&] (auto) {
      int n[dim * 1];
    };
    l(0);
    // In f<int>, we shouldn't actually capture dim.
    static_assert (sizeof(l) == 1, "");
  }

  template void f<int>();

It seems prune_lambda_captures doesn't thoroughly walk the lambda body,
and so fails to find all uses of constant captures such as in 'int n[dim * 1]'
or 'using type = decltype(g<dim * 1>())' (in the original testcase the
constant capture use occurred inside an alias declaration).

I guess generic lambdas are special in that their body is always
templated and so fewer constant captures are folded away by instantiation
time.  So they are more sensitive to incomplete walking by
prune_lambda_captures.