[Bug c++/94894] New: Premature instantiation of conversion function template during overload resolution

[Bug c++/94894] New: Premature instantiation of conversion function template during overload resolution

[ppalka at gcc dot gnu.org]

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

            Bug ID: 94894
           Summary: Premature instantiation of conversion function
                    template during overload resolution
           Product: gcc
           Version: 10.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: ppalka at gcc dot gnu.org
  Target Milestone: ---

The following testcase was reduced from a build failure with GCC 10 when
compiling LLVM.

When considering the overload candidate 'void f(int&)' for the overloaded call
'f(S{})', we try to build up a conversion sequence from 'S' to 'int&' that goes
through the conversion operator template with T=int.  In doing so we
instantiate the conversion operator template, which triggers an instantiation
of F<int>::k which triggers a hard error.

$ cat testcase.C
template <typename T, bool B = false>
struct F
{
  static_assert(B);
};

struct S
{
  template <typename T, int = F<T>::k> operator T();
};

void f(int&);
void f(S);

void foo()
{
  f(S{});
}

$ g++ testcase.C
testcase.C: In instantiation of ‘struct F<int, false>’:
testcase.C:9:37:   required by substitution of ‘template<class T, int
<anonymous> > S::operator T() [with T = int; int <anonymous> = <missing>]’
testcase.C:18:6:   required from here
testcase.C:4:17: error: static assertion failed
    4 |   static_assert(B);
      |                 ^

[Bug c++/94894] Premature instantiation of conversion function template during overload resolution

[redi at gcc dot gnu.org]

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

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
                 CC|                            |redi at gcc dot gnu.org
     Ever confirmed|0                           |1
   Last reconfirmed|                            |2022-07-05

--- Comment #1 from Jonathan Wakely <redi at gcc dot gnu.org> ---
>From PR libstdc++/106201:

struct foo
{
  template<typename T, typename = decltype(f(*(T*)nullptr))>
    foo(const T&) { }
};

struct bar { };

struct baz
{
  template<typename T> baz(const T&) { }
};

void f(foo&);
void f(baz);

int main()
{
  bar b;
  f(b);
}

G++ goes into infinite recursion, Clang, EDG and MSVC accept it.

That was reduced from one using concepts:

namespace effing
{
  template<typename T>
    concept effable = requires (T& t) { f(t); };

  template <class T>
    requires effable<T> || true
  void eff(T&&) { }
}

struct path {
  template<effing::effable T> path(const T&) { }
};

void f(path&);

struct iterator { };

int main()
{
  iterator i;
  effing::eff(i);
}

[Bug c++/94894] avoidable instantiation of conversion function template during overload resolution

[ppalka at gcc dot gnu.org]

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

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Assignee|unassigned at gcc dot gnu.org      |ppalka at gcc dot gnu.org
             Status|NEW                         |ASSIGNED

[Bug c++/94894] avoidable instantiation of conversion function template during overload resolution

[cvs-commit at gcc dot gnu.org]

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

--- Comment #2 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Patrick Palka <ppalka@gcc.gnu.org>:

https://gcc.gnu.org/g:68f37670eff0b872ce5dfd382c8d8f3206bdfc27

commit r13-1755-g68f37670eff0b872ce5dfd382c8d8f3206bdfc27
Author: Patrick Palka <ppalka@redhat.com>
Date:   Tue Jul 19 14:04:13 2022 -0400

    c++: shortcut bad reference binding [PR94894]

    In case of l/rvalue or cv-qual mismatch during reference binding, we
    try to give more helpful diagnostics by computing a bad conversion that
    allows the mismatch.  But in doing so, we may end up considering and
    instantiating a conversion function that could induce a hard error and
    in turn cause us to reject otherwise valid code.  We could just give up
    on producing a better diagnostic here, but ideally we'd preserve the
    better diagnostics for invalid code while avoiding unnecessary template
    instantiations for valid code.

    To that end, this patch adapts the bad conversion shortcutting mechanism
    from r12-3346-g47543e5f9d1fc5 to additionally handle this situation.
    The main observation from there is that during overload resolution, if we
    know we have a strictly viable candidate then we don't need to distinguish
    between an unviable and non-strictly viable candidate.  Thus we don't
    need to distinguish between an invalid and bad conversion either, which
    is what this patch exploits.  Of course, we don't know whether we have a
    strictly viable candidate until after the fact, so we still need to
    remember when we deferred distinguishing between an invalid and bad
    conversion.  This patch adds a special conversion kind ck_deferred_bad
    for this purpose.

            PR c++/94894
            PR c++/105766
            PR c++/106201

    gcc/cp/ChangeLog:

            * call.cc (enum conversion_kind): Add ck_deferred_bad enumerator.
            (has_next): Return false for it.
            (reference_binding): Return a ck_deferred_bad conversion instead
            of an actual bad conversion when LOOKUP_SHORTCUT_BAD_CONVS is set.
            Remove now obsolete early exit for the incomplete TO case.
            (implicit_conversion_1): Don't mask out LOOKUP_SHORTCUT_BAD_CONVS.
            (add_function_candidate): Set LOOKUP_SHORTCUT_BAD_CONVS iff
            shortcut_bad_convs.
            (missing_conversion_p): Also return true for a ck_deferred_bad
            conversion.
            * cp-tree.h (LOOKUP_SHORTCUT_BAD_CONVS): Define.

    gcc/testsuite/ChangeLog:

            * g++.dg/conversion/ref8.C: New test.
            * g++.dg/conversion/ref9.C: New test.

[Bug c++/94894] avoidable instantiation of conversion function template during overload resolution

[ppalka at gcc dot gnu.org]

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

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|---                         |13.0
         Resolution|---                         |FIXED
             Status|ASSIGNED                    |RESOLVED

--- Comment #3 from Patrick Palka <ppalka at gcc dot gnu.org> ---
Fixed in GCC 13