inherited constructor causes `std::source_location::current()` to point at wrong line

[snarkmaster]

In this code (https://godbolt.org/z/dPhq718e5), Foo foo{} ends up with an incorrect source_location, while Foo foo{Potato{} is fine.

It looks like using Bar::Bar generates a default ctor for Foo, which becomes the evaluation site for source_location::current().

I'm not a standards lawyer, but I didn't find any suggestion that what we're seeing here is the specified behavior. And for default arguments, the the clear intent of the C++ standard is for default arguments to be evaluated at the call site. The current behavior violates at least the spirit of that rule. It also breaks the typical source_location-stamping technique.

#include <iostream>
#include <source_location>

struct Potato {};

struct Bar {
  std::source_location sl_;
  explicit Bar(Potato = {}, std::source_location sl = std::source_location::current())
      : sl_(sl) {}
};

struct Foo : Bar { // `foo.sl_` points here on GCC & clang
  using Bar::Bar;
}; // `foo.sl_` points here on MSVC

int main() {
  Foo foo{}; // Why isn't `sl_` pointing here?
  std::cout << "foo @ line " << foo.sl_.line() << std::endl;
  Foo foo2{Potato{}}; // But this is fine!
  std::cout << "foo2 @ line " << foo2.sl_.line() << std::endl;
  return 0;
}

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (snarkmaster)

In this code (https://godbolt.org/z/dPhq718e5), `Foo foo{}` ends up with an incorrect `source_location`, while `Foo foo{Potato{}` is fine.

It looks like using Bar::Bar generates a default ctor for Foo, which becomes the evaluation site for source_location::current().

I'm not a standards lawyer, but I didn't find any suggestion that what we're seeing here is the specified behavior. And for default arguments, the the clear intent of the C++ standard is for default arguments to be evaluated at the call site. The current behavior violates at least the spirit of that rule. It also breaks the typical source_location-stamping technique.

#include <iostream>
#include <source_location>

struct Potato {};

struct Bar {
  std::source_location sl_;
  explicit Bar(Potato = {}, std::source_location sl = std::source_location::current())
      : sl_(sl) {}
};

struct Foo : Bar { // `foo.sl_` points here on GCC & clang
  using Bar::Bar;
}; // `foo.sl_` points here on MSVC

int main() {
  Foo foo{}; // Why isn't `sl_` pointing here?
  std::cout << "foo @ line " << foo.sl_.line() << std::endl;
  Foo foo2{Potato{}}; // But this is fine!
  std::cout << "foo2 @ line " << foo2.sl_.line() << std::endl;
  return 0;
}

[cor3ntin]

I think clang and gcc are correct here.

struct Bar {
    int sl;
    Bar(int i = 0, int sl = __builtin_LINE()) : sl(sl) {}
};

struct Foo : Bar {
    using Bar::Bar;
};

int main() {
    Foo foo; // #1
    return foo.sl;
}

Per https://eel.is/c++draft/class#inhctor.init-1.sentence-1

When a constructor for type B is invoked to initialize an object of a different type D (that is, when the constructor was inherited ([namespace.udecl])), initialization proceeds as if a defaulted default constructor were used to initialize the D object and each base class subobject from which the constructor was inherited, except that the B subobject is initialized by the inherited constructor if the base class subobject were to be initialized as part of the D object ([class.base.init]).

In #1 we call the default constructor of Foo - which then calls the default constructor of Bar from its point of declaration - which in clang and gcc is the the opening bracket of the class.

If instead you give parameters, the constructor of Bar is explicitly called, then the point of call is where foo is initialized.