clang-format: misformatted method body when declared with trailing return type syntax followed by a requires clause

[elevendroids]

clang-format incorrectly formats methods declared with the trailing return type syntax followed by a requires clause.

Tested version:

clang-format version 15.0.0 (https://github.com/llvm/llvm-project.git e8716179eb0b57ad6d767bb17f349f32f387c7bd)

Platform:
Arch Linux, x86_64

---

Consider this example:

template<typename T>
struct Foo
{
    auto bar() -> int
    requires(is_integral_v<T>)
    {
        call_something();
        return 0;
    }
};

Reformatting it with clang-format (using the default configuration) leads to badly indented function body:

template <typename T> struct Foo {
  auto bar() -> int requires(is_integral_v<T>) {
                      call_something();
                      return 0;
                    }
};

When using the regular return type syntax... :

template<typename T>
struct Foo
{
    int bar()
    requires(is_integral_v<T>)
    {
        call_something();
        return 0;
    }
};

... the method is formatted as expected:

template <typename T> struct Foo {
  int bar()
    requires(is_integral_v<T>)
  {
    call_something();
    return 0;
  }
};

[llvmbot]

@llvm/issue-subscribers-clang-format

[mkurdej]

It looks as if the function braces where considered a part of the requires clause (compound requirements).
@HazardyKnusperkeks, WDYT?

[HazardyKnusperkeks]

Seems to be. I'll have a look at it.

[HazardyKnusperkeks]

It's parsed as a requires expression, the detection heuristic is flawed.

[HazardyKnusperkeks]

Review: https://reviews.llvm.org/D128496

[helmesjo]

@HazardyKnusperkeks

There appears to still be an edge case regarding this.
Tweaking the original example by adding & to the trailing return and using decltype(...) in the requires statement breaks it in the same way:

  template<typename T>
  struct Foo
  {
    auto bar(T in) -> int& requires (is_integral_v<decltype(in)>) {
                             call_something();
                             return 0;
                           }
  };

Changing one of the following fixes the formatting again:

• -> int& to -> int
• decltype(in) to T
• requires (...) to requires ...

You need parens if you negate ((!...)), but I guess a (highly arbitrary looking) workaround is to change from
requires (is_integral_v<decltype(in)>)
to
requires is_integral_v<decltype(in)> || true
works (tested).

$ clang++ --version
Homebrew clang version 17.0.6