Clang reports an undefined function that has been defined

[tbaederr]

Not sure how to title this properly.

The original reproducer is just:

#include <string>
constexpr auto z = std::string("", 0);

with libstdc++.

Using cvise, I get:

template <typename _CharT>
struct basic_string {
  constexpr void _M_construct();

  constexpr basic_string() {
    _M_construct();
  }

};


basic_string<char *> a;


template <typename _CharT>
constexpr void basic_string<_CharT>::_M_construct(){}

constexpr basic_string<char*> z{};

https://godbolt.org/z/7PzreExcf

Clang's output is:

<source>:18:16: error: constexpr variable 'z' must be initialized by a constant expression
   18 | constexpr auto z = basic_string<char *>();
      |                ^   ~~~~~~~~~~~~~~~~~~~~~~
<source>:6:5: note: undefined function '_M_construct' cannot be used in a constant expression
    6 |     _M_construct();
      |     ^
<source>:18:20: note: in call to 'basic_string()'
   18 | constexpr basic_string<char*> z{}
      |                    ^~~~~~~~~~~~~~~~~~~~~~
<source>:3:18: note: declared here
    3 |   constexpr void _M_construct();
      |                  ^

The problem vanishes if a is commented out, or if basic_string is not a template anymore.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Timm Baeder (tbaederr)

Not sure how to title this properly.

The original reproducer is just:

#include <string>
constexpr auto z = std::string("", 0);

with libstdc++.

Using cvise, I get:

template <typename _CharT>
struct basic_string {
  constexpr void _M_construct();

  constexpr basic_string() {
    _M_construct();
  }

};

void operators() {
  basic_string<char *>{};
}

template <typename _CharT>
constexpr void basic_string<_CharT>::_M_construct(){}

constexpr basic_string<char*> z{};

https://godbolt.org/z/7PzreExcf

Clang's output is:

<source>:18:16: error: constexpr variable 'z' must be initialized by a constant expression
   18 | constexpr auto z = basic_string<char *>();
      |                ^   ~~~~~~~~~~~~~~~~~~~~~~
<source>:6:5: note: undefined function '_M_construct' cannot be used in a constant expression
    6 |     _M_construct();
      |     ^
<source>:18:20: note: in call to 'basic_string()'
   18 | constexpr auto z = basic_string<char *>();
      |                    ^~~~~~~~~~~~~~~~~~~~~~
<source>:3:18: note: declared here
    3 |   constexpr void _M_construct();
      |                  ^

The problem vanishes if operators() is commented out, or if basic_string is not a template anymore.

[cor3ntin]

same problem with free functions

template <typename T>
constexpr void g(T);

constexpr int f() {
    g(0);
    return 0;
}

template <typename T> 
constexpr void g(T) {}

constexpr auto z = f();

[cor3ntin]

We probably want to call Sema::InstantiateFunctionDefinition in CheckConstexprFunction.
Unfortunately, CheckConstexprFunction does not have access to Sema. in general, nothing in ExprConstant has access to Sema.
To fix that we'd need to add a reference to Sema in EvalInfo, probably. A bit tedious. Anyone has a better idea? @erichkeane

[tbaederr]

CC @AaronBallman and @zygoloid, maybe they have an idea

[zygoloid]

Ultimately this is a language bug. There's no point of instantiation after the function template is defined and before the end of the TU -- we only get PoIs at uses and at end of TU.

What we should probably do is instantiate all used specializations at the point where the function template is defined (if it's constexpr). Constant evaluation shouldn't have side effects.

I'm pretty sure this is a duplicate of a (very) old PR.

[zygoloid]

See CWG2497.

[cor3ntin]

Ultimately this is a language bug. There's no point of instantiation after the function template is defined and before the end of the TU -- we only get PoIs at uses and at end of TU.

What we should probably do is instantiate all used specializations at the point where the function template is defined (if it's constexpr). Constant evaluation shouldn't have side effects.

Hum, I can see how trying to do instantiations in the middle of constant evaluation would not be great, thanks!

Do you think we should wait for core to resolve the issue, or should we try to eagerly instantiate at the end of the definition of constexpr functions?

[zygoloid]

I think we should eagerly start instantiating at the end of definitions. (Both function and variable templates are affected by this IIRC.)