Support dumping type bindings and 'mutable' qualifier in lambda diagnostics.

* error.c (dump_lambda_function): New function, dependent on ...
	(maybe_dump_with_clause): ... this new function, factored out of ...
	(subst_to_string): ... here and ...
	(dump_function_decl): ... here.  Updated to early-out with call to
	dump_lambda_function after determining template bindings.
---
Hi Gaby,

On 29.08.2013 18:04, Adam Butcher wrote:
> On 29.08.2013 16:25, Gabriel Dos Reis wrote:
> >
> > Document the new functions.
> > Use pp->translate_string ("with") instead of
> > pp_cxx_ws_string (pp, M_("with")).
> >
> Done.  In documenting 'maybe_dump_template_bindings' and reviewing
> it again I'm not sure it's got the right name.  It wraps
> 'dump_template_bindings' in "[with " and "]".  So it does more than
> just filter a call to 'dump_template_bindings'.
>
> Any suggestions?  What do you think of 'maybe_dump_with_clause' or
> something similar?
>
Here's a diff with the name change (though I'm not all that happy with
it) and the docs.

I've also reimplemented subst_to_string in terms of the new function
as it was duplicating much of the code from dump_function_decl (the
only downside of this is some unnecessary tests in the subst_to_string
case but I think they should get optimized away if it were inlined --
we're dealing with diagnostics formatting here anyway so performance
is probably not a big factor).

Cheers,
Adam
---
 gcc/cp/error.c | 73 ++++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 46 insertions(+), 27 deletions(-)

On Thu, Aug 29, 2013 at 1:51 PM, Adam Butcher <adam@jessamine.co.uk> wrote:
>         * error.c (dump_lambda_function): New function, dependent on ...
>         (maybe_dump_with_clause): ... this new function, factored out of ...
>         (subst_to_string): ... here and ...
>         (dump_function_decl): ... here.  Updated to early-out with call to
>         dump_lambda_function after determining template bindings.
> ---
> Hi Gaby,
>
> On 29.08.2013 18:04, Adam Butcher wrote:
>> On 29.08.2013 16:25, Gabriel Dos Reis wrote:
>> >
>> > Document the new functions.
>> > Use pp->translate_string ("with") instead of
>> > pp_cxx_ws_string (pp, M_("with")).
>> >
>> Done.  In documenting 'maybe_dump_template_bindings' and reviewing
>> it again I'm not sure it's got the right name.  It wraps
>> 'dump_template_bindings' in "[with " and "]".  So it does more than
>> just filter a call to 'dump_template_bindings'.
>>
>> Any suggestions?  What do you think of 'maybe_dump_with_clause' or
>> something similar?
>>
> Here's a diff with the name change (though I'm not all that happy with
> it) and the docs.

call it dump_substitution.  We don't need the 'maybe_' prefix since
an empty substitution is the identity transformation.

>
> I've also reimplemented subst_to_string in terms of the new function
> as it was duplicating much of the code from dump_function_decl (the
> only downside of this is some unnecessary tests in the subst_to_string
> case but I think they should get optimized away if it were inlined --
> we're dealing with diagnostics formatting here anyway so performance
> is probably not a big factor).

Patch OK with that change.  Thanks!

