Here the problem was that we were remembering the lookup in template scope, and then trying to reuse that lookup in the instantiation without substituting into it at all. The simplest solution is to not try to remember a lookup that finds a class-scope declaration, as in that case doing the normal lookup again at instantiation time will always find the right declarations.
Tested x86_64-pc-linux-gnu, applying to trunk. PR c++/93279 - ICE with lambda in member operator. * name-lookup.c (maybe_save_operator_binding): Don't remember class-scope bindings. --- gcc/cp/name-lookup.c | 6 ++++++ .../g++.dg/cpp0x/lambda/lambda-template16.C | 15 +++++++++++++++ 2 files changed, 21 insertions(+) create mode 100644 gcc/testsuite/g++.dg/cpp0x/lambda/lambda-template16.C diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c index cd7a5816e46..572100766cb 100644 --- a/gcc/cp/name-lookup.c +++ b/gcc/cp/name-lookup.c @@ -7616,6 +7616,12 @@ maybe_save_operator_binding (tree e) if (!fns && (fns = op_unqualified_lookup (fnname))) { + tree fn = get_first_fn (fns); + if (DECL_CLASS_SCOPE_P (fn)) + /* We don't need to remember class-scope functions, normal unqualified + lookup will find them again. */ + return; + bindings = tree_cons (fnname, fns, bindings); if (attr) TREE_VALUE (attr) = bindings; diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-template16.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-template16.C new file mode 100644 index 00000000000..faaff68b968 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-template16.C @@ -0,0 +1,15 @@ +// PR c++/93279 +// { dg-do compile { target c++11 } } + +template <typename T> struct B { using f = int; }; +template <typename T, int N> struct E { + template <typename U, typename B<E>::f = 0> + void operator*(U l) { [l](T m) { m * l; }; } +}; + +int +main () +{ + E<E<float, 4>, 1> n; + n * 4.f; +} base-commit: c671727004b87f0f256191c3a99c50dc4888e79b -- 2.18.1