<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/61821>61821</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            Clang's algorithm for choosing overloads that don't need to instantiate a class template might have room for improvement
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            question,
            c++20,
            clang:frontend,
            concepts
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          cjdb
      </td>
    </tr>
</table>

<pre>
    GCC test (`concepts-conv3.C`) currently fails. I think Clang is in the clear for it failing per [[temp.inst]/9](http://wg21.link/temp.inst#9), but I wonder if we ought to mimic GCC here, since it will improve template ergonomics.

```cpp
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s

// Here, normal overload resolution would consider B::operator bool when
// evaluating A(b), leading to a hard error instantiating Error<int>, but we
// avoid considering it by noticing that converting bool (a scalar) to A (a
// class) would require a user-defined conversion, which is not allowed when
// we're already dealing with the user-defined conversion to A.

// This seems to be allowed by [temp.inst]/9: "If the function selected by
// overload resolution (12.4) can be determined without instantiating a class
// template definition, it is unspecified whether that instantiation actually
// takes place."

template <class T>
struct Error { static constexpr auto value = T::value; };

struct A { A(const A&); };

template <class T>
struct B { operator bool() requires Error<T>::value; };

template <class T>
concept C = requires (B<T> b) { A(b); };

static_assert(!C<int>);
```
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJyMVc2y2zYPfRp6g7FGgvwjLbzwT_x92XTRSdcZioItJhSpkJAdv32HtK593d60nblz5SGJgwPwHEKGoM-WaCOWO7E8zOTInfMb9a1tZo1rb5v_7ffAFBgEVmKVK2cVDRzmytlLme3FKhdYgxq9J8vmBiepTcjgM3Cn7XfYG2nPoANoC9wRKEPSw8l50JzOanuGgTyk_Dumfsi0DSyWB4HHOn2qjnkQ5VbgUeDxesYiM9p-F3h8HseyFlgL3EMzMnyGq7MtedAnuBK48dwxsINe91pBLKkjT_F00FZR5HLVxoDuB-8uBBHXSCYgf3bW9VqFTOQHkW-n_6v8_qeGYVpJ3OD3P34T5RYELlUs_KtSBcwDt6I8KIE7gTvMYX4KN8vy59xZc4P5hbw-3WJMeMlxR_z_RNQ630sD7kLeONmCp-DMyNpZuLrRtKCcDTrWvIutKrduIC_ZeWicM3DtyL7g0kWaUXJs_1Zg1UzdMyTbuMYOJHTSt0Dex9uygaVlfY_4FNdEudeWRfnpretXeskgL04_acUwzdDcwDrWKuXoJMf9C_mEmogKrCQEJY30UVjsYJvWXqCVkSHE7Xvpnn6M2hNIGAP5eUsnbamdoIN2NjK8dlp1UYnWMUhj3JXav7flSgLXEcp4ku0NWpJJolfNXRLwLzIkotkH9_el0wECUR_ikYYeqZsbfCT4pB78fErJTqNV6YoDGVKcol7QP5KDwKrAbJFsKW1M2RKT7xPjWIcb-S_3KaeOvod-eCAVq3lqo-bYw9GGgZQ-6XsPuSN_v853uM6CVDxKY145s_xOAQYjFWUC8X3PHjlFuU-M4EvUV9oL7EfFd-mBWO8gsGStksCYfg4e5MgOoqxj_CGGRh-kBVHuQKwPoty9TzdBbhNcdEHCir9W0Q4fxvwHiruE9-K_-Hhi_SbU8DBQiv03mv-UcnqPYZ9KfuALrHYTPERrPypsflnYvZ1fZQjkOfEt9u8sXj-Pvz1-s3ZTtnVZyxltilWVF1ivl9Ws29SLFte1ynFVVFUji2WlyryiRZ0XValymukN5ljmJdaICyyrrFFYqmqxWKvTYlEsSSxy6qU2mTGXPnP-PNMhjLRZFRUWMyMbMiGNLMQfI4W7OFHgXiA-HtrnSnyLRbk9eWeZbPvcmKZZXFgeZn4T082b8RzEIjc6cHgSYM2GNmmeCVwHkObsvOauT9NMdc6FaKU3R4a7H9pIbM1gidr4ADz9QW-uezqt13FOdfJC4J27A08jqSfLs9GbTZyF4TEMz5q7scmU6wUeI9XpMx-8-0aKBR5T44LAY-rdnwEAAP__AJB95Q">