Index: clang/docs/ClangFormatStyleOptions.rst
===================================================================
--- clang/docs/ClangFormatStyleOptions.rst
+++ clang/docs/ClangFormatStyleOptions.rst
@@ -2671,7 +2671,8 @@
 
 
 **IndentRequires** (``Boolean``) :versionbadge:`clang-format 13`
-  Indent the requires clause in a template
+  Indent the requires clause in a template, this only applies if the
+  ``requires`` is at the beginning of a line.
 
   .. code-block:: c++
 
@@ -3236,7 +3237,7 @@
 **QualifierAlignment** (``QualifierAlignmentStyle``) :versionbadge:`clang-format 14`
   Different ways to arrange specifiers and qualifiers (e.g. const/volatile).
 
-  .. warning::
+  .. warning:: 
 
    Setting ``QualifierAlignment``  to something other than `Leave`, COULD
    lead to incorrect code formatting due to incorrect decisions made due to
@@ -3395,6 +3396,182 @@
      /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
       * information */
 
+**RequiresClausePositionForClasses** (``RequiresClausePositionStyle``) :versionbadge:`clang-format 14`
+  The position of the ``requires`` clause for class templates.
+
+  Possible values:
+
+  * ``RCPS_OwnLine`` (in configuration: ``OwnLine``)
+    The clause always gets its own line.
+
+    .. code-block:: c++
+
+      template<typename T>
+      requires C<T>
+      struct Foo {...
+
+      template<typename T>
+      requires C<T>
+      void bar(T t) {...
+
+      template<typename T>
+      void baz(T t)
+      requires C<T> {...
+
+  * ``RCPS_ToPreceeding`` (in configuration: ``ToPreceeding``)
+    The clause tries to stick to the template declaration in case of class
+    templates or between template and function delcarations. In case of
+    after the function delcaration it tries to stick to this.
+
+    .. code-block:: c++
+
+      template<typename T> requires C<T>
+      struct Foo {...
+
+      template<typename T> requires C<T>
+      void bar(T t) {...
+
+      template<typename T>
+      void baz(T t) requires C<T> {...
+
+  * ``RCPS_ToFollowing`` (in configuration: ``ToFollowing``)
+    The clause tries to stick to the class respectively function
+    declaration.
+
+    .. code-block:: c++
+
+      template<typename T>
+      requires C<T> struct Foo {...
+
+      template<typename T>
+      requires C<T> void bar(T t) {...
+
+      template<typename T>
+      void baz(T t) requires C<T> {...
+
+  * ``RCPS_SingleLine`` (in configuration: ``SingleLine``)
+    The clause tries to get everything in the same line, if it doesn't fit
+    normal line breaking rules decide to which part it sticks.
+
+    .. code-block:: c++
+
+      template<typename T> requires C<T> struct Foo {...
+
+      template<typename T> requires C<T> void bar(T t) {...
+
+      template<typename T> void bar(T t) requires C<T> {...
+
+  * ``RCPS_TwoLines`` (in configuration: ``TwoLines``)
+    The clause always gets its own line, and the content of the clause go
+    into the next line with some indentation.
+
+    .. code-block:: c++
+
+      template<typename T>
+      requires
+              C<T>
+      struct Foo {...
+
+      template<typename T>
+      requires
+              C<T>
+      void bar(T t) {...
+
+      template<typename T>
+      void bar(T t)
+      requires
+              C<T> {...
+
+
+
+**RequiresClausePositionForFunctions** (``RequiresClausePositionStyle``) :versionbadge:`clang-format 14`
+  The position of the ``requires`` clause for function templates.
+
+  Possible values:
+
+  * ``RCPS_OwnLine`` (in configuration: ``OwnLine``)
+    The clause always gets its own line.
+
+    .. code-block:: c++
+
+      template<typename T>
+      requires C<T>
+      struct Foo {...
+
+      template<typename T>
+      requires C<T>
+      void bar(T t) {...
+
+      template<typename T>
+      void baz(T t)
+      requires C<T> {...
+
+  * ``RCPS_ToPreceeding`` (in configuration: ``ToPreceeding``)
+    The clause tries to stick to the template declaration in case of class
+    templates or between template and function delcarations. In case of
+    after the function delcaration it tries to stick to this.
+
+    .. code-block:: c++
+
+      template<typename T> requires C<T>
+      struct Foo {...
+
+      template<typename T> requires C<T>
+      void bar(T t) {...
+
+      template<typename T>
+      void baz(T t) requires C<T> {...
+
+  * ``RCPS_ToFollowing`` (in configuration: ``ToFollowing``)
+    The clause tries to stick to the class respectively function
+    declaration.
+
+    .. code-block:: c++
+
+      template<typename T>
+      requires C<T> struct Foo {...
+
+      template<typename T>
+      requires C<T> void bar(T t) {...
+
+      template<typename T>
+      void baz(T t) requires C<T> {...
+
+  * ``RCPS_SingleLine`` (in configuration: ``SingleLine``)
+    The clause tries to get everything in the same line, if it doesn't fit
+    normal line breaking rules decide to which part it sticks.
+
+    .. code-block:: c++
+
+      template<typename T> requires C<T> struct Foo {...
+
+      template<typename T> requires C<T> void bar(T t) {...
+
+      template<typename T> void bar(T t) requires C<T> {...
+
+  * ``RCPS_TwoLines`` (in configuration: ``TwoLines``)
+    The clause always gets its own line, and the content of the clause go
+    into the next line with some indentation.
+
+    .. code-block:: c++
+
+      template<typename T>
+      requires
+              C<T>
+      struct Foo {...
+
+      template<typename T>
+      requires
+              C<T>
+      void bar(T t) {...
+
+      template<typename T>
+      void bar(T t)
+      requires
+              C<T> {...
+
+
+
 **ShortNamespaceLines** (``Unsigned``) :versionbadge:`clang-format 14`
   The maximal number of unwrapped lines that a short namespace spans.
   Defaults to 1.
Index: clang/docs/ReleaseNotes.rst
===================================================================
--- clang/docs/ReleaseNotes.rst
+++ clang/docs/ReleaseNotes.rst
@@ -267,6 +267,10 @@
 
 - Improved C++20 Modules and Coroutines support.
 
+- Reworked and improved handling of concepts and requires. Added the
+  ``RequiresClausePositionForClasses`` and
+  ``RequiresClausePositionForFunctions`` options as part of that.
+
 libclang
 --------
 
Index: clang/include/clang/Format/Format.h
===================================================================
--- clang/include/clang/Format/Format.h
+++ clang/include/clang/Format/Format.h
@@ -2501,7 +2501,8 @@
   /// \version 12
   IndentExternBlockStyle IndentExternBlock;
 
-  /// Indent the requires clause in a template
+  /// Indent the requires clause in a template, this only applies if the
+  /// ``requires`` is at the beginning of a line.
   /// \code
   ///    true:
   ///    template <typename It>
@@ -3049,6 +3050,91 @@
   bool ReflowComments;
   // clang-format on
 
+  /// \brief The possible positions for the requires clause. The
+  /// ``IndentRequires`` option is only used if the ``requires`` is put on the
+  /// start of a line.
+  enum RequiresClausePositionStyle {
+    /// The clause always gets its own line.
+    /// \code
+    ///   template<typename T>
+    ///   requires C<T>
+    ///   struct Foo {...
+    ///
+    ///   template<typename T>
+    ///   requires C<T>
+    ///   void bar(T t) {...
+    ///
+    ///   template<typename T>
+    ///   void baz(T t)
+    ///   requires C<T> {...
+    /// \endcode
+    RCPS_OwnLine,
+    /// The clause tries to stick to the template declaration in case of class
+    /// templates or between template and function delcarations. In case of
+    /// after the function delcaration it tries to stick to this.
+    /// \code
+    ///   template<typename T> requires C<T>
+    ///   struct Foo {...
+    ///
+    ///   template<typename T> requires C<T>
+    ///   void bar(T t) {...
+    ///
+    ///   template<typename T>
+    ///   void baz(T t) requires C<T> {...
+    /// \endcode
+    RCPS_ToPreceeding,
+    /// The clause tries to stick to the class respectively function
+    /// declaration.
+    /// \code
+    ///   template<typename T>
+    ///   requires C<T> struct Foo {...
+    ///
+    ///   template<typename T>
+    ///   requires C<T> void bar(T t) {...
+    ///
+    ///   template<typename T>
+    ///   void baz(T t) requires C<T> {...
+    /// \endcode
+    RCPS_ToFollowing,
+    /// The clause tries to get everything in the same line, if it doesn't fit
+    /// normal line breaking rules decide to which part it sticks.
+    /// \code
+    ///   template<typename T> requires C<T> struct Foo {...
+    ///
+    ///   template<typename T> requires C<T> void bar(T t) {...
+    ///
+    ///   template<typename T> void bar(T t) requires C<T> {...
+    /// \endcode
+    RCPS_SingleLine,
+    /// The clause always gets its own line, and the content of the clause go
+    /// into the next line with some indentation.
+    /// \code
+    ///   template<typename T>
+    ///   requires
+    ///           C<T>
+    ///   struct Foo {...
+    ///
+    ///   template<typename T>
+    ///   requires
+    ///           C<T>
+    ///   void bar(T t) {...
+    ///
+    ///   template<typename T>
+    ///   void bar(T t)
+    ///   requires
+    ///           C<T> {...
+    /// \endcode
+    RCPS_TwoLines,
+  };
+
+  /// \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;
+
   /// The maximal number of unwrapped lines that a short namespace spans.
   /// Defaults to 1.
   ///
@@ -3790,6 +3876,10 @@
            QualifierOrder == R.QualifierOrder &&
            RawStringFormats == R.RawStringFormats &&
            ReferenceAlignment == R.ReferenceAlignment &&
+           RequiresClausePositionForClasses ==
+               R.RequiresClausePositionForClasses &&
+           RequiresClausePositionForFunctions ==
+               R.RequiresClausePositionForFunctions &&
            ShortNamespaceLines == R.ShortNamespaceLines &&
            SortIncludes == R.SortIncludes &&
            SortJavaStaticImport == R.SortJavaStaticImport &&
Index: clang/lib/Format/ContinuationIndenter.cpp
===================================================================
--- clang/lib/Format/ContinuationIndenter.cpp
+++ clang/lib/Format/ContinuationIndenter.cpp
@@ -800,6 +800,18 @@
 
   State.Column = getNewLineColumn(State);
 
+  if (Current.is(TT_RequiresClauseForClasses)) {
+    State.Stack.back().Indent = State.Column;
+    if (Style.RequiresClausePositionForClasses == FormatStyle::RCPS_TwoLines)
+      State.Stack.back().Indent += Current.ColumnWidth;
+  }
+
+  if (Current.is(TT_RequiresClauseForFunctions)) {
+    State.Stack.back().Indent = State.Column;
+    if (Style.RequiresClausePositionForFunctions == FormatStyle::RCPS_TwoLines)
+      State.Stack.back().Indent += Current.ColumnWidth;
+  }
+
   // Add Penalty proportional to amount of whitespace away from FirstColumn
   // This tends to penalize several lines that are far-right indented,
   // and prefers a line-break prior to such a block, e.g:
@@ -1086,6 +1098,10 @@
   }
   if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0)
     return State.Stack.back().VariablePos;
+  if (Current.isOneOf(TT_RequiresClauseForClasses,
+                      TT_RequiresClauseForFunctions) &&
+      Style.IndentRequires)
+    return State.Stack.back().Indent + Style.IndentWidth;
   if ((PreviousNonComment &&
        (PreviousNonComment->ClosesTemplateDeclaration ||
         PreviousNonComment->isOneOf(
@@ -1343,11 +1359,13 @@
   const FormatToken *Previous = Current.getPreviousNonComment();
 
   // Don't add extra indentation for the first fake parenthesis after
-  // 'return', assignments or opening <({[. The indentation for these cases
-  // is special cased.
+  // 'return', assignments, opening <({[, or requires clauses. The indentation
+  // for these cases is special cased.
   bool SkipFirstExtraIndent =
       (Previous && (Previous->opensScope() ||
-                    Previous->isOneOf(tok::semi, tok::kw_return) ||
+                    Previous->isOneOf(tok::semi, tok::kw_return,
+                                      TT_RequiresClauseForClasses,
+                                      TT_RequiresClauseForFunctions) ||
                     (Previous->getPrecedence() == prec::Assignment &&
                      Style.AlignOperands != FormatStyle::OAS_DontAlign) ||
                     Previous->is(TT_ObjCMethodExpr)));
@@ -1383,7 +1401,8 @@
 
     if (Previous &&
         (Previous->getPrecedence() == prec::Assignment ||
-         Previous->is(tok::kw_return) ||
+         Previous->isOneOf(tok::kw_return, TT_RequiresClauseForClasses,
+                           TT_RequiresClauseForFunctions) ||
          (PrecedenceLevel == prec::Conditional && Previous->is(tok::question) &&
           Previous->is(TT_ConditionalExpr))) &&
         !Newline) {
Index: clang/lib/Format/Format.cpp
===================================================================
--- clang/lib/Format/Format.cpp
+++ clang/lib/Format/Format.cpp
@@ -450,6 +450,18 @@
   }
 };
 
+template <>
+struct ScalarEnumerationTraits<FormatStyle::RequiresClausePositionStyle> {
+  static void enumeration(IO &IO,
+                          FormatStyle::RequiresClausePositionStyle &Value) {
+    IO.enumCase(Value, "OwnLine", FormatStyle::RCPS_OwnLine);
+    IO.enumCase(Value, "ToPreceeding", FormatStyle::RCPS_ToPreceeding);
+    IO.enumCase(Value, "ToFollowing", FormatStyle::RCPS_ToFollowing);
+    IO.enumCase(Value, "SingleLine", FormatStyle::RCPS_SingleLine);
+    IO.enumCase(Value, "TwoLines", FormatStyle::RCPS_TwoLines);
+  }
+};
+
 template <>
 struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensStyle> {
   static void enumeration(IO &IO, FormatStyle::SpaceBeforeParensStyle &Value) {
@@ -769,6 +781,10 @@
     IO.mapOptional("RawStringFormats", Style.RawStringFormats);
     IO.mapOptional("ReferenceAlignment", Style.ReferenceAlignment);
     IO.mapOptional("ReflowComments", Style.ReflowComments);
+    IO.mapOptional("RequiresClausePositionForClasses",
+                   Style.RequiresClausePositionForClasses);
+    IO.mapOptional("RequiresClausePositionForFunctions",
+                   Style.RequiresClausePositionForFunctions);
     IO.mapOptional("ShortNamespaceLines", Style.ShortNamespaceLines);
     IO.mapOptional("SortIncludes", Style.SortIncludes);
     IO.mapOptional("SortJavaStaticImport", Style.SortJavaStaticImport);
@@ -1193,6 +1209,9 @@
   LLVMStyle.ObjCSpaceBeforeProtocolList = true;
   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
   LLVMStyle.ReferenceAlignment = FormatStyle::RAS_Pointer;
+  // This is open for discussions! When will LLVM adapt C++20?
+  LLVMStyle.RequiresClausePositionForClasses = FormatStyle::RCPS_OwnLine;
+  LLVMStyle.RequiresClausePositionForFunctions = FormatStyle::RCPS_OwnLine;
   LLVMStyle.ShortNamespaceLines = 1;
   LLVMStyle.SpacesBeforeTrailingComments = 1;
   LLVMStyle.Standard = FormatStyle::LS_Latest;
Index: clang/lib/Format/FormatToken.h
===================================================================
--- clang/lib/Format/FormatToken.h
+++ clang/lib/Format/FormatToken.h
@@ -35,12 +35,13 @@
   TYPE(BinaryOperator)                                                         \
   TYPE(BitFieldColon)                                                          \
   TYPE(BlockComment)                                                           \
+  TYPE(BracedListLBrace)                                                       \
   TYPE(CastRParen)                                                             \
+  TYPE(CompoundRequirementLBrace)                                              \
   TYPE(ConditionalExpr)                                                        \
   TYPE(ConflictAlternative)                                                    \
   TYPE(ConflictEnd)                                                            \
   TYPE(ConflictStart)                                                          \
-  TYPE(ConstraintJunctions)                                                    \
   TYPE(CtorInitializerColon)                                                   \
   TYPE(CtorInitializerComma)                                                   \
   TYPE(DesignatedInitializerLSquare)                                           \
@@ -96,6 +97,8 @@
   TYPE(PureVirtualSpecifier)                                                   \
   TYPE(RangeBasedForLoopColon)                                                 \
   TYPE(RegexLiteral)                                                           \
+  TYPE(RequiresClauseForClasses)                                               \
+  TYPE(RequiresClauseForFunctions)                                             \
   TYPE(SelectorName)                                                           \
   TYPE(StartOfName)                                                            \
   TYPE(StatementAttributeLikeMacro)                                            \
Index: clang/lib/Format/TokenAnnotator.cpp
===================================================================
--- clang/lib/Format/TokenAnnotator.cpp
+++ clang/lib/Format/TokenAnnotator.cpp
@@ -251,7 +251,9 @@
       Contexts.back().IsExpression = false;
     } else if (Left->Previous &&
                (Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_while,
-                                        tok::l_paren, tok::comma) ||
+                                        tok::l_paren, tok::comma,
+                                        TT_RequiresClauseForClasses,
+                                        TT_RequiresClauseForFunctions) ||
                 Left->Previous->isIf() ||
                 Left->Previous->is(TT_BinaryOperator))) {
       // static_assert, if and while usually contain expressions.
@@ -1162,6 +1164,10 @@
         parseCSharpGenericTypeConstraint();
       }
       break;
+    case tok::arrow:
+      if (Tok->Previous && Tok->Previous->is(tok::kw_noexcept))
+        Tok->setType(TT_TrailingReturnArrow);
+      break;
     default:
       break;
     }
@@ -1425,8 +1431,10 @@
             TT_ImplicitStringLiteral, TT_InlineASMBrace, TT_FatArrow,
             TT_LambdaArrow, TT_NamespaceMacro, TT_OverloadedOperator,
             TT_RegexLiteral, TT_TemplateString, TT_ObjCStringLiteral,
-            TT_UntouchableMacroFunc, TT_ConstraintJunctions,
-            TT_StatementAttributeLikeMacro))
+            TT_UntouchableMacroFunc, TT_StatementAttributeLikeMacro,
+            TT_RequiresClauseForClasses, TT_RequiresClauseForFunctions,
+            TT_BinaryOperator, TT_CompoundRequirementLBrace,
+            TT_BracedListLBrace))
       CurrentToken->setType(TT_Unknown);
     CurrentToken->Role.reset();
     CurrentToken->MatchingParen = nullptr;
@@ -2136,7 +2144,7 @@
 public:
   ExpressionParser(const FormatStyle &Style, const AdditionalKeywords &Keywords,
                    AnnotatedLine &Line)
-      : Style(Style), Keywords(Keywords), Current(Line.First) {}
+      : Style(Style), Keywords(Keywords), Line(Line), Current(Line.First) {}
 
   /// Parse expressions with the given operator precedence.
   void parse(int Precedence = 0) {
@@ -2192,7 +2200,11 @@
       }
 
       // Consume scopes: (), [], <> and {}
-      if (Current->opensScope()) {
+      // In addition to that we handle require clauses as scope, so that the
+      // constraints in that are correctly indented.
+      if (Current->opensScope() ||
+          Current->isOneOf(TT_RequiresClauseForClasses,
+                           TT_RequiresClauseForFunctions)) {
         // In fragment of a JavaScript template string can look like '}..${' and
         // thus close a scope and open a new one at the same time.
         while (Current && (!Current->closesScope() || Current->opensScope())) {
@@ -2214,12 +2226,25 @@
     }
 
     if (LatestOperator && (Current || Precedence > 0)) {
-      // LatestOperator->LastOperator = true;
+      // The requires clauses do not neccessarily end in a semicolon or a brace,
+      // but just go over to struct/class or a function declaration, we need to
+      // intervene so that the fake right paren is inserted correctly.
+      auto End = (!Current && Start->Previous &&
+                  Start->Previous->isOneOf(TT_RequiresClauseForClasses,
+                                           TT_RequiresClauseForFunctions))
+                     ? [this](){
+                         auto Ret = Line.Last;
+                         while (Ret->is(tok::comment) && Ret->Previous)
+                           Ret = Ret->Previous;
+                         return Ret;
+                       }()
+                     : nullptr;
+
       if (Precedence == PrecedenceArrowAndPeriod) {
         // Call expressions don't have a binary operator precedence.
-        addFakeParenthesis(Start, prec::Unknown);
+        addFakeParenthesis(Start, prec::Unknown, End);
       } else {
-        addFakeParenthesis(Start, prec::Level(Precedence));
+        addFakeParenthesis(Start, prec::Level(Precedence), End);
       }
     }
   }
@@ -2270,17 +2295,17 @@
     return -1;
   }
 
-  void addFakeParenthesis(FormatToken *Start, prec::Level Precedence) {
+  void addFakeParenthesis(FormatToken *Start, prec::Level Precedence,
+                          FormatToken *End = nullptr) {
     Start->FakeLParens.push_back(Precedence);
     if (Precedence > prec::Unknown)
       Start->StartsBinaryExpression = true;
-    if (Current) {
-      FormatToken *Previous = Current->Previous;
-      while (Previous->is(tok::comment) && Previous->Previous)
-        Previous = Previous->Previous;
-      ++Previous->FakeRParens;
+    if (!End && Current)
+      End = Current->getPreviousNonComment();
+    if (End) {
+      ++End->FakeRParens;
       if (Precedence > prec::Unknown)
-        Previous->EndsBinaryExpression = true;
+        End->EndsBinaryExpression = true;
     }
   }
 
@@ -2326,6 +2351,7 @@
 
   const FormatStyle &Style;
   const AdditionalKeywords &Keywords;
+  const AnnotatedLine &Line;
   FormatToken *Current;
 };
 
@@ -2959,9 +2985,6 @@
   if (Left.isOneOf(tok::kw_co_await, tok::kw_co_yield, tok::kw_co_return) &&
       Right.isNot(tok::semi))
     return true;
-  // requires clause Concept1<T> && Concept2<T>
-  if (Left.is(TT_ConstraintJunctions) && Right.is(tok::identifier))
-    return true;
 
   if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
     return (Right.is(TT_CastRParen) ||
@@ -3832,6 +3855,28 @@
     // concept ...
     if (Right.is(tok::kw_concept))
       return Style.BreakBeforeConceptDeclarations;
+
+    if (Right.is(TT_RequiresClauseForClasses)) {
+      switch (Style.RequiresClausePositionForClasses) {
+      case FormatStyle::RCPS_OwnLine:
+      case FormatStyle::RCPS_ToFollowing:
+      case FormatStyle::RCPS_TwoLines:
+        return true;
+      default:
+        break;
+      }
+    }
+
+    if (Right.is(TT_RequiresClauseForFunctions)) {
+      switch (Style.RequiresClausePositionForFunctions) {
+      case FormatStyle::RCPS_OwnLine:
+      case FormatStyle::RCPS_ToFollowing:
+      case FormatStyle::RCPS_TwoLines:
+        return true;
+      default:
+        break;
+      }
+    }
     return (Style.AlwaysBreakTemplateDeclarations == FormatStyle::BTDS_Yes);
   }
   if (Style.PackConstructorInitializers == FormatStyle::PCIS_Never) {
@@ -4043,6 +4088,13 @@
       return true;
   }
 
+  if (Left.is(TT_RequiresClauseForClasses))
+    return Style.RequiresClausePositionForClasses == FormatStyle::RCPS_TwoLines;
+
+  if (Left.is(TT_RequiresClauseForFunctions))
+    return Style.RequiresClausePositionForFunctions ==
+           FormatStyle::RCPS_TwoLines;
+
   return false;
 }
 
Index: clang/lib/Format/UnwrappedLineParser.h
===================================================================
--- clang/lib/Format/UnwrappedLineParser.h
+++ clang/lib/Format/UnwrappedLineParser.h
@@ -83,10 +83,12 @@
 private:
   void reset();
   void parseFile();
-  void parseLevel(bool HasOpeningBrace);
+  void parseLevel(bool HasOpeningBrace, bool CanContainBracedList,
+                  TokenType NextLBracesType = TT_Unknown);
   void parseBlock(bool MustBeDeclaration = false, unsigned AddLevels = 1u,
-                  bool MunchSemi = true,
-                  bool UnindentWhitesmithsBraces = false);
+                  bool MunchSemi = true, bool UnindentWhitesmithsBraces = false,
+                  bool CanContainBracedList = true,
+                  TokenType NextLBracesType = TT_Unknown);
   void parseChildBlock();
   void parsePPDirective();
   void parsePPDefine();
@@ -96,11 +98,12 @@
   void parsePPEndIf();
   void parsePPUnknown();
   void readTokenWithJavaScriptASI();
-  void parseStructuralElement(bool IsTopLevel = false);
+  void parseStructuralElement(bool IsTopLevel = false,
+                              TokenType NextLBracesType = TT_Unknown);
   bool tryToParseBracedList();
   bool parseBracedList(bool ContinueOnSemicolons = false, bool IsEnum = false,
                        tok::TokenKind ClosingBraceKind = tok::r_brace);
-  void parseParens();
+  void parseParens(TokenType AmpAmpTokenType = TT_Unknown);
   void parseSquare(bool LambdaIntroducer = false);
   void parseIfThenElse();
   void parseTryCatch();
@@ -116,9 +119,9 @@
   bool parseEnum();
   bool parseStructLike();
   void parseConcept();
-  void parseRequires();
-  void parseRequiresExpression(unsigned int OriginalLevel);
-  void parseConstraintExpression(unsigned int OriginalLevel);
+  void parseRequiresClause();
+  void parseRequiresExpression();
+  void parseConstraintExpression();
   void parseJavaEnumBody();
   // Parses a record (aka class) as a top level element. If ParseAsExpr is true,
   // parses the record as a child block, i.e. if the class declaration is an
Index: clang/lib/Format/UnwrappedLineParser.cpp
===================================================================
--- clang/lib/Format/UnwrappedLineParser.cpp
+++ clang/lib/Format/UnwrappedLineParser.cpp
@@ -373,7 +373,7 @@
   if (Style.Language == FormatStyle::LK_TextProto)
     parseBracedList();
   else
-    parseLevel(/*HasOpeningBrace=*/false);
+    parseLevel(/*HasOpeningBrace=*/false, /*CanContainBracedList=*/true);
   // Make sure to format the remaining tokens.
   //
   // LK_TextProto is special since its top-level is parsed as the body of a
@@ -432,7 +432,17 @@
   } while (!eof());
 }
 
-void UnwrappedLineParser::parseLevel(bool HasOpeningBrace) {
+/// \brief Parses a level, that is ???.
+/// \param HasOpeningBrace If that level is started by an opening brace.
+/// \param CanContainBracedList If the content can contain (at any level) a
+/// braced list.
+/// \param NextLBracesType The type for left brace found in this level.
+void UnwrappedLineParser::parseLevel(bool HasOpeningBrace,
+                                     bool CanContainBracedList,
+                                     TokenType NextLBracesType) {
+  auto NextLevelLBracesType = NextLBracesType == TT_CompoundRequirementLBrace
+                                  ? TT_BracedListLBrace
+                                  : TT_Unknown;
   bool SwitchLabelEncountered = false;
   do {
     tok::TokenKind kind = FormatTok->Tok.getKind();
@@ -448,11 +458,15 @@
       addUnwrappedLine();
       break;
     case tok::l_brace:
-      // FIXME: Add parameter whether this can happen - if this happens, we must
-      // be in a non-declaration context.
-      if (!FormatTok->is(TT_MacroBlockBegin) && tryToParseBracedList())
+      if (NextLBracesType != TT_Unknown)
+        FormatTok->setType(NextLBracesType);
+      if (CanContainBracedList && !FormatTok->is(TT_MacroBlockBegin) &&
+          tryToParseBracedList())
         continue;
-      parseBlock();
+      parseBlock(/*MustBeDeclaration=*/false, /*AddLevels=*/1u,
+                 /*MunchSemi=*/true, /*UnindentWhitesmithBraces=*/false,
+                 CanContainBracedList,
+                 /*NextLBracesType=*/NextLBracesType);
       addUnwrappedLine();
       break;
     case tok::r_brace:
@@ -498,7 +512,8 @@
       }
       LLVM_FALLTHROUGH;
     default:
-      parseStructuralElement(!HasOpeningBrace);
+      parseStructuralElement(/*IsTopLevel=*/!HasOpeningBrace,
+                             /*NextLBracesType=*/NextLevelLBracesType);
       break;
     }
   } while (!eof());
@@ -572,27 +587,47 @@
           bool NextIsObjCMethod = NextTok->isOneOf(tok::plus, tok::minus) &&
                                   NextTok->OriginalColumn == 0;
 
+          // Try to detect a braced list. Note that regardless how we mark inner
+          // braces here, we will overwrite the BlockKind later if we parse a
+          // braced list (where all blocks inside are by default braced lists),
+          // or when we explicitly detect blocks (for example while parsing
+          // lambdas).
+
+          // If we already marked the opening brace as braced list, the closing
+          // must also be part of it.
+          ProbablyBracedList = LBraceStack.back()->is(TT_BracedListLBrace);
+
+          ProbablyBracedList = ProbablyBracedList ||
+                               (Style.Language == FormatStyle::LK_JavaScript &&
+                                NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in,
+                                                 Keywords.kw_as));
+          ProbablyBracedList =
+              ProbablyBracedList ||
+              (Style.isCpp() && NextTok->is(tok::l_paren));
+
           // If there is a comma, semicolon or right paren after the closing
-          // brace, we assume this is a braced initializer list.  Note that
-          // regardless how we mark inner braces here, we will overwrite the
-          // BlockKind later if we parse a braced list (where all blocks
-          // inside are by default braced lists), or when we explicitly detect
-          // blocks (for example while parsing lambdas).
+          // brace, we assume this is a braced initializer list.
           // FIXME: Some of these do not apply to JS, e.g. "} {" can never be a
           // braced list in JS.
           ProbablyBracedList =
-              (Style.Language == FormatStyle::LK_JavaScript &&
-               NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in,
-                                Keywords.kw_as)) ||
-              (Style.isCpp() && NextTok->is(tok::l_paren)) ||
+              ProbablyBracedList ||
               NextTok->isOneOf(tok::comma, tok::period, tok::colon,
                                tok::r_paren, tok::r_square, tok::l_brace,
-                               tok::ellipsis) ||
+                               tok::ellipsis);
+
+          ProbablyBracedList =
+              ProbablyBracedList ||
               (NextTok->is(tok::identifier) &&
-               !PrevTok->isOneOf(tok::semi, tok::r_brace, tok::l_brace)) ||
-              (NextTok->is(tok::semi) &&
-               (!ExpectClassBody || LBraceStack.size() != 1)) ||
+               !PrevTok->isOneOf(tok::semi, tok::r_brace, tok::l_brace));
+
+          ProbablyBracedList = ProbablyBracedList ||
+                               (NextTok->is(tok::semi) &&
+                                (!ExpectClassBody || LBraceStack.size() != 1));
+
+          ProbablyBracedList =
+              ProbablyBracedList ||
               (NextTok->isBinaryOperator() && !NextIsObjCMethod);
+
           if (!Style.isCSharp() && NextTok->is(tok::l_square)) {
             // We can have an array subscript after a braced init
             // list, but C++11 attributes are expected after blocks.
@@ -659,7 +694,9 @@
 
 void UnwrappedLineParser::parseBlock(bool MustBeDeclaration, unsigned AddLevels,
                                      bool MunchSemi,
-                                     bool UnindentWhitesmithsBraces) {
+                                     bool UnindentWhitesmithsBraces,
+                                     bool CanContainBracedList,
+                                     TokenType NextLBracesType) {
   assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
          "'{' or macro block token expected");
   const bool MacroBlock = FormatTok->is(TT_MacroBlockBegin);
@@ -696,7 +733,7 @@
                                           MustBeDeclaration);
   if (AddLevels > 0u && Style.BreakBeforeBraces != FormatStyle::BS_Whitesmiths)
     Line->Level += AddLevels;
-  parseLevel(/*HasOpeningBrace=*/true);
+  parseLevel(/*HasOpeningBrace=*/true, CanContainBracedList, NextLBracesType);
 
   if (eof())
     return;
@@ -716,8 +753,12 @@
   if (MacroBlock && FormatTok->is(tok::l_paren))
     parseParens();
 
+  if (FormatTok->is(tok::kw_noexcept))
+    // A noexcept in a requires expression.
+    nextToken();
+
   if (FormatTok->is(tok::arrow)) {
-    // Following the } we can find a trailing return type arrow
+    // Following the } or noexcept we can find a trailing return type arrow
     // as part of an implicit conversion constraint.
     nextToken();
     parseStructuralElement();
@@ -797,7 +838,7 @@
     ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
                                             /*MustBeDeclaration=*/false);
     Line->Level += SkipIndent ? 0 : 1;
-    parseLevel(/*HasOpeningBrace=*/true);
+    parseLevel(/*HasOpeningBrace=*/true, /*CanContainBracedList=*/true);
     flushComments(isOnNewLine(*FormatTok));
     Line->Level -= SkipIndent ? 0 : 1;
   }
@@ -1189,7 +1230,8 @@
     return addUnwrappedLine();
 }
 
-void UnwrappedLineParser::parseStructuralElement(bool IsTopLevel) {
+void UnwrappedLineParser::parseStructuralElement(bool IsTopLevel,
+                                                 TokenType NextLBracesType) {
   if (Style.Language == FormatStyle::LK_TableGen &&
       FormatTok->is(tok::pp_include)) {
     nextToken();
@@ -1439,7 +1481,7 @@
       parseConcept();
       break;
     case tok::kw_requires:
-      parseRequires();
+      parseRequiresClause();
       break;
     case tok::kw_enum:
       // Ignore if this is part of "template <enum ...".
@@ -1520,6 +1562,8 @@
         parseChildBlock();
       break;
     case tok::l_brace:
+      if (NextLBracesType != TT_Unknown)
+        FormatTok->setType(NextLBracesType);
       if (!tryToParsePropertyAccessor() && !tryToParseBracedList()) {
         // A block outside of parentheses must be the last part of a
         // structural element.
@@ -2063,7 +2107,10 @@
   return false;
 }
 
-void UnwrappedLineParser::parseParens() {
+/// \brief Parses a parens pair.
+/// \param AmpAmpTokenType If different than TT_Unknown sets this type for all
+/// double ampersands. This only counts for the current parens scope.
+void UnwrappedLineParser::parseParens(TokenType AmpAmpTokenType) {
   assert(FormatTok->Tok.is(tok::l_paren) && "'(' expected.");
   nextToken();
   do {
@@ -2113,6 +2160,13 @@
       else
         nextToken();
       break;
+    case tok::kw_requires:
+      parseRequiresExpression();
+      break;
+    case tok::ampamp:
+      if (AmpAmpTokenType != TT_Unknown)
+        FormatTok->setType(AmpAmpTokenType);
+      LLVM_FALLTHROUGH;
     default:
       nextToken();
       break;
@@ -2522,6 +2576,11 @@
   addUnwrappedLine();
 }
 
+/// \brief Parses a concept definition.
+/// \pre The current token has to be the concept keyword.
+///
+/// Returns if it either has finished parsing the concept, or it detects, that
+/// the concept definition is incorrect.
 void UnwrappedLineParser::parseConcept() {
   assert(FormatTok->Tok.is(tok::kw_concept) && "'concept' expected");
   nextToken();
@@ -2531,107 +2590,168 @@
   if (!FormatTok->Tok.is(tok::equal))
     return;
   nextToken();
-  if (FormatTok->Tok.is(tok::kw_requires)) {
+  parseConstraintExpression();
+  if (FormatTok->Tok.is(tok::semi))
     nextToken();
-    parseRequiresExpression(Line->Level);
-  } else {
-    parseConstraintExpression(Line->Level);
+  addUnwrappedLine();
+}
+
+/// \brief Parses a requires clause.
+/// \pre The current token needs to be the requires keyword.
+/// \sa parseRequiresExpression
+///
+/// Returns if it either has finished parsing the clause, or it detects, that
+/// the clause is incorrect.
+void UnwrappedLineParser::parseRequiresClause() {
+  assert(FormatTok->Tok.is(tok::kw_requires) && "'requires' expected");
+  assert(FormatTok->getType() == TT_Unknown);
+
+  auto RequiresToken = FormatTok;
+
+  nextToken();
+  parseConstraintExpression();
+
+  auto setTypeAndMaybeAddLine =
+      [this,
+       RequiresToken](TokenType Type,
+                      FormatStyle::RequiresClausePositionStyle PositionStyle) {
+        RequiresToken->setType(Type);
+
+        switch (PositionStyle) {
+        case FormatStyle::RCPS_OwnLine:
+        case FormatStyle::RCPS_ToPreceeding:
+        case FormatStyle::RCPS_TwoLines:
+          addUnwrappedLine();
+          break;
+        default:
+          break;
+        }
+      };
+
+  switch (FormatTok->Tok.getKind()) {
+  case tok::kw_class:
+  case tok::kw_struct:
+  case tok::kw_union:
+    setTypeAndMaybeAddLine(TT_RequiresClauseForClasses,
+                           Style.RequiresClausePositionForClasses);
+    break;
+
+  case tok::semi:
+    if (RequiresToken->Previous)
+      // We are a trailing requires clause for a function.
+      RequiresToken->setType(TT_RequiresClauseForFunctions);
+    // Else: We are a requires clause within a requires expression.
+    // The Semi is eaten by the caller, he also adds the unwrapped line.
+    break;
+
+  default:
+    setTypeAndMaybeAddLine(TT_RequiresClauseForFunctions,
+                           Style.RequiresClausePositionForFunctions);
+    break;
   }
 }
 
-void UnwrappedLineParser::parseRequiresExpression(unsigned int OriginalLevel) {
-  // requires (R range)
-  if (FormatTok->Tok.is(tok::l_paren)) {
+/// \brief Parses a requires expression.
+/// \pre The current token needs to be the requires keyword.
+/// \sa parseRequiresClause
+///
+/// Returns if it either has finished parsing the expression, or it detects,
+/// that the expression is incorrect.
+void UnwrappedLineParser::parseRequiresExpression() {
+  assert(FormatTok->Tok.is(tok::kw_requires) && "'requires' expected");
+  assert(FormatTok->getType() == TT_Unknown);
+  nextToken();
+
+  if (FormatTok->is(tok::l_paren))
     parseParens();
-    if (Style.IndentRequires && OriginalLevel != Line->Level) {
-      addUnwrappedLine();
-      --Line->Level;
-    }
-  }
 
-  if (FormatTok->Tok.is(tok::l_brace)) {
-    if (Style.BraceWrapping.AfterFunction)
-      addUnwrappedLine();
-    FormatTok->setType(TT_FunctionLBrace);
-    parseBlock();
-    addUnwrappedLine();
-  } else {
-    parseConstraintExpression(OriginalLevel);
-  }
+  if (FormatTok->is(tok::l_brace))
+    parseBlock(/*MustBeDeclaration=*/false, /*AddLevels=*/1u,
+               /*MunchSemi=*/false, /*UnindentWhitesmithsBraces=*/false,
+               /*CanContainBracedList=*/false,
+               /*NextLBracesType=*/TT_CompoundRequirementLBrace);
 }
 
-void UnwrappedLineParser::parseConstraintExpression(
-    unsigned int OriginalLevel) {
-  // requires Id<T> && Id<T> || Id<T>
-  while (
-      FormatTok->isOneOf(tok::identifier, tok::kw_requires, tok::coloncolon)) {
-    nextToken();
-    while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::less,
-                              tok::greater, tok::comma, tok::ellipsis)) {
-      if (FormatTok->Tok.is(tok::less)) {
+/// \brief Parses a constraint expression.
+///
+/// This is either the definition of a concept, or the body of a requires
+/// clause. It returns, when the parsing is complete, or the expression is
+/// incorrect.
+void UnwrappedLineParser::parseConstraintExpression() {
+  do {
+    switch (FormatTok->Tok.getKind()) {
+    case tok::kw_requires:
+      parseRequiresExpression();
+      break;
+
+    case tok::l_paren:
+      parseParens(/*AmpAmpTokenType=*/TT_BinaryOperator);
+      break;
+
+    case tok::l_square:
+      if (!tryToParseLambda())
+        return;
+      break;
+
+    case tok::identifier:
+      // Read identifier with optional template declaration.
+      nextToken();
+      if (FormatTok->Tok.is(tok::less))
         parseBracedList(/*ContinueOnSemicolons=*/false, /*IsEnum=*/false,
                         /*ClosingBraceKind=*/tok::greater);
-        continue;
-      }
+      break;
+
+    case tok::semi:
+    case tok::kw_class:
+    case tok::kw_struct:
+    case tok::kw_union:
+      return;
+
+    case tok::l_brace:
+      // Potential function body.
+      return;
+
+    case tok::ampamp:
+      FormatTok->setType(TT_BinaryOperator);
       nextToken();
-    }
-    if (FormatTok->Tok.is(tok::kw_requires)) {
-      parseRequiresExpression(OriginalLevel);
-    }
-    if (FormatTok->Tok.is(tok::less)) {
-      parseBracedList(/*ContinueOnSemicolons=*/false, /*IsEnum=*/false,
-                      /*ClosingBraceKind=*/tok::greater);
-    }
+      break;
 
-    if (FormatTok->Tok.is(tok::l_paren)) {
-      parseParens();
-    }
-    if (FormatTok->Tok.is(tok::l_brace)) {
-      if (Style.BraceWrapping.AfterFunction)
-        addUnwrappedLine();
-      FormatTok->setType(TT_FunctionLBrace);
-      parseBlock();
-    }
-    if (FormatTok->Tok.is(tok::semi)) {
-      // Eat any trailing semi.
+    default:
+      // Just eat them.
       nextToken();
-      addUnwrappedLine();
-    }
-    if (FormatTok->Tok.is(tok::colon)) {
-      return;
-    }
-    if (!FormatTok->Tok.isOneOf(tok::ampamp, tok::pipepipe)) {
-      if (FormatTok->Previous &&
-          !FormatTok->Previous->isOneOf(tok::identifier, tok::kw_requires,
-                                        tok::coloncolon)) {
-        addUnwrappedLine();
-      }
-      if (Style.IndentRequires && OriginalLevel != Line->Level) {
-        --Line->Level;
-      }
       break;
-    } else {
-      FormatTok->setType(TT_ConstraintJunctions);
     }
-
-    nextToken();
-  }
+  } while (!eof());
 }
 
-void UnwrappedLineParser::parseRequires() {
+/*void UnwrappedLineParser::parseRequires() {
   assert(FormatTok->Tok.is(tok::kw_requires) && "'requires' expected");
 
   unsigned OriginalLevel = Line->Level;
-  if (FormatTok->Previous && FormatTok->Previous->is(tok::greater)) {
-    addUnwrappedLine();
-    if (Style.IndentRequires) {
-      Line->Level++;
+  bool IsClause = false;
+  if (FormatTok->Previous) {
+    if (FormatTok->Previous->is(tok::greater)) {
+      FormatTok->setType(TT_RequiresClause);
+      IsClause = true;
+      addUnwrappedLine();
+      if (Style.IndentRequires) {
+        Line->Level++;
+      }
+    } else if (FormatTok->Previous->is(tok::r_paren)) {
+      FormatTok->setType(TT_RequiresClause);
+      IsClause = true;
     }
   }
+  if (!IsClause)
+    FormatTok->setType(TT_RequiresExpression);
+
   nextToken();
 
-  parseRequiresExpression(OriginalLevel);
-}
+  if (IsClause)
+    parseRequiresClause(OriginalLevel);
+  else
+    parseRequiresExpression(OriginalLevel);
+}*/
 
 bool UnwrappedLineParser::parseEnum() {
   // Won't be 'enum' for NS_ENUMs.
@@ -2830,7 +2950,7 @@
   }
 
   // Parse the class body after the enum's ";" if any.
-  parseLevel(/*HasOpeningBrace=*/true);
+  parseLevel(/*HasOpeningBrace=*/true, /*CanContainBracedList=*/true);
   nextToken();
   --Line->Level;
   addUnwrappedLine();
Index: clang/unittests/Format/FormatTest.cpp
===================================================================
--- clang/unittests/Format/FormatTest.cpp
+++ clang/unittests/Format/FormatTest.cpp
@@ -19143,6 +19143,30 @@
   // For backward compatibility:
   CHECK_PARSE("SpacesInAngles: false", SpacesInAngles, FormatStyle::SIAS_Never);
   CHECK_PARSE("SpacesInAngles: true", SpacesInAngles, FormatStyle::SIAS_Always);
+
+  CHECK_PARSE("RequiresClausePositionForClasses: ToPreceeding",
+              RequiresClausePositionForClasses, FormatStyle::RCPS_ToPreceeding);
+  CHECK_PARSE("RequiresClausePositionForClasses: ToFollowing",
+              RequiresClausePositionForClasses, FormatStyle::RCPS_ToFollowing);
+  CHECK_PARSE("RequiresClausePositionForClasses: SingleLine",
+              RequiresClausePositionForClasses, FormatStyle::RCPS_SingleLine);
+  CHECK_PARSE("RequiresClausePositionForClasses: TwoLines",
+              RequiresClausePositionForClasses, FormatStyle::RCPS_TwoLines);
+  CHECK_PARSE("RequiresClausePositionForClasses: OwnLine",
+              RequiresClausePositionForClasses, FormatStyle::RCPS_OwnLine);
+
+  CHECK_PARSE("RequiresClausePositionForFunctions: ToPreceeding",
+              RequiresClausePositionForFunctions,
+              FormatStyle::RCPS_ToPreceeding);
+  CHECK_PARSE("RequiresClausePositionForFunctions: ToFollowing",
+              RequiresClausePositionForFunctions,
+              FormatStyle::RCPS_ToFollowing);
+  CHECK_PARSE("RequiresClausePositionForFunctions: SingleLine",
+              RequiresClausePositionForFunctions, FormatStyle::RCPS_SingleLine);
+  CHECK_PARSE("RequiresClausePositionForFunctions: TwoLines",
+              RequiresClausePositionForFunctions, FormatStyle::RCPS_TwoLines);
+  CHECK_PARSE("RequiresClausePositionForFunctions: OwnLine",
+              RequiresClausePositionForFunctions, FormatStyle::RCPS_OwnLine);
 }
 
 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
@@ -22257,43 +22281,234 @@
                Style);
 }
 
-TEST_F(FormatTest, ConceptsAndRequires) {
-  FormatStyle Style = getLLVMStyle();
-  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
+TEST_F(FormatTest, Concepts) {
+  verifyFormat("template <typename T>\n"
+               "concept True = true;");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = ((false || foo()) && C2<T>) || "
+               "(std::trait<T>::value && Baz) ||\n "
+               "           sizeof(T) >= 6;");
+
+  verifyFormat("template <typename T>\n"
+               "concept DelayedCheck = true && requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept DelayedCheck = false || requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept DelayedCheck = !!false || requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat(
+      "template <typename T>\n"
+      "concept DelayedCheck = static_cast<bool>(0) || requires(T t) {\n"
+      "  t.bar();\n"
+      "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept DelayedCheck = bool(0) || requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept DelayedCheck = (bool)(0) || requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept DelayedCheck = (bool)0 || requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept Size = sizeof(T) >= 5 && requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat(
+      "template <typename T>\n"
+      "concept Size = 2 < 5 && 2 <= 5 && 8 >= 5 && 8 > 5 && requires(T t) {\n"
+      "  t.bar();\n"
+      "} && sizeof(T) <= 8 && !(4 < 3);");
+
+  verifyFormat("template <typename T>\n"
+               "concept TrueOrNot = IsAlwaysTrue || IsNeverTrue;");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = foo();");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = foo(T());");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = foo(T{});");
+
+  verifyFormat("template <typename T>\n"
+               "concept Size = V<sizeof(T)>::Value > 5;");
+
+  verifyFormat("template <typename T>\n"
+               "concept True = S<T>::Value;");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = []() { return true; }() && requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = [] { return true; }() && requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = [] -> bool { return true; }() && requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat(
+      "template <typename T>\n"
+      "concept C = decltype([]() { return std::true_type{}; }())::value &&\n"
+      "            requires(T t) {\n"
+      "  t.bar();\n"
+      "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = decltype([]() { return std::true_type{}; "
+               "}())::value && requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;",
+               getLLVMStyleWithColumns(120));
+
+  verifyFormat("template <typename T>\n"
+               "concept C = decltype([]() -> std::true_type { return {}; "
+               "}())::value &&\n"
+               "            requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = true;\n"
+               "Foo Bar;");
 
   verifyFormat("template <typename T>\n"
                "concept Hashable = requires(T a) {\n"
                "  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
-               "};",
-               Style);
+               "};");
+
   verifyFormat("template <typename T>\n"
                "concept EqualityComparable = requires(T a, T b) {\n"
-               "  { a == b } -> bool;\n"
-               "};",
-               Style);
+               "  { a == b } -> std::same_as<bool>;\n"
+               "};");
+
   verifyFormat("template <typename T>\n"
                "concept EqualityComparable = requires(T a, T b) {\n"
-               "  { a == b } -> bool;\n"
-               "  { a != b } -> bool;\n"
-               "};",
-               Style);
+               "  { a == b } -> std::same_as<bool>;\n"
+               "  { a != b } -> std::same_as<bool>;\n"
+               "};");
+
   verifyFormat("template <typename T>\n"
-               "concept EqualityComparable = requires(T a, T b) {\n"
-               "  { a == b } -> bool;\n"
-               "  { a != b } -> bool;\n"
-               "};",
-               Style);
+               "concept WeakEqualityComparable = requires(T a, T b) {\n"
+               "  { a == b };\n"
+               "  { a != b };\n"
+               "};");
 
-  verifyFormat("template <typename It>\n"
-               "requires Iterator<It>\n"
-               "void sort(It begin, It end) {\n"
-               "  //....\n"
-               "}",
-               Style);
+  verifyFormat("template <typename T>\n"
+               "concept HasSizeT = requires {\n"
+               "  typename T::size_t;\n"
+               "};");
 
   verifyFormat("template <typename T>\n"
-               "concept Large = sizeof(T) > 10;",
-               Style);
+               "concept Semiregular = DefaultConstructible<T> && "
+               "CopyConstructible<T> &&\n"
+               "                      CopyAssignable<T> && requires(T a, "
+               "std::size_t n) {\n"
+               "  requires Same<T *, decltype(&a)>;\n"
+               "  { a.~T() } noexcept;\n"
+               "  requires Same<T *, decltype(new T)>;\n"
+               "  requires Same<T *, decltype(new T[n])>;\n"
+               "  { delete new T; };\n"
+               "  { delete new T[n]; };\n"
+               "};");
+
+  verifyFormat("template <typename T>\n"
+               "concept Semiregular = requires(T a, std::size_t n) {\n"
+               "  requires Same<T *, decltype(&a)>;\n"
+               "  { a.~T() } noexcept;\n"
+               "  requires Same<T *, decltype(new T)>;\n"
+               "  requires Same<T *, decltype(new T[n])>;\n"
+               "  { delete new T; };\n"
+               "  { delete new T[n]; };\n"
+               "  { new T } -> std::same_as<T *>;\n"
+               "} && DefaultConstructible<T> && CopyConstructible<T> && "
+               "CopyAssignable<T>;");
+
+  verifyFormat("template <typename T>\n"
+               "concept Semiregular = DefaultConstructible<T> requires(T a, "
+               "std::size_t n) {\n"
+               "  requires Same<T *, decltype(&a)>;\n"
+               "  { a.~T() } noexcept;\n"
+               "  requires Same<T *, decltype(new T)>;\n"
+               "  requires Same<T *, decltype(new T[n])>;\n"
+               "  { delete new T; };\n"
+               "  { delete new T[n]; };\n"
+               "} && CopyConstructible<T> && CopyAssignable<T>;");
+
+  verifyFormat("template <typename T>\n"
+               "concept Two = requires(T t) {\n"
+               "  { t.foo() } -> std::same_as<Bar>;\n"
+               "} && requires(T &&t) {\n"
+               "  { t.foo() } -> std::same_as<Bar &&>;\n"
+               "}");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = requires(T x) {\n"
+               "  { *x } -> std::convertible_to<typename T::inner>;\n"
+               "  { x + 1 } noexcept -> std::same_as<int>;\n"
+               "  { x * 1 } -> std::convertible_to<T>;\n"
+               "};");
+
+  verifyFormat("template <typename T, typename U = T>\n"
+               "concept Swappable = requires(T &&t, U &&u) {\n"
+               "  swap(std::forward<T>(t), std::forward<U>(u));\n"
+               "  swap(std::forward<U>(u), std::forward<T>(t));\n"
+               "};");
+
+  verifyFormat("template <typename T, typename U>\n"
+               "concept Common = requires(T &&t, U &&u) {\n"
+               "  typename CommonType<T, U>;\n"
+               "  { CommonType<T, U>(std::forward<T>(t)) };\n"
+               "};");
+
+  verifyFormat("template <typename T, typename U>\n"
+               "concept Common = requires(T &&t, U &&u) {\n"
+               "  typename CommonType<T, U>;\n"
+               "  { CommonType<T, U>{std::forward<T>(t)} };\n"
+               "};");
+
+  verifyFormat("template <typename T>\n"
+               "concept C = requires(T t) {\n"
+               "  requires Bar<T> && Foo<T>;\n"
+               "  requires((trait<T> && Baz) || (T2<T> && Foo<T>));\n"
+               "};");
+
+  verifyFormat("template <typename T>\n"
+               "concept HasFoo = requires(T t) {\n"
+               "  { t.foo() };\n"
+               "  t.foo();\n"
+               "};\n"
+               "template <typename T>\n"
+               "concept HasBar = requires(T t) {\n"
+               "  { t.bar() };\n"
+               "  t.bar();\n"
+               "};");
+
+  verifyFormat("template <typename T>\n"
+               "concept Large = sizeof(T) > 10;");
 
   verifyFormat("template <typename T, typename U>\n"
                "concept FooableWith = requires(T t, U u) {\n"
@@ -22301,199 +22516,881 @@
                "  { t.foo(u) } -> typename T::foo_type;\n"
                "  t++;\n"
                "};\n"
-               "void doFoo(FooableWith<int> auto t) {\n"
-               "  t.foo(3);\n"
-               "}",
-               Style);
-  verifyFormat("template <typename T>\n"
-               "concept Context = sizeof(T) == 1;",
-               Style);
-  verifyFormat("template <typename T>\n"
-               "concept Context = is_specialization_of_v<context, T>;",
-               Style);
+               "void doFoo(FooableWith<int> auto t) { t.foo(3); }");
+
   verifyFormat("template <typename T>\n"
-               "concept Node = std::is_object_v<T>;",
-               Style);
+               "concept Context = is_specialization_of_v<context, T>;");
+
   verifyFormat("template <typename T>\n"
-               "concept Tree = true;",
-               Style);
+               "concept Node = std::is_object_v<T>;");
 
-  verifyFormat("template <typename T> int g(T i) requires Concept1<I> {\n"
-               "  //...\n"
-               "}",
+  auto Style = getLLVMStyle();
+  Style.BreakBeforeConceptDeclarations = false;
+
+  verifyFormat("template <typename T> concept C = requires(T t) {\n"
+               "  requires Bar<T> && Foo<T>;\n"
+               "  requires((trait<T> && Baz) || (T2<T> && Foo<T>));\n"
+               "};",
                Style);
 
-  verifyFormat(
-      "template <typename T> int g(T i) requires Concept1<I> && Concept2<I> {\n"
-      "  //...\n"
-      "}",
-      Style);
+  verifyFormat("template <typename T> concept HasFoo = requires(T t) {\n"
+               "  { t.foo() };\n"
+               "  t.foo();\n"
+               "};\n"
+               "template <typename T> concept HasBar = requires(T t) {\n"
+               "  { t.bar() };\n"
+               "  t.bar();\n"
+               "};",
+               Style);
 
-  verifyFormat(
-      "template <typename T> int g(T i) requires Concept1<I> || Concept2<I> {\n"
-      "  //...\n"
-      "}",
-      Style);
+  verifyFormat("template <typename T> concept True = true;", Style);
 
   verifyFormat("template <typename T>\n"
-               "veryveryvery_long_return_type g(T i) requires Concept1<I> || "
-               "Concept2<I> {\n"
-               "  //...\n"
-               "}",
+               "concept C = decltype([]() -> std::true_type { return {}; "
+               "}())::value &&\n"
+               "            requires(T t) {\n"
+               "  t.bar();\n"
+               "} && sizeof(T) <= 8;",
                Style);
 
   verifyFormat("template <typename T>\n"
-               "veryveryvery_long_return_type g(T i) requires Concept1<I> && "
-               "Concept2<I> {\n"
-               "  //...\n"
-               "}",
+               "concept Semiregular = DefaultConstructible<T> && "
+               "CopyConstructible<T> &&\n"
+               "                      CopyAssignable<T> && requires(T a, "
+               "std::size_t n) {\n"
+               "  requires Same<T *, decltype(&a)>;\n"
+               "  { a.~T() } noexcept;\n"
+               "  requires Same<T *, decltype(new T)>;\n"
+               "  requires Same<T *, decltype(new T[n])>;\n"
+               "  { delete new T; };\n"
+               "  { delete new T[n]; };\n"
+               "};",
                Style);
 
-  verifyFormat(
-      "template <typename T>\n"
-      "veryveryvery_long_return_type g(T i) requires Concept1 && Concept2 {\n"
-      "  //...\n"
-      "}",
-      Style);
+  // The following tests are invalid C++, we just want to make sure we don't
+  // assert.
+  verifyFormat("template <typename T>\n"
+               "concept C = requires C2<T>;");
 
-  verifyFormat(
-      "template <typename T>\n"
-      "veryveryvery_long_return_type g(T i) requires Concept1 || Concept2 {\n"
-      "  //...\n"
-      "}",
-      Style);
+  verifyFormat("template <typename T>\n"
+               "concept C = 5 + 4;");
 
-  verifyFormat("template <typename It>\n"
-               "requires Foo<It>() && Bar<It> {\n"
-               "  //....\n"
-               "}",
-               Style);
+  verifyFormat("template <typename T>\n"
+               "concept C =\n"
+               "class X;");
 
-  verifyFormat("template <typename It>\n"
-               "requires Foo<Bar<It>>() && Bar<Foo<It, It>> {\n"
-               "  //....\n"
-               "}",
-               Style);
+  verifyFormat("template <typename T>\n"
+               "concept C = [] && true;");
 
-  verifyFormat("template <typename It>\n"
-               "requires Foo<Bar<It, It>>() && Bar<Foo<It, It>> {\n"
-               "  //....\n"
-               "}",
-               Style);
+  verifyFormat("template <typename T>\n"
+               "concept C = [] && requires(T t) {\n"
+               "  typename T::size_type;\n"
+               "};");
+}
 
-  verifyFormat(
-      "template <typename It>\n"
-      "requires Foo<Bar<It>, Baz<It>>() && Bar<Foo<It>, Baz<It, It>> {\n"
-      "  //....\n"
-      "}",
-      Style);
+TEST_F(FormatTest, RequiresClauseBeforeClass) {
+  auto Style = getLLVMStyle();
+  EXPECT_EQ(Style.RequiresClausePositionForClasses, FormatStyle::RCPS_OwnLine);
+  EXPECT_EQ(Style.IndentRequires, false);
 
-  Style.IndentRequires = true;
-  verifyFormat("template <typename It>\n"
-               "  requires Iterator<It>\n"
-               "void sort(It begin, It end) {\n"
-               "  //....\n"
-               "}",
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+                 "requires(std::invocable<F, std::invoke_result_t<Args>...>)\n"
+                 "struct constant;",
+                 Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
                Style);
-  verifyFormat("template <std::size index_>\n"
-               "  requires(index_ < sizeof...(Children_))\n"
-               "Tree auto &child() {\n"
-               "  // ...\n"
-               "}",
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires true\n"
+               "struct constant;",
                Style);
 
-  Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
-  verifyFormat("template <typename T>\n"
-               "concept Hashable = requires (T a) {\n"
-               "  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
-               "};",
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "         AndAnotherConcept<F>\n"
+               "struct constant;",
                Style);
 
-  verifyFormat("template <class T = void>\n"
-               "  requires EqualityComparable<T> || Same<T, void>\n"
-               "struct equal_to;",
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "         AndAnotherConcept<F>)\n"
+               "struct constant;",
                Style);
 
-  verifyFormat("template <class T>\n"
-               "  requires requires {\n"
-               "    T{};\n"
-               "    T (int);\n"
-               "  }\n",
+  verifyFormat("template <typename T>\n"
+               "requires(C<T> && C2<T>)\n"
+               "class Foo;",
                Style);
 
-  Style.ColumnLimit = 78;
   verifyFormat("template <typename T>\n"
-               "concept Context = Traits<typename T::traits_type> and\n"
-               "    Interface<typename T::interface_type> and\n"
-               "    Request<typename T::request_type> and\n"
-               "    Response<typename T::response_type> and\n"
-               "    ContextExtension<typename T::extension_type> and\n"
-               "    ::std::is_copy_constructable<T> and "
-               "::std::is_move_constructable<T> and\n"
-               "    requires (T c) {\n"
-               "  { c.response; } -> Response;\n"
-               "} and requires (T c) {\n"
-               "  { c.request; } -> Request;\n"
-               "}\n",
+               "requires(C<T> && C2<T>)\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
                Style);
 
   verifyFormat("template <typename T>\n"
-               "concept Context = Traits<typename T::traits_type> or\n"
-               "    Interface<typename T::interface_type> or\n"
-               "    Request<typename T::request_type> or\n"
-               "    Response<typename T::response_type> or\n"
-               "    ContextExtension<typename T::extension_type> or\n"
-               "    ::std::is_copy_constructable<T> or "
-               "::std::is_move_constructable<T> or\n"
-               "    requires (T c) {\n"
-               "  { c.response; } -> Response;\n"
-               "} or requires (T c) {\n"
-               "  { c.request; } -> Request;\n"
-               "}\n",
+               "requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "}\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
                Style);
 
   verifyFormat("template <typename T>\n"
-               "concept Context = Traits<typename T::traits_type> &&\n"
-               "    Interface<typename T::interface_type> &&\n"
-               "    Request<typename T::request_type> &&\n"
-               "    Response<typename T::response_type> &&\n"
-               "    ContextExtension<typename T::extension_type> &&\n"
-               "    ::std::is_copy_constructable<T> && "
-               "::std::is_move_constructable<T> &&\n"
-               "    requires (T c) {\n"
-               "  { c.response; } -> Response;\n"
-               "} && requires (T c) {\n"
-               "  { c.request; } -> Request;\n"
-               "}\n",
+               "requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T>\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
                Style);
 
-  verifyFormat("template <typename T>\nconcept someConcept = Constraint1<T> && "
-               "Constraint2<T>;");
+  Style.IndentRequires = true;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant;",
+               Style);
 
-  Style.BreakBeforeBraces = FormatStyle::BS_Custom;
-  Style.BraceWrapping.AfterFunction = true;
-  Style.BraceWrapping.AfterClass = true;
-  Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
-  Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
-  verifyFormat("void Foo () requires (std::copyable<T>)\n"
-               "{\n"
-               "  return\n"
-               "}\n",
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
                Style);
 
-  verifyFormat("void Foo () requires std::copyable<T>\n"
-               "{\n"
-               "  return\n"
-               "}\n",
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires true\n"
+               "struct constant;",
                Style);
 
   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
-               "  requires (std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "  requires Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "           AndAnotherConcept<F>\n"
                "struct constant;",
                Style);
 
   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
-               "  requires std::invocable<F, std::invoke_result_t<Args>...>\n"
+               "  requires(Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "           AndAnotherConcept<F>)\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires(C<T> && C2<T>)\n"
+               "class Foo;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires(C<T> && C2<T>)\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "}\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T>\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  Style.RequiresClausePositionForClasses = FormatStyle::RCPS_SingleLine;
+  Style.IndentRequires = false;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(std::invocable<F, std::invoke_result_t<Args>...>) "
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(std::invocable<F, std::invoke_result_t<Args>...>) "
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires true struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "         AndAnotherConcept<F> struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "         AndAnotherConcept<F>) struct constant;",
+               Style);
+
+  verifyFormat("template <typename T> requires(C<T> && C2<T>) class Foo;",
+               Style);
+
+  verifyFormat("template <typename T> requires(C<T> && C2<T>) class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T> requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T> requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T> class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  Style.IndentRequires = true;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(std::invocable<F, std::invoke_result_t<Args>...>) "
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(std::invocable<F, std::invoke_result_t<Args>...>) "
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires true struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "           AndAnotherConcept<F> struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "           AndAnotherConcept<F>) struct constant;",
+               Style);
+
+  verifyFormat("template <typename T> requires(C<T> && C2<T>) class Foo;",
+               Style);
+
+  verifyFormat("template <typename T> requires(C<T> && C2<T>) class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T> requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T> requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T> class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  Style.RequiresClausePositionForClasses = FormatStyle::RCPS_ToPreceeding;
+  Style.IndentRequires = false;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
+               Style);
+
+  verifyFormat(
+      "template <std::semiregular F, std::semiregular... Args> requires true\n"
+      "struct constant;",
+      Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "         AndAnotherConcept<F>\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(Concept1<F> && Concept2<Args...> && ThisIsAVeryLongConceptName<F> &&\n"
+               "         AndAnotherConcept<F>)\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <typename T> requires(C<T> && C2<T>)\n"
+               "class Foo;",
+               Style);
+
+  verifyFormat("template <typename T> requires(C<T> && C2<T>)\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T> requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "}\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T> requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T>\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  Style.IndentRequires = true;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
+               Style);
+
+  verifyFormat(
+      "template <std::semiregular F, std::semiregular... Args> requires true\n"
+      "struct constant;",
+      Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "           AndAnotherConcept<F>\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "           AndAnotherConcept<F>)\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <typename T> requires(C<T> && C2<T>)\n"
+               "class Foo;",
+               Style);
+
+  verifyFormat("template <typename T> requires(C<T> && C2<T>)\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T> requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "}\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T> requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T>\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  Style.RequiresClausePositionForClasses = FormatStyle::RCPS_ToFollowing;
+  Style.IndentRequires = false;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(std::invocable<F, std::invoke_result_t<Args>...>) "
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(std::invocable<F, std::invoke_result_t<Args>...>) "
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires true struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "         AndAnotherConcept<F> struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires(Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "         AndAnotherConcept<F>) struct constant;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "requires(C<T> && C2<T>) class Foo;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "requires(C<T> && C2<T>) class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T> class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  Style.IndentRequires = true;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(std::invocable<F, std::invoke_result_t<Args>...>) "
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(std::invocable<F, std::invoke_result_t<Args>...>) "
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires true struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "           AndAnotherConcept<F> struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires(Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "           AndAnotherConcept<F>) struct constant;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires(C<T> && C2<T>) class Foo;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires(C<T> && C2<T>) class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T> class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  Style.RequiresClausePositionForClasses = FormatStyle::RCPS_TwoLines;
+  Style.IndentRequires = false;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires\n"
+               "        (std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires\n"
+               "        (std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires\n"
+               "        true\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "requires\n"
+               "        Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "        AndAnotherConcept<F>\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "requires\n"
+               "        (C<T> && C2<T>)\n"
+               "class Foo;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "requires\n"
+               "        (C<T> && C2<T>)\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "requires\n"
+               "        requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "}\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "requires\n"
+               "        requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T>\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  Style.IndentRequires = true;
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires\n"
+               "          (std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires\n"
+               "          (std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant {\n"
+               "  int Foo;\n"
+               "  double Bar;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires\n"
+               "          true\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires\n"
+               "          Concept1<F> && Concept2<Args...> && "
+               "ThisIsAVeryLongConceptName<F> &&\n"
+               "          AndAnotherConcept<F>\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires\n"
+               "          (C<T> && C2<T>)\n"
+               "class Foo;",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires\n"
+               "          (C<T> && C2<T>)\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires\n"
+               "          requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "}\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires\n"
+               "          requires(T t) {\n"
+               "  typename T::Bar;\n"
+               "  { t.bar() } -> std::same_as<bool>;\n"
+               "} && C<T>\n"
+               "class Foo {\n"
+               "public:\n"
+               "  Foo();\n"
+               "  void foo() const;\n"
+               "};",
+               Style);
+}
+
+TEST_F(FormatTest, ConceptsAndRequires) {
+  return;
+  FormatStyle Style = getLLVMStyle();
+  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
+
+  verifyFormat("template <typename It>\n"
+               "requires Iterator<It>\n"
+               "void sort(It begin, It end) {\n"
+               "  //....\n"
+               "}",
+               Style);
+
+  verifyFormat("template <typename T> int g(T i) requires Concept1<I> {\n"
+               "  //...\n"
+               "}",
+               Style);
+
+  verifyFormat(
+      "template <typename T> int g(T i) requires Concept1<I> && Concept2<I> {\n"
+      "  //...\n"
+      "}",
+      Style);
+
+  verifyFormat(
+      "template <typename T> int g(T i) requires Concept1<I> || Concept2<I> {\n"
+      "  //...\n"
+      "}",
+      Style);
+
+  verifyFormat("template <typename T>\n"
+               "veryveryvery_long_return_type g(T i) requires Concept1<I> || "
+               "Concept2<I> {\n"
+               "  //...\n"
+               "}",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "veryveryvery_long_return_type g(T i) requires Concept1<I> && "
+               "Concept2<I> {\n"
+               "  //...\n"
+               "}",
+               Style);
+
+  verifyFormat(
+      "template <typename T>\n"
+      "veryveryvery_long_return_type g(T i) requires Concept1 && Concept2 {\n"
+      "  //...\n"
+      "}",
+      Style);
+
+  verifyFormat(
+      "template <typename T>\n"
+      "veryveryvery_long_return_type g(T i) requires Concept1 || Concept2 {\n"
+      "  //...\n"
+      "}",
+      Style);
+
+  verifyFormat("template <typename It>\n"
+               "requires Foo<It>() && Bar<It> {\n"
+               "  //....\n"
+               "}",
+               Style);
+
+  verifyFormat("template <typename It>\n"
+               "requires Foo<Bar<It>>() && Bar<Foo<It, It>> {\n"
+               "  //....\n"
+               "}",
+               Style);
+
+  verifyFormat("template <typename It>\n"
+               "requires Foo<Bar<It, It>>() && Bar<Foo<It, It>> {\n"
+               "  //....\n"
+               "}",
+               Style);
+
+  verifyFormat(
+      "template <typename It>\n"
+      "requires Foo<Bar<It>, Baz<It>>() && Bar<Foo<It>, Baz<It, It>> {\n"
+      "  //....\n"
+      "}",
+      Style);
+
+  Style.IndentRequires = true;
+  verifyFormat("template <typename It>\n"
+               "  requires Iterator<It>\n"
+               "void sort(It begin, It end) {\n"
+               "  //....\n"
+               "}",
+               Style);
+  verifyFormat("template <std::size index_>\n"
+               "  requires(index_ < sizeof...(Children_))\n"
+               "Tree auto &child() {\n"
+               "  // ...\n"
+               "}",
+               Style);
+
+  Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
+
+  verifyFormat("template <class T = void>\n"
+               "  requires EqualityComparable<T> || Same<T, void>\n"
+               "struct equal_to;",
+               Style);
+
+  Style.BreakBeforeBraces = FormatStyle::BS_Custom;
+  Style.BraceWrapping.AfterFunction = true;
+  Style.BraceWrapping.AfterClass = true;
+  Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
+  Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
+  verifyFormat("void Foo () requires (std::copyable<T>)\n"
+               "{\n"
+               "  return\n"
+               "}\n",
+               Style);
+
+  verifyFormat("void Foo () requires std::copyable<T>\n"
+               "{\n"
+               "  return\n"
+               "}\n",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires (std::invocable<F, std::invoke_result_t<Args>...>)\n"
+               "struct constant;",
+               Style);
+
+  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
+               "  requires std::invocable<F, std::invoke_result_t<Args>...>\n"
                "struct constant;",
                Style);
 
