C++ static constexpr class variables considered 'invalid' as template arguments

[mld2443]

https://godbolt.org/z/WY54brjqY

struct A {
    static constexpr int VALUE = 42;
    template <int ARG>
    constexpr int bar() const {
        return ARG;
    }

    constexpr int foo() const {
        return this->template bar<this->VALUE>();
    }
};

static_assert(A{}.foo()==42);

This code compiles with every version of GCC I tried, but I cannot get it to compile with clang at all.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Matt (mld2443)

https://godbolt.org/z/WY54brjqY ```cpp struct A { static constexpr int VALUE = 42; template <int ARG> constexpr int bar() const { return ARG; }

constexpr int foo() const {
    return this->template bar<this->VALUE>();
}

};

static_assert(A{}.foo()==42);

This code compiles with every version of GCC I tried, but I cannot get it to compile with clang at all.
</details>

[mld2443]

To clarify my comment, I'll add that it does compile with clang if you remove the explicit this references, which removes the need to use the keyword template.

For my purposes, however, I am developing something using the C++23 explicit (deducing) this, and I can't just remove them.

[mld2443]

https://godbolt.org/z/PWazf833e

struct A {
    static constexpr int VALUE = 42;
    template <int ARG>
    constexpr int bar() const {
        return ARG;
    }

    constexpr int foo() const {
        return bar<this->VALUE>();
    }
};

static_assert(A{}.foo()==42);

oops, looks like it has nothing to do with the keyword usage, here's an even simpler fail-case

[Rajveer100]

struct A {
    static constexpr int VALUE = 42;
    template <int ARG>
    constexpr int bar() const {
        return ARG;
    }

    constexpr int foo() const {
        return this->template bar<A::VALUE>();
    }
};

static_assert(A{}.foo()==42);

If you do it this way, it works.

[Rajveer100]

You don't need this->template as well.

[mld2443]

Thanks for the tip, Rajveer!

I was aware that you can reference the class value itself, however, this is a simplified version of something I'm working on which itself uses the "deducing this" feature of C++23. Without explaining everything, there were reasons using the type itself was possible, but extremely inconvenient and messy.

I brought it up because it is a case where clang is divergent from GCC.

[Rajveer100]

Indeed, this can be addressed, will hunt the codebase as usual :)

[efriedma-quic]

This simplifies to just:

template<int ARG> struct X {};
struct A {
  static constexpr int VALUE = 42;
  void f() {
    X<this->VALUE> x;
  }
};

I think this is a dup of #63139?

[mld2443]

@Rajveer100
I was certain that I had tried referencing the class directly, and I had.
edit: here's a godbolt link: https://godbolt.org/z/GzTExE7oM

#include <utility>

struct A {
    static constexpr int VALUE = 42;
};

struct B : public A {
    template <class SELF, int ARG>
    constexpr auto getImpl(this SELF&& self) {
        return ARG;
    }

    template <class SELF>
    constexpr auto getSum(this SELF&& self) {
        return std::forward<SELF>(self).template getImpl<SELF, std::forward<SELF>(self).VALUE>();
    }
};

int main() {
    constexpr auto b = B{};
    b.getSum();
}

Here is an example of a case where I cannot use the type directly. If you change std::forward<SELF>(self).VALUE to SELF::VALUE, neither clang nor gcc accept it.

I'll note that this necessitates the -std=c++23 build flag, and that I've only recently started playing around with the explicit this so there's a remote possibility I'm misusing it

[efriedma-quic]

std::remove_reference_t<SELF>::VALUE appears to work for your example.

[mld2443]

Oops, yeah I should have known better, given that’s half the point of `std::forward`On Oct 29, 2024, at 5:27 PM, Eli Friedman ***@***.***> wrote: std::remove_reference_t<SELF>::VALUE appears to work for your example. —Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you authored the thread.Message ID: ***@***.***>