>
> Cheers,
> Adam
> ---
>  gcc/cp/error.c | 73 ++++++++++++++++++++++++++++++++++++----------------------
>  1 file changed, 46 insertions(+), 27 deletions(-)
>
> diff --git a/gcc/cp/error.c b/gcc/cp/error.c
> index c82a0ce..3d1e173 100644
> --- a/gcc/cp/error.c
> +++ b/gcc/cp/error.c
> @@ -1363,6 +1363,47 @@ find_typenames (tree t)
>    return ft.typenames;
>  }
>
> +/* Output the "[with ...]" clause for a template instantiation T iff
> +   TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable.  T may be NULL if
> +   formatting a deduction/substitution diagnostic rather than an
> +   instantiation.  */
> +
> +static void
> +maybe_dump_with_clause (cxx_pretty_printer *pp,
> +                       tree t, tree template_parms, tree template_args,
> +                       int flags)
> +{
> +  if (template_parms != NULL_TREE && template_args != NULL_TREE
> +      && !(flags & TFF_NO_TEMPLATE_BINDINGS))
> +    {
> +      vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
> +      pp_cxx_whitespace (pp);
> +      pp_cxx_left_bracket (pp);
> +      pp->translate_string ("with");
> +      pp_cxx_whitespace (pp);
> +      dump_template_bindings (pp, template_parms, template_args, typenames);
> +      pp_cxx_right_bracket (pp);
> +    }
> +}
> +
> +/* Dump the lambda function FN including its 'mutable' qualifier and any
> +   template bindings.  */
> +
> +static void
> +dump_lambda_function (cxx_pretty_printer *pp,
> +                     tree fn, tree template_parms, tree template_args,
> +                     int flags)
> +{
> +  /* A lambda's signature is essentially its "type".  */
> +  dump_type (pp, DECL_CONTEXT (fn), flags);
> +  if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
> +    {
> +      pp->padding = pp_before;
> +      pp_c_ws_string (pp, "mutable");
> +    }
> +  maybe_dump_with_clause (pp, fn, template_parms, template_args, flags);
> +}
> +
>  /* Pretty print a function decl. There are several ways we want to print a
>     function declaration. The TFF_ bits in FLAGS tells us how to behave.
>     As error can only apply the '#' flag once to give 0 and 1 for V, there
> @@ -1379,15 +1420,6 @@ dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
>    int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
>    int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
>    tree exceptions;
> -  vec<tree, va_gc> *typenames = NULL;
> -
> -  if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
> -    {
> -      /* A lambda's signature is essentially its "type", so defer.  */
> -      gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
> -      dump_type (pp, DECL_CONTEXT (t), flags);
> -      return;
> -    }
>
>    flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
>    if (TREE_CODE (t) == TEMPLATE_DECL)
> @@ -1409,10 +1441,12 @@ dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
>         {
>           template_parms = DECL_TEMPLATE_PARMS (tmpl);
>           t = tmpl;
> -         typenames = find_typenames (t);
>         }
>      }
>
> +  if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
> +    return dump_lambda_function (pp, t, template_parms, template_args, flags);
> +
>    fntype = TREE_TYPE (t);
>    parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
>
> @@ -1476,17 +1510,7 @@ dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
>        if (show_return)
>         dump_type_suffix (pp, TREE_TYPE (fntype), flags);
>
> -      /* If T is a template instantiation, dump the parameter binding.  */
> -      if (template_parms != NULL_TREE && template_args != NULL_TREE
> -         && !(flags & TFF_NO_TEMPLATE_BINDINGS))
> -       {
> -         pp_cxx_whitespace (pp);
> -         pp_cxx_left_bracket (pp);
> -         pp_cxx_ws_string (pp, M_("with"));
> -         pp_cxx_whitespace (pp);
> -         dump_template_bindings (pp, template_parms, template_args, typenames);
> -         pp_cxx_right_bracket (pp);
> -       }
> +      maybe_dump_with_clause (pp, t, template_parms, template_args, flags);
>      }
>    else if (template_args)
>      {
> @@ -2950,12 +2974,7 @@ subst_to_string (tree p)
>
>    reinit_cxx_pp ();
>    dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags);
> -  pp_cxx_whitespace (cxx_pp);
> -  pp_cxx_left_bracket (cxx_pp);
> -  pp_cxx_ws_string (cxx_pp, M_("with"));
> -  pp_cxx_whitespace (cxx_pp);
> -  dump_template_bindings (cxx_pp, tparms, targs, NULL);
> -  pp_cxx_right_bracket (cxx_pp);
> +  maybe_dump_with_clause (cxx_pp, NULL, tparms, targs, /*flags=*/0);
>    return pp_ggc_formatted_text (cxx_pp);
>  }
>
> --
> 1.8.4
>