HazardyKnusperkeks marked 15 inline comments as done.
HazardyKnusperkeks added inline comments.
================
Comment at: clang/include/clang/Format/Format.h:3130-3136
+ /// \brief The position of the ``requires`` clause for class templates.
+ /// \version 14
+ RequiresClausePositionStyle RequiresClausePositionForClasses;
+
+ /// \brief The position of the ``requires`` clause for function templates.
+ /// \version 14
+ RequiresClausePositionStyle RequiresClausePositionForFunctions;
----------------
Quuxplusone wrote:
> HazardyKnusperkeks wrote:
> > Quuxplusone wrote:
> > > What about for variable templates? What about for alias templates? What
> > > about for deduction guides?
> > > It makes sense to me to have //one// option for this. It doesn't make
> > > sense to have 2, 3, or 4. Having 5 feels insane. So, I think you should
> > > just have one option that applies consistently to all `requires`-clauses
> > > everywhere in the code.
> > That makes sense, in my defense I thought about it and came to the
> > conclusion there would be no need for requires on variable templates, and
> > the others I did not think of.
> >
> > Why I have chosen to options is maybe someone wants
> > ```template <typename T>
> > requires ...
> > class ...```
> >
> > But also
> > ```template <typename T>
> > void foo(T) requires ... {
> > ```
> >
> > What's your opinion on that?
> Well, I see that there is a machine-readable distinction between "`requires`
> after `template`" versus "`requires` after function parameter list," i.e.
> between
> ```
> template<class T> requires X
> void f(T);
>
> template<class T>
> void f(T) requires X;
> ```
> The latter position is not (currently) valid for non-functions (e.g.
> `template<class T> int v requires X;` is a syntax error).
> However, as usual, I don't think that the user should //want// to format
> these differently.
> If you're using clang-format to format your code, then you should definitely
> want function-parameter-list-requires-clauses on their own line for sure, to
> avoid confusing strings of tokens such as
> ```
> void f() const noexcept requires foobar<T>; // bad
>
> void f() const noexcept // better
> requires foobar<T>;
> ```
> If you do that, then (in my proposed world) you would also automatically get
> ```
> template<class T>
> requires foobar<T> // automatically
> void f();
>
> template<class T> requires foobar<T> // can't get this
> void f();
>
> template<foobar T> // could also get this, via manual intervention
> void f();
> ```
> And personally I see nothing wrong with that state of affairs.
I still can imagine someone maybe wants it different, but for now I go with
your suggestion, only one option for all clauses.
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D113319/new/
https://reviews.llvm.org/D113319
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
