[Bug c++/97214] New: ICE in lookup_template_class_1, at cp/pt.c:9896

[Bug c++/97214] New: ICE in lookup_template_class_1, at cp/pt.c:9896

[sfranzen85 at hotmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97214

            Bug ID: 97214
           Summary: ICE in lookup_template_class_1, at cp/pt.c:9896
           Product: gcc
           Version: 10.2.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: sfranzen85 at hotmail dot com
  Target Milestone: ---

The following snippet reproduces an error I encountered with lambdas:

struct Foo {
    // void operator()(int) {}

    template<typename T>
    void operator()(T, T)
    {
        auto bar = [this](auto&& v){ operator()(v); };
    }
};

int main ()
{
    Foo{}(0,1);
    return 0;
}

Full error:
../src/main.cpp: In instantiation of ‘void Foo::operator()(T, T) [with T =
int]’:
../src/main.cpp:13:14:   required from here
../src/main.cpp:7:38: internal compiler error: in lookup_template_class_1, at
cp/pt.c:9896
    7 |         auto bar = [this](auto&& v){ operator()(v); };
      |                                      ^~~~~~~~~~

Further observations:
* The error appears regardless of available operator()() overloads;
* It only appears if the function call is unqualified, e.g. (*this)(v) is fine
if the overload exists.

A possibly related error is given using a version of Foo without a function
template:
struct Foo {
    void operator()(int) {}

    void operator()(int a, int)
    {
        auto bar = [this](auto&& v){ operator()(v); };
        bar(a);
    }
};

../src/main.cpp: In instantiation of ‘Foo::operator()(int,
int)::<lambda(auto:1&&)> [with auto:1 = int&]’:
../src/main.cpp:8:14:   required from here
../src/main.cpp:7:48: error: use of ‘Foo::operator()(int,
int)::<lambda(auto:1&&)> [with auto:1 = int&]’ before deduction of ‘auto’
    7 |         auto bar = [this](auto&& v){ operator()(v); };
      |                                      ~~~~~~~~~~^~~

This error similarly only appears with the unqualified call, and also
disappears if the lambda has '-> void'.

[Bug c++/97214] ICE in lookup_template_class_1, at cp/pt.c:9896

[sfranzen85 at hotmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97214

--- Comment #1 from Steven Franzen <sfranzen85 at hotmail dot com> ---
Bug 97219 looks similar. Unqualified name lookup should consider the scope
containing the lambda, which here is a member function and also includes the
full scope of its class. Similar example at
http://en.cppreference.com/w/cpp/language/lambda:

For the purpose of name lookup, determining the type and value of the this
pointer and for accessing non-static class members, the body of the closure
type's function call operator is considered in the context of the
lambda-expression.

struct X {
    int x, y;
    int operator()(int);
    void f()
    {
        // the context of the following lambda is the member function X::f
        [=]()->int
        {
            return operator()(this->x + y); // X::operator()(this->x +
(*this).y)
                                            // this has type X*
        };
    }
};

[Bug c++/97214] [8/9/10/11 Regression] ICE in lookup_template_class_1, at cp/pt.c:9896

[mpolacek at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97214

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
     Ever confirmed|0                           |1
            Summary|ICE in                      |[8/9/10/11 Regression] ICE
                   |lookup_template_class_1, at |in lookup_template_class_1,
                   |cp/pt.c:9896                |at cp/pt.c:9896
   Last reconfirmed|                            |2020-10-26
                 CC|                            |jason at gcc dot gnu.org,
                   |                            |mpolacek at gcc dot gnu.org
             Status|UNCONFIRMED                 |NEW
           Priority|P3                          |P2

--- Comment #2 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
Confirmed.

commit 373d1f5f055ee378e8e773df331da85d0cffc89b
Author: Jason Merrill <jason@redhat.com>
Date:   Fri Jan 26 10:25:23 2018 -0500

    PR c++/82514 - ICE with local class in generic lambda.

            * pt.c (regenerated_lambda_fn_p): Remove.
            (enclosing_instantiation_of): Don't use it.
            (tsubst_function_decl): Call enclosing_instantiation_of.

            * pt.c (lookup_template_class_1): Add sanity check.
            * name-lookup.c (do_pushtag): Don't add closures to local_classes.

    From-SVN: r257093

[Bug c++/97214] [8/9/10/11 Regression] ICE in lookup_template_class_1, at cp/pt.c:9896

[mpolacek at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97214

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|---                         |8.5

[Bug c++/97214] [8/9/10/11 Regression] ICE in lookup_template_class_1, at cp/pt.c:9896

[mpolacek at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97214

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
         Resolution|---                         |DUPLICATE

--- Comment #3 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
This has been fixed on trunk with r11-7418, so it's a dup.

*** This bug has been marked as a duplicate of bug 95451 ***