Inherited constructor is ignored during overload resolution

[Fedr]

In the following code

struct A {
    A() {}
    A(int) = delete;
};

struct B : A {
    using A::A;
    B(int&&) {}
};

int main() {
    B b(1);
}

GCC and MSVC print ambiguity error during constructor selection: neither B(int) nor B(int&&) is better than the other. But Clang prefers the constructor defined in B over the inherited one, which looks incorrect. Demo: https://gcc.godbolt.org/z/dnErEenE5

Related discussion: https://stackoverflow.com/q/71196145/7325599

[llvmbot]

@llvm/issue-subscribers-clang-frontend

[llvmbot]

@llvm/issue-subscribers-c-14

Author: None (Fedr)

In the following code ```c++ struct A { A() {} A(int) = delete; };

struct B : A {
using A::A;
B(int&&) {}
};

int main() {
B b(1);
}

GCC and MSVC print ambiguity error during constructor selection: neither `B(int)` nor `B(int&&)` is better than the other. But Clang prefers the constructor defined in B over the inherited one, which looks incorrect. Demo: https://gcc.godbolt.org/z/dnErEenE5

Related discussion: https://stackoverflow.com/q/71196145/7325599
</details>

[Endilll]

I'm pretty sure Clang is correct to pick constructors of inheriting class instead of considering this an ambiguity.

There was a number of Core issues on the topic of inherited constructors, which were resolved by P0136R1 "Rewording inheriting constructors (core issue 1941 et al)". According to wording changes there, inherited constructors are hidden by constructors of inheriting class ([namespace.udecl]/15):

When a using-declaration brings declarations from a base class into a derived class, member functions and member function templates in the derived class override and/or hide member functions and member function templates with the same name, parameter-type-list (8.3.5), cv-qualification, and ref-qualifier (if any) in a base class (rather than conflicting). Such hidden or overridden declarations are excluded from the set of declarations introduced by the using-declaration.

Note that while this exact wording has been superseded by P1787R6 "Declarations and where to find them", intent is still intact.

[Fedr]

According to SO, there is a tiebreaker that prefers direct over inherited constructors ([over.match.best.general]/2.7), but it applies only if they have the same parameter types (ignoring those whose default arguments are being used).

Please note that in the example above constructors take distinct parameters:

A(int);
B(int&&);

[Endilll]

Apologies, I missed that example focuses on regular constructors, and not on copy or move constructors.

Yes, both constructors are going to be found by name lookup. Conversion sequences from 1 to int and int&& are equally good (identity conversion for int, direct reference binding for int&&, which is also considered to be an identity conversion), and aforementioned tiebreaker doesn't apply.