Fix usage of right shift operator in fold expressions

[Rakete1111]

Summary

The right shift operator was not seen as a valid operator in a fold expression, which is PR32563.

[Rakete1111]

Ping?

[Rakete1111]

Updated test to use the -std=c++17 option + friendly ping

[Rakete1111]

Added the tests to the existing test file for fold operators that I didn't notice before :)

[Rakete1111]

Used the correct return type, even if it doesn't really matter to the compiler.

[Rakete1111]

Used the naming convention of LLVM + friendly ping. :)

[rsmith]

Thanks!

lib/Parse/ParseExpr.cpp

273

Do we ever need to pass in the Parser's GreaterThanIsOperator value here? (From a quick check, it looks like we never call isFoldOperator in any case where > might end a template argument list instead, but it's not completely obvious, because we do support parsing unparenthesized fold operators for better error handling in some cases.)

Seems like it would be safer to pass the correct value in here, even if it happens to not matter right now.

[Rakete1111]

Used Parser's GreaterThanIsOperator just to be sure. :)

[Rakete1111]

Added some more tests.
If this patch is still ok can you please commit it @rsmith ? Thanks!

[rsmith]

Committed as r317032, thanks!

include/clang/Parse/Parser.h

            Kind == tok::annot_module_end || Kind == tok::annot_module_include;
   }
 
+  /// \brief Checks if the \p Level is valid for use in a fold expression.
+  bool isFoldOperator(prec::Level Level) const;
+
+  /// \brief Checks if the \p Kind is a valid operator for fold expressions.
+  bool isFoldOperator(tok::TokenKind Kind) const;
+
   /// \brief Initialize all pragma handlers.
   void initializePragmaHandlers();
 

lib/Parse/ParseExpr.cpp

   return false;
 }
 
-static bool isFoldOperator(prec::Level Level) {
+bool Parser::isFoldOperator(prec::Level Level) const {
   return Level > prec::Unknown && Level != prec::Conditional;
 }
-static bool isFoldOperator(tok::TokenKind Kind) {
-  return isFoldOperator(getBinOpPrecedence(Kind, false, true));
+
+bool Parser::isFoldOperator(tok::TokenKind Kind) const {
+  return isFoldOperator(getBinOpPrecedence(Kind, GreaterThanIsOperator, true));
 }
 
 /// \brief Parse a binary expression that starts with \p LHS and has a

test/Parser/cxx1z-fold-expressions.cpp

     (int)(undeclared_junk + ...) + // expected-error {{undeclared}}
     (int)(a + ...); // expected-error {{does not contain any unexpanded}}
 }
+
+// fold-operator can be '>' or '>>'.
+template <int... N> constexpr bool greaterThan() { return (N > ...); }
+template <int... N> constexpr int rightShift() { return (N >> ...); }
+
+static_assert(greaterThan<2, 1>());
+static_assert(rightShift<10, 1>() == 5);
+
+template <auto V> constexpr auto Identity = V;
+
+// Support fold operators within templates.
+template <int... N> constexpr int nestedFoldOperator() {
+  return Identity<(Identity<0> >> ... >> N)> +
+    Identity<(N >> ... >> Identity<0>)>;
+}
+
+static_assert(nestedFoldOperator<3, 1>() == 1);