@@ -22518,13 +23415,114 @@
                "}\n",
                Style);
 
-  Style.BreakBeforeConceptDeclarations = false;
-  verifyFormat("template <typename T> concept Tree = true;", Style);
-
   Style.IndentRequires = false;
-  verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
-               "requires (std::invocable<F, std::invoke_result_t<Args>...>) "
-               "struct constant;",
+
+  verifyFormat("template <typename T> void func(T);");
+
+  verifyFormat("template <typename T>\n"
+               "requires std::signed_integral<T> && std::signed_integral<T>\n"
+               "void func(T);");
+  verifyFormat("template <typename T>\n"
+               "requires(std::is_integral_v<T> && std::is_signed_v<T>)\n"
+               "void func(T);");
+  verifyFormat("template <tyename T>\n"
+               "requires requires(T &&t) {\n"
+               "  typename T::size_type;\n"
+               "  { t.size() } -> std::same_as<typename T::size_type>;\n"
+               "}\n"
+               "func(T);");
+
+  verifyFormat("template <typename T>\n"
+               "requires std::signed_integral<T> && std::signed_integral<T>\n"
+               "void func(T) {}");
+  verifyFormat("template <typename T>\n"
+               "requires(std::is_integral_v<T> && std::is_signed_v<T>)\n"
+               "void func(T) {}");
+  verifyFormat("template <tyename T>\n"
+               "requires requires(T &&t) {\n"
+               "  typename T::size_type;\n"
+               "  { t.size() } -> std::same_as<typename T::size_type>;\n"
+               "}\n"
+               "func(T) {}");
+
+  verifyFormat(
+      "template <typename T> void func(T) requires std::signed_integral<T>;");
+  verifyFormat("template <typename T>\n"
+               "void func(T) requires std::signed_integral<T> && "
+               "std::signed_integral<T>;");
+  verifyFormat(
+      "template <typename T>\n"
+      "void func(T) requires(std::is_integral_v<T> && std::is_signed_v<T>);");
+  verifyFormat("template <typename T> void func(T) requires requires(T &&t) {\n"
+               "  typename T::size_type;\n"
+               "  { t.size() } -> std::same_as<typename T::size_type>;\n"
+               "};");
+
+  verifyFormat(
+      "template <typename T> void func(T) requires std::signed_integral<T> {}");
+  verifyFormat("template <typename T>\n"
+               "void func(T) requires std::signed_integral<T> && "
+               "std::signed_integral<T> {}");
+  verifyFormat(
+      "template <typename T>\n"
+      "void func(T) requires(std::is_integral_v<T> && std::is_signed_v<T>) {}");
+  verifyFormat("template <typename T> void func(T) requires requires(T &&t) {\n"
+               "  typename T::size_type;\n"
+               "  { t.size() } -> std::same_as<typename T::size_type>;\n"
+               "}\n"
+               "{}");
+
+  Style = getLLVMStyle();
+  Style.IndentRequires = true;
+
+  verifyFormat("template <typename T>\n"
+               "  requires std::signed_integral<T> && std::signed_integral<T>\n"
+               "void func(T);",
+               Style);
+  verifyFormat("template <typename T>\n"
+               "  requires(std::is_integral_v<T> && std::is_signed_v<T>)\n"
+               "void func(T);",
+               Style);
+  verifyFormat("template <tyename T>\n"
+               "  requires requires(T &&t) {\n"
+               "    typename T::size_type;\n"
+               "    { t.size() } -> std::same_as<typename T::size_type>;\n"
+               "  }\n"
+               "func(T);",
+               Style);
+
+  verifyFormat("template <typename T>\n"
+               "  requires std::signed_integral<T> && std::signed_integral<T>\n"
+               "void func(T) {}",
+               Style);
+  verifyFormat("template <typename T>\n"
+               "  requires(std::is_integral_v<T> && std::is_signed_v<T>)\n"
+               "void func(T) {}",
+               Style);
+  verifyFormat("template <tyename T>\n"
+               "  requires requires(T &&t) {\n"
+               "    typename T::size_type;\n"
+               "    { t.size() } -> std::same_as<typename T::size_type>;\n"
+               "  }\n"
+               "func(T) {}",
+               Style);
+
+  verifyFormat(
+      "template <typename T> void func(T) requires std::signed_integral<T> {}",
+      Style);
+  verifyFormat("template <typename T>\n"
+               "void func(T) requires std::signed_integral<T> && "
+               "std::signed_integral<T> {}",
+               Style);
+  verifyFormat(
+      "template <typename T>\n"
+      "void func(T) requires(std::is_integral_v<T> && std::is_signed_v<T>) {}",
+      Style);
+  verifyFormat("template <typename T> void func(T) requires requires(T &&t) {\n"
+               "  typename T::size_type;\n"
+               "  { t.size() } -> std::same_as<typename T::size_type>;\n"
+               "}\n"
+               "{}",
                Style);
 }
 
Index: clang/unittests/Format/TokenAnnotatorTest.cpp
===================================================================
--- clang/unittests/Format/TokenAnnotatorTest.cpp
+++ clang/unittests/Format/TokenAnnotatorTest.cpp
@@ -67,6 +67,51 @@
   EXPECT_TOKEN(Tokens[11], tok::star, TT_PointerOrReference);
 }
 
+TEST_F(TokenAnnotatorTest, UnderstandsRequiresClauses) {
+  auto Tokens = annotate("template <typename T>\n"
+                         "concept C = (Foo && Bar) && (Bar && Baz);");
+
+  EXPECT_EQ(Tokens.size(), 21u) << Tokens;
+  EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[13], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[16], tok::ampamp, TT_BinaryOperator);
+
+  Tokens = annotate("template <typename T>\n"
+                    "concept C = requires(T t) {\n"
+                    "  { t.foo() };\n"
+                    "} && Bar<T> && Baz<T>;");
+  EXPECT_EQ(Tokens.size(), 35u) << Tokens;
+  EXPECT_TOKEN(Tokens[23], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator);
+
+  Tokens = annotate("template<typename T>\n"
+                    "requires C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>\n"
+                    "struct Foo;");
+  EXPECT_EQ(Tokens.size(), 36u) << Tokens;
+  EXPECT_TOKEN(Tokens[6], tok::identifier, TT_Unknown);
+  EXPECT_EQ(Tokens[6]->FakeLParens.size(), 1u);
+  EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[16], tok::pipepipe, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[21], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[27], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[31], tok::greater, TT_TemplateCloser);
+  EXPECT_EQ(Tokens[31]->FakeRParens, 1u);
+
+  Tokens =
+      annotate("template<typename T>\n"
+               "requires (C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>)\n"
+               "struct Foo;");
+  EXPECT_EQ(Tokens.size(), 38u) << Tokens;
+  EXPECT_TOKEN(Tokens[7], tok::identifier, TT_Unknown);
+  EXPECT_EQ(Tokens[7]->FakeLParens.size(), 1u);
+  EXPECT_TOKEN(Tokens[11], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[17], tok::pipepipe, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[22], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[32], tok::greater, TT_TemplateCloser);
+  EXPECT_EQ(Tokens[32]->FakeRParens, 1u);
+}
+
 } // namespace
 } // namespace format
 } // namespace clang