When we regenerate a lambda, the resulting op() doesn't have any
template information, so we can't delay instantiating default
arguments like we do for a normal template function. I believe this
is also the direction of the core working group for default arguments
in local extern function declarations, so I don't think we need to
invent a mechanism to remember those template arguments for later use.
Tested x86_64-pc-linux-gnu, applying to trunk.
commit 17d672e6eaf10f96174b00207c60b5467693877f
Author: Jason Merrill <ja...@redhat.com>
Date: Thu Aug 31 13:03:31 2017 -0400
PR c++/82053 - ICE with default argument in lambda in template
* pt.c (tsubst_arg_types): Substitute default arguments for lambdas
in templates.
(retrieve_specialization): Use lambda_fn_in_template_p.
* cp-tree.h: Declare it.
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 20fa039..a0e31d3 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6821,6 +6821,7 @@ extern tree current_nonlambda_function (void);
extern tree nonlambda_method_basetype (void);
extern tree current_nonlambda_scope (void);
extern bool generic_lambda_fn_p (tree);
+extern bool lambda_fn_in_template_p (tree);
extern void maybe_add_lambda_conv_op (tree);
extern bool is_lambda_ignored_entity (tree);
extern bool lambda_static_thunk_p (tree);
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 4a65e31..ec7bbc8 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -1193,16 +1193,8 @@ retrieve_specialization (tree tmpl, tree args, hashval_t
hash)
/* Lambda functions in templates aren't instantiated normally, but through
tsubst_lambda_expr. */
- if (LAMBDA_FUNCTION_P (tmpl))
- {
- bool generic = PRIMARY_TEMPLATE_P (tmpl);
- if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)) > generic)
- return NULL_TREE;
-
- /* But generic lambda functions are instantiated normally, once their
- containing context is fully instantiated. */
- gcc_assert (generic);
- }
+ if (lambda_fn_in_template_p (tmpl))
+ return NULL_TREE;
if (optimize_specialization_lookup_p (tmpl))
{
@@ -12579,7 +12571,7 @@ tsubst_template_decl (tree t, tree args, tsubst_flags_t
complain,
bool
lambda_fn_in_template_p (tree fn)
{
- if (!LAMBDA_FUNCTION_P (fn))
+ if (!fn || !LAMBDA_FUNCTION_P (fn))
return false;
tree closure = DECL_CONTEXT (fn);
return CLASSTYPE_TEMPLATE_INFO (closure) != NULL_TREE;
@@ -13248,6 +13240,13 @@ tsubst_arg_types (tree arg_types,
done in build_over_call. */
default_arg = TREE_PURPOSE (arg_types);
+ /* Except that we do substitute default arguments under tsubst_lambda_expr,
+ since the new op() won't have any associated template arguments for us
+ to refer to later. */
+ if (lambda_fn_in_template_p (in_decl))
+ default_arg = tsubst_copy_and_build (default_arg, args, complain,
in_decl,
+ false/*fn*/, false/*constexpr*/);
+
if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
{
/* We've instantiated a template before its default arguments
diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-defarg7.C
b/gcc/testsuite/g++.dg/cpp1y/lambda-defarg7.C
new file mode 100644
index 0000000..f67dfee
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/lambda-defarg7.C
@@ -0,0 +1,13 @@
+// PR c++/82053
+// { dg-do compile { target c++14 } }
+
+template<class T>
+int fn() { return 42; }
+
+template<class T>
+auto lam = [](int = fn<T>()){};
+
+int main()
+{
+ lam<int>();
+}
