[Bug c++/102802] New: Selection of inherited operator contrary to `using` clause in C++

[Bug c++/102802] New: Selection of inherited operator contrary to `using` clause in C++

[fchelnokov at gmail dot com]

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

            Bug ID: 102802
           Summary: Selection of inherited operator contrary to `using`
                    clause in C++
           Product: gcc
           Version: 12.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: fchelnokov at gmail dot com
  Target Milestone: ---

This program is invalid:
```
using A = decltype([](int){ return 1; });
using B = decltype([](){ return 2; });

struct S : A, B {
    using A::operator();
};

int main() {
    S s;
    static_assert( s() == 2 ); // erroneously passes in GCC and Clang
}
```
It must be rejected because A::operator(int) takes 1 argument and B::operator()
shall not be considered. Only MSVC correctly rejects it now:
https://gcc.godbolt.org/z/x6x3aWzoq

Related discussion: https://stackoverflow.com/q/69601650/7325599

[Bug c++/102802] Selection of inherited operator contrary to `using` clause in C++ when using lambda type

[pinskia at gcc dot gnu.org]

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

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
     Ever confirmed|0                           |1
   Last reconfirmed|                            |2021-10-17
            Summary|Selection of inherited      |Selection of inherited
                   |operator contrary to        |operator contrary to
                   |`using` clause in C++       |`using` clause in C++ when
                   |                            |using lambda type

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Confirmed.

[Bug c++/102802] Selection of inherited operator contrary to `using` clause in C++ when using lambda type

[pinskia at gcc dot gnu.org]

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

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
ICC also rejects it.

[Bug c++/102802] Selection of inherited operator contrary to `using` clause in C++ when using lambda type

[rs2740 at gmail dot com]

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

TC <rs2740 at gmail dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |rs2740 at gmail dot com

--- Comment #3 from TC <rs2740 at gmail dot com> ---
No, this is valid. B's operator() is not visible, but its conversion to
function pointer is, and that introduces a surrogate call function during the
overload resolution for the function call expression (and it's selected because
it is the only viable candidate).

[Bug c++/102802] Selection of inherited operator contrary to `using` clause in C++ when using lambda type

[fchelnokov at gmail dot com]

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

Fedor Chelnokov <fchelnokov at gmail dot com> changed:

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

--- Comment #4 from Fedor Chelnokov <fchelnokov at gmail dot com> ---
Thanks for TC's explanation! This is an equivalent code to the question, but
without lambdas: gcc.godbolt.org/z/38T35Yfvs 

GCC is correct in processing the original code, closing the issue.