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

    <tr>
        <th>Summary</th>
        <td>
            Assertion failure in C++17 mode in `TreeTransform<Derived>::TransformExceptionSpec`
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            new issue
      </td>
    </tr>

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

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

<pre>
    This is spun off from https://github.com/llvm/llvm-project/issues/68543

That issue is marked as fixed by 9f3e3405603177c46b873fa219624b759e6ef851, but actually that commit fixes a reduced test-case attached to that ticket, but not the original test-case.  FTR, with a non-assertion compiler, the original test-case and the reduced test-case both compile without crashing.  Also, the reduced test-case hits a slightly different assertion than the original full test-case.  Both test-cases fail in llvm17, so for comparison of the assertion failures, here are the two assertion-failures with llvm17:

Original (full) test-case assertion failure on llvm17 (equivalent failure still happens on trunk) https://godbolt.org/z/hcf49cTWr
```
/root/llvm-project/clang/lib/Sema/TreeTransform.h:6168:
 bool clang::TreeTransform<Derived>::TransformExceptionSpec(clang::SourceLocation, clang::FunctionProtoType::ExceptionSpecInfo&, llvm::SmallVectorImpl<clang::QualType>&, bool&)
  [with Derived = {anonymous}::SubstituteDeducedTypeTransform]:
  Assertion `ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated' failed.
```

Reduced test-case assertion failure on llvm17 (passes with trunk because fixed by 9f3e3405603177c46b873fa219624b759e6ef851) https://godbolt.org/z/dWa1KMzo1
```
/root/llvm-project/clang/lib/Sema/SemaTemplateInstantiate.cpp:2667:
 bool clang::Sema::SubstExceptionSpec(clang::SourceLocation, clang::FunctionProtoType::ExceptionSpecInfo&, llvm::SmallVectorImpl<clang::QualType>&, const clang::MultiLevelTemplateArgumentList&):
  Assertion `ESI.Type != EST_Uninstantiated' failed.
```

For reference, here is the reduced test-case that was fixed by the commit noted above:
```c++
  template <class> struct c {
    template <class> void bar() noexcept(0);
 };

  void (c<int>::*tmp)() = &c<int>::bar<int>;
```

The original text-case (shown below) is still failing with the following assertion failure (equivalent to the failure for it noted above from llvm17):

```
/root/llvm-project/clang/lib/Sema/TreeTransform.h:6187:
 bool clang::TreeTransform<Derived>::TransformExceptionSpec(clang::SourceLocation, clang::FunctionProtoType::ExceptionSpecInfo&, llvm::SmallVectorImpl<clang::QualType>&, bool&)
  [with Derived = {anonymous}::SubstituteDeducedTypeTransform]:
  Assertion `ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated' failed.

```

Test-case still failing in trunk https://godbolt.org/z/z4EWrvo35

```c++
  namespace a {
  inline namespace c {
  template <class e> constexpr bool f = __is_member_object_pointer(e);
  struct g {
    template <class h, class... i>
    static auto ae(h p1, i... j) -> decltype(p1(j...));
 };
  template <class h, class k = h, bool = f<k>> struct l;
  template <class h, class k> struct l<h, k, false> : g {};
  template <class h, class m, class... r>
  auto ag(h p1, m j, r... o) -> decltype(l<h>::ae(p1, j, o...));
  struct ai {
    template <class m, class n> auto operator()(m p1, n j) -> decltype(p1 > j);
  };
  template <class e, e...> struct q {};
  template <class e, e as> using at = __make_integer_seq<q, e, as>;
  template <long... au> using av = q<unsigned long, au...>;
  template <long as> using aw = at<unsigned long, as>;
  template <class... i> using ax = aw<sizeof...(i)>;
  int bg;
 struct t {
    template <class bo, class... p>
    static auto ae(bo p1, p... j) -> decltype(ag(p1, j...));
  };
  template <class bq, unsigned long... br, class bs, class bt, class bl>
  auto bu(bq, av<br...>, bs o, bt, bl) -> decltype(bq ::ae(o, br...));
  template <class, class, class... i> class bw {
    using bx = ax<i...>;
    int ca;

  public:
    template <class...> auto operator()() noexcept(noexcept(ca)) {
      ai s;
      return bu(t{}, bx{}, s, ca, bg);
    }
  };
  template <class bo, class... i> bw<int, bo, i...> bind(bo, i...);
  } // namespace c
  } // namespace a
  struct F {
    template <typename b,
              typename = decltype(static_cast<bool (b::*)()>(&b::operator()))>
    F(b *);
 };
  int cb;
  a::bw cc = bind(a::ai(), 0, cb);
  F d() { return &cc; }
```

As a side note, there is also a "Reduced slightly" test-case in that original GitHub issue.  But that test-case gets a user-error when compiled with a non-checking compiler (i.e., invalid C++). So I'm not including it here.  (The original test-case shown above compiles without an error using a non-assertion compiler.)

</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJzsWM1y47gRfhr40mUWCeqHOuggy1Yyld1KslYyRxdIgiLGIMABQMmep081SEqkfuypqT3sIS6XLAON7sbXX3cDYNaKneJ8SaYPZPp4xxpXarM8fDPCOn24S3X-vtyWwoKwYOtGgS4KKIyuoHSutiReEbohdLMTrmzSINMVoRsp9_2f-9robzxzhG6EtQ23hG5myXQSk_CRhKv2c1syB34azVTMvPIcmIVCvPEc0ndYFDGPJ-F0FsbRfJ5NZmkyjwtGo8WMTtL5dMFnvEimEaFrSBsHLHMNk_IdHGrOdFUJ57VZYGB43mQ8B8etu8-Y5cCcY1mJQ7pd4UT2yl2vTWkHruSgjdgJxeRpZQCw2f6BcgfhSmCgtLpn1nLjhFZouBaSGxS4rgCYyv3UpVOpdmWvwavXjYPMMFsKtQsAVtLqXvHl6lI43KuVYlc6-Q65KApuuHJwcs-VTI39Kho53t0DOnEcsFAwIUEowNBGczRvNRTaeEeZEVYjQ7zSkx1c1BgM_RpKbjgww72IO-iT2H0v1mLZWYhXQ6L8s3eU0AR9JXQxxPLcIujeU1zAvzdizyRi0M9bJ6SEktU1VxalnWnUK2o9Y7fOUy1doM2O0M0PQjdlVkwW2far6dybhd1v-y_dGK3dZQ5kkilUIUVK6OaZV4zQzdZwvjVM2UKbKihJvJpFs-S4dUi1ltCujFckXo3kSbx-5EbseU7ip36-m3t6y3iNgDzXPCM0Geh41o3J-G86YziPkRlMbhqV4fC_jHZ6-17zdnik7osqNKEzXOnTvdVaMSn_yzOnzZeqliReD7T-u2GyVfbULcSN-a-LbqdApg8--t2WgMSPQOYPTGn1XunGkvljZ6lJrROucfyx5T5qPoEyfTzBB6sjL8gsfHr-EqAsEBqh9qfn7ct_lFDWMeUEc2gUXZrBdUm-Z7JBMULnnkc8D65zwH_-cVlsPmZpjfNdDng2Qsoz1lj-K9Xwcx7nX1n0j99_6OhP4DH-2fKqlszxLydAg6yuSbyis9n8Nqe9ilNk_-rMzbSybmj490Y68Rvfc9kjsDK7puLK_Sas60j-y5T8Oa5ttAHDfZnP-LHYCnujRfhOdxi2WZTrmqXSmAks1Xt-qsG90YzQB_ztNuO6HUOLmrUkfgLrTJM5yDB9e8EbonstckiZITRByirNfbgITUKPWr_eJ__DcMfQrkWCkHgtlDvWQEJXrqpxeavUFxI6OxdDq6eRhw_A3Y7791sHIqGJLfVBQcqlPqAlPCj5toIBE2rXpXLJodBS6gMOXdaAcX_y5xB-nMQGO45JewTru_DirE3-6d0o-SBz_9-N_prd6AMqH0vAmKiiO_982jR-TJ6-mr2Op1dNnVUHxSpua5ZxYMNaIJQUig9mR5Xiok4ABqotu_ytNi0LCx-RlxdhXypepdy86BSp_VJroRyeuxM-qiB9Vdp9UpWg7DhobRAEIJAkR2nrmBMZsMZpYJzQpITa3zwEyn7DGnCPzuY8kw4ZRhOcT74FQeAL0o2S9rEf8Oo3W_ZM9f8VJF6_-kw7Flz50_rGi9Z-6hU_Ciath5vEqw6qn3ezGiFnBsi1gO0GgFWI1hoMSupruLV-9ZWE9VCu23X6CqD9jpj4LMQnR0GhWe-errlhTnetiNCk6lxVtwILOPJt7MNncPnmzNH7Uwi-_wzO7UJgvm021rcS1yVBxV75C9J-x82L5d9JvP7uxfHDr7ihWmq1wwiwZqB177Wikkb5J4IcUM7ralrPP1A39vDgdTF3VdkHjo3yr1f21io7kHhtxQ-uC0-CRPgIDDUJ5SDdnQY6nN1nvEj1iMH1x7mf6o4g9c3k95TvaHuNsZ8FPfVhHCGHtlJzInBqB9_d4Ls8z7-0Qae9RrYn8To1XTCxrFjwe281pPLaZtLvMEjGVtxc29XlSa_36qK09s4exqFpA552AX_Dc9oF8dowZ-ziXFg3qRTZoO1ep9btxD87iQ6-Zqzd7NhbwJJjR64BGO4ao1rQXZffiNjb6XsLB_PDuzGELTV-liX6Etf00B1ufc_oW5SfESr37D0OnlMS2uY_bNAfzrKzAry5nWdIJVwIKaHrIVz9z1EAIz8gX5t9LxmzWEvaLkiT9HjiP0bOEzohdNbNnUd30ckcbW9QD3QqbnRnz7R0MNBdWNMDZJl3tUO1G2eiN7eG0AcnHaO8gby_ncwfeq7gJSUj8cMp9lfPcCv_uidy7m8F3Ttge9tj0mo8a1HaPz70r4CE0sH9T6j2Cni81fxNuL83afsQGwA8NK57DT0u2XH_qthYbu65MdrAoeTHd858-AqalTx7xQTuH0ExVCLggWec2jMpclh3R0W6COBZwxdC55V_bhUqk03uD6XOX2MDwPXb64-o7Q2svRh15uzxyZQpaF3tGsiNN9rgeO6_y5dxvogX7I4vo3kYRbMwnId35XKaLGg-jcI4nqRhuCiiNEoW0SJZZNM0n0zCO7GkIY2jiCZhQufTMIiiyTTks0VOE8oKOiGTkFdMyAAvKXigvvNgL-fxjEZ3kqVcWv8UT6nihzYShFIyfbwzS395S5udJZNQCuvsSYsTTvLl6uJWKVQPcTSHSud-hMzCX7yzzcK7xsjlr7_8-33-LwAA___IbWrj">