[Concepts] Remove -fconcepts-ts, enable concepts support under -std=c++2a

[saar.raz]

Summary

Enable concepts support under normal -std=c++2a and not under -fconcepts-ts, which is now deprecated.

[saar.raz]

Readd -fconcepts-ts for deprecation diagnostic

[rsmith]

clang/include/clang/Basic/LangOptions.def

124

Looks like you picked up an unrelated change here; please revert this.

clang/lib/Frontend/InitPreprocessor.cpp

389

I think everything is done other than P0848, so according to https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#__cpp_concepts the appropriate value to use here is 201907L.

clang/www/cxx_status.html

884

As discussed off-line: I think P0848R3 is not yet done, so that row should be left as "No" instead of being marked as "Clang 10". (I'm assuming you'll land https://reviews.llvm.org/D73155 first, so P1616R1 will be done before this goes in.)

clang/include/clang/Basic/DiagnosticFrontendKinds.td

 def err_fe_action_not_available : Error<
     "action %0 not compiled in">;
 def err_fe_invalid_alignment : Error<
     "invalid value '%1' in '%0'; alignment must be a power of 2">;
 def err_fe_invalid_wchar_type
     : Error<"invalid wchar_t type '%0'; must be one of 'char', 'short', 'int'">;
 def err_fe_invalid_exception_model
    : Error<"invalid exception model '%0' for target '%1'">;
+def warn_fe_concepts_ts_flag : Warning<
+  "-fconcepts-ts is deprecated - use '-std=c++2a' for concepts support">,
+  InGroup<Deprecated>;
 
 def warn_fe_serialized_diag_merge_failure : Warning<
     "unable to merge a subprocess's serialized diagnostics">,
     InGroup<SerializedDiagnostics>;
 def warn_fe_serialized_diag_failure : Warning<
     "unable to open file %0 for serializing diagnostics (%1)">,
     InGroup<SerializedDiagnostics>;
 

clang/include/clang/Basic/LangOptions.def

 LANGOPT(Digraphs          , 1, 0, "digraphs")
 BENIGN_LANGOPT(HexFloats  , 1, C99, "C99 hexadecimal float constants")
 LANGOPT(CXXOperatorNames  , 1, 0, "C++ operator name keywords")
 LANGOPT(AppleKext         , 1, 0, "Apple kext support")
 BENIGN_LANGOPT(PascalStrings, 1, 0, "Pascal string support")
 LANGOPT(WritableStrings   , 1, 0, "writable string support")
 LANGOPT(ConstStrings      , 1, 0, "const-qualified string support")
 ENUM_LANGOPT(LaxVectorConversions, LaxVectorConversionKind, 2,
-             LaxVectorConversionKind::All, "lax vector conversions")
+             LaxVectorConversionKind::Integer, "lax vector conversions")
 LANGOPT(ConvergentFunctions, 1, 1, "Assume convergent functions")
 LANGOPT(AltiVec           , 1, 0, "AltiVec-style vector initializers")
 LANGOPT(ZVector           , 1, 0, "System z vector extensions")
 LANGOPT(Exceptions        , 1, 0, "exception handling")
 LANGOPT(ObjCExceptions    , 1, 0, "Objective-C exceptions")
 LANGOPT(CXXExceptions     , 1, 0, "C++ exceptions")
 LANGOPT(DWARFExceptions   , 1, 0, "dwarf exception handling")
 LANGOPT(SjLjExceptions    , 1, 0, "setjmp-longjump exception handling")

 LANGOPT(SYCLIsDevice      , 1, 0, "Generate code for SYCL device")
 
 LANGOPT(HIPUseNewLaunchAPI, 1, 0, "Use new kernel launching API for HIP")
 
 LANGOPT(SizedDeallocation , 1, 0, "sized deallocation")
 LANGOPT(AlignedAllocation , 1, 0, "aligned allocation")
 LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable")
 LANGOPT(NewAlignOverride  , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'")
-LANGOPT(ConceptsTS , 1, 0, "enable C++ Extensions for Concepts")
 LANGOPT(ConceptSatisfactionCaching , 1, 1, "enable satisfaction caching for C++2a Concepts")
 BENIGN_LANGOPT(ModulesCodegen , 1, 0, "Modules code generation")
 BENIGN_LANGOPT(ModulesDebugInfo , 1, 0, "Modules debug info")
 BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision")
 BENIGN_LANGOPT(DumpRecordLayouts , 1, 0, "dumping the layout of IRgen'd records")
 BENIGN_LANGOPT(DumpRecordLayoutsSimple , 1, 0, "dumping the layout of IRgen'd records in a simple form")
 BENIGN_LANGOPT(DumpVTableLayouts , 1, 0, "dumping the layouts of emitted vtables")
 LANGOPT(NoConstantCFStrings , 1, 0, "no constant CoreFoundation strings")

clang/include/clang/Basic/TokenKinds.def

 CXX11_KEYWORD(char32_t              , KEYNOMS18)
 CXX11_KEYWORD(constexpr             , 0)
 CXX11_KEYWORD(decltype              , 0)
 CXX11_KEYWORD(noexcept              , 0)
 CXX11_KEYWORD(nullptr               , 0)
 CXX11_KEYWORD(static_assert         , KEYMSCOMPAT)
 CXX11_KEYWORD(thread_local          , 0)
 
-// C++2a / concepts TS keywords
+// C++2a keywords
 CONCEPTS_KEYWORD(concept)
 CONCEPTS_KEYWORD(requires)
 
 // C++2a / coroutines TS keywords
 COROUTINES_KEYWORD(co_await)
 COROUTINES_KEYWORD(co_return)
 COROUTINES_KEYWORD(co_yield)
 

clang/lib/Basic/IdentifierTable.cpp

static KeywordStatus getKeywordStatus(const LangOptions &LangOpts,
   if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLC))
     return KS_Enabled;
   if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX)) return KS_Enabled;
   if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) return KS_Enabled;
   if (LangOpts.C11 && (Flags & KEYC11)) return KS_Enabled;
   // We treat bridge casts as objective-C keywords so we can warn on them
   // in non-arc mode.
   if (LangOpts.ObjC && (Flags & KEYOBJC)) return KS_Enabled;
-  if (LangOpts.ConceptsTS && (Flags & KEYCONCEPTS)) return KS_Enabled;
+  if (LangOpts.CPlusPlus2a && (Flags & KEYCONCEPTS)) return KS_Enabled;
   if (LangOpts.Coroutines && (Flags & KEYCOROUTINES)) return KS_Enabled;
   if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled;
   if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future;
   return KS_Disabled;
 }
 
 /// AddKeyword - This method is used to associate a token ID with specific
 /// identifiers because they are language keywords.  This causes the lexer to

clang/lib/Frontend/CompilerInvocation.cpp

#include "clang/Basic/LangStandards.def"
   Opts.NewAlignOverride =
       getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags);
   if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {
     Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
     Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
                                                  << A->getValue();
     Opts.NewAlignOverride = 0;
   }
-  Opts.ConceptsTS = Args.hasArg(OPT_fconcepts_ts);
   Opts.ConceptSatisfactionCaching =
       !Args.hasArg(OPT_fno_concept_satisfaction_caching);
+  if (Args.hasArg(OPT_fconcepts_ts))
+    Diags.Report(diag::warn_fe_concepts_ts_flag);
   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
   Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
   Opts.InstantiationDepth =
       getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
   Opts.ArrowDepth =
       getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);

clang/lib/Frontend/InitPreprocessor.cpp

if (!LangOpts.CPlusPlus) {
     else if (LangOpts.CPlusPlus11)
       Builder.defineMacro("__cplusplus", "201103L");
     // C++03 [cpp.predefined]p1:
     //   The name __cplusplus is defined to the value 199711L when compiling a
     //   C++ translation unit.
     else
       Builder.defineMacro("__cplusplus", "199711L");
 
-    if (LangOpts.ConceptsTS)
+    if (LangOpts.CPlusPlus2a)
       Builder.defineMacro("__cpp_concepts", "201707L");
 
     // C++1z [cpp.predefined]p1:
     //   An integer literal of type std::size_t whose value is the alignment
     //   guaranteed by a call to operator new(std::size_t)
     //
     // We provide this in all language modes, since it seems generally useful.
     Builder.defineMacro("__STDCPP_DEFAULT_NEW_ALIGNMENT__",
                         Twine(TI.getNewAlign() / TI.getCharWidth()) +
if (LangOpts.CPlusPlus2a) {
     //Builder.defineMacro("__cpp_modules", "201907L");
     //Builder.defineMacro("__cpp_using_enum", "201907L");
   }
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "201811L");
   Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
 
   // TS features.
-  if (LangOpts.ConceptsTS)
-    Builder.defineMacro("__cpp_experimental_concepts", "1L");
   if (LangOpts.Coroutines)
     Builder.defineMacro("__cpp_coroutines", "201703L");
 }
 
 static void InitializePredefinedMacros(const TargetInfo &TI,
                                        const LangOptions &LangOpts,
                                        const FrontendOptions &FEOpts,
                                        const PreprocessorOptions &PPOpts,

clang/lib/Parse/ParseTemplate.cpp

 ///
 ///     type-constraint:
 ///       nested-name-specifier[opt] concept-name
 ///       nested-name-specifier[opt] concept-name
 ///           '<' template-argument-list[opt] '>'[opt]
 ///
 /// \returns true if an error occurred, and false otherwise.
 bool Parser::TryAnnotateTypeConstraint() {
-  if (!getLangOpts().ConceptsTS)
+  if (!getLangOpts().CPlusPlus2a)
     return false;
   CXXScopeSpec SS;
   bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope);
   if (ParseOptionalCXXScopeSpecifier(
           SS, ParsedType(),
           /*EnteringContext=*/false,
           /*MayBePseudoDestructor=*/nullptr,
           // If this is not a type-constraint, then

clang/lib/Sema/SemaTemplate.cpp

if (!Name.isDependent() &&
             InstantiationDependent)) {
       Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
           << VarTemplate->getDeclName();
       IsPartialSpecialization = false;
     }
 
     if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(),
                                 Converted) &&
-        (!Context.getLangOpts().ConceptsTS ||
+        (!Context.getLangOpts().CPlusPlus2a ||
          !TemplateParams->hasAssociatedConstraints())) {
       // C++ [temp.class.spec]p9b3:
       //
       //   -- The argument list of the specialization shall not be identical
       //      to the implicit argument list of the primary template.
       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
         << /*variable template*/ 1
         << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
if (isPartialSpecialization) {
     // Build the canonical type that describes the converted template
     // arguments of the class template partial specialization.
     TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
     CanonType = Context.getTemplateSpecializationType(CanonTemplate,
                                                       Converted);
 
     if (Context.hasSameType(CanonType,
                         ClassTemplate->getInjectedClassNameSpecialization()) &&
-        (!Context.getLangOpts().ConceptsTS ||
+        (!Context.getLangOpts().CPlusPlus2a ||
          !TemplateParams->hasAssociatedConstraints())) {
       // C++ [temp.class.spec]p9b3:
       //
       //   -- The argument list of the specialization shall not be identical
       //      to the implicit argument list of the primary template.
       //
       // This rule has since been removed, because it's redundant given DR1495,
       // but we keep it because it produces better diagnostics and recovery.

clang/lib/Sema/SemaType.cpp

if (DeducedType *Deduced = T->getContainedDeducedType()) {
     case DeclaratorContext::RequiresExprContext:
       Error = 22;
       break;
     case DeclaratorContext::PrototypeContext:
     case DeclaratorContext::LambdaExprParameterContext: {
       InventedTemplateParameterInfo *Info = nullptr;
       if (D.getContext() == DeclaratorContext::PrototypeContext) {
         // With concepts we allow 'auto' in function parameters.
-        if (!SemaRef.getLangOpts().ConceptsTS || !Auto ||
+        if (!SemaRef.getLangOpts().CPlusPlus2a || !Auto ||
             Auto->getKeyword() != AutoTypeKeyword::Auto) {
           Error = 0;
           break;
         } else if (!SemaRef.getCurScope()->isFunctionDeclarationScope()) {
           Error = 21;
           break;
         } else if (D.hasTrailingReturnType()) {
           // This might be OK, but we'll need to convert the trailing return
case DeclaratorChunk::Function: {
                 << T << D.getDeclSpec().getSourceRange();
             D.setInvalidType(true);
           }
           T = S.GetTypeFromParser(FTI.getTrailingReturnType(), &TInfo);
           if (T.isNull()) {
             // An error occurred parsing the trailing return type.
             T = Context.IntTy;
             D.setInvalidType(true);
-          } else if (S.getLangOpts().ConceptsTS)
+          } else if (S.getLangOpts().CPlusPlus2a)
             // Handle cases like: `auto f() -> auto` or `auto f() -> C auto`.
             if (AutoType *Auto = T->getContainedAutoType())
               if (S.getCurScope()->isFunctionDeclarationScope())
                 T = InventTemplateParameter(state, T, TInfo, Auto,
                                             S.InventedParameterInfos.back());
         } else {
           // This function type is not the type of the entity being declared,
           // so checking the 'auto' is not the responsibility of this chunk.
case DeclaratorContext::RequiresExprContext:
       //   parameter pack is a function parameter pack (14.5.3). The type T
       //   of the declarator-id of the function parameter pack shall contain
       //   a template parameter pack; each template parameter pack in T is
       //   expanded by the function parameter pack.
       //
       // We represent function parameter packs as function parameters whose
       // type is a pack expansion.
       if (!T->containsUnexpandedParameterPack() &&
-          (!LangOpts.ConceptsTS || !T->getContainedAutoType())) {
+          (!LangOpts.CPlusPlus2a || !T->getContainedAutoType())) {
         S.Diag(D.getEllipsisLoc(),
              diag::err_function_parameter_pack_without_parameter_packs)
           << T <<  D.getSourceRange();
         D.setEllipsisLoc(SourceLocation());
       } else {
         T = Context.getPackExpansionType(T, None);
       }
       break;

clang/test/CXX/class.derived/class.virtual/p6.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T>
 class A {
   virtual void f1() requires (sizeof(T) == 0);
   // expected-error@-1{{virtual function cannot have a requires clause}}
   virtual void f2() requires (sizeof(T) == 1);
   // expected-error@-1{{virtual function cannot have a requires clause}}
 };
 
 template<typename T>
 class B : A<T> {
   virtual void f1() requires (sizeof(T) == 0) override {}
   // expected-error@-1{{virtual function cannot have a requires clause}}
 };
 
 template<typename T> struct C : T {void f() requires true; };
 // expected-error@-1{{virtual function cannot have a requires clause}}
 struct D { virtual void f(); };
 template struct C<D>;
 // expected-note@-1{{in instantiation of template class 'C<D>' requested here}}
 No newline at end of file

clang/test/CXX/dcl/dcl.decl/p3.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T, typename U>
 constexpr bool is_same_v = false;
 
 template<typename T>
 constexpr bool is_same_v<T, T> = true;
 
 void f1(int a) requires true; // OK

clang/test/CXX/dcl/dcl.fct/p17.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 template<typename T, typename U> constexpr bool is_same_v = false;
 template<typename T> constexpr bool is_same_v<T, T> = true;
 
 template<typename... T>
 struct type_list;
 
 namespace unconstrained {
   decltype(auto) f1(auto x) { return x; }

clang/test/CXX/dcl/dcl.spec/dcl.type/dcl.spec.auto/p6.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T, unsigned size>
 concept LargerThan = sizeof(T) > size;
 // expected-note@-1 2{{because 'sizeof(char) > 1U' (1 > 1) evaluated to false}}
 // expected-note@-2 {{because 'sizeof(int) > 10U' (4 > 10) evaluated to false}}
 // expected-note@-3 {{because 'sizeof(int) > 4U' (4 > 4) evaluated to false}}
 
 template<typename T>

 ::LargerThan<2> auto test4() { return 10; }
 
 Large auto test5() -> void;
 // expected-error@-1{{function with trailing return type must specify return type 'auto', not 'Large auto'}}
 auto test6() -> Large auto { return 1; }
 
 X::Small auto test7() { return 'a'; }
 X::SmallerThan<5> auto test8() { return 10; }
 No newline at end of file

clang/test/CXX/expr/expr.prim/expr.prim.id/mixed-constraints.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T> requires (sizeof(T) >= 4 && sizeof(T) <= 10)
 // expected-note@-1{{because 'sizeof(char [20]) <= 10' (20 <= 10) evaluated to false}}
 // expected-note@-2{{because 'sizeof(char) >= 4' (1 >= 4) evaluated to false}}
 void foo() requires (sizeof(T) <= 8) {}
 // expected-note@-1{{candidate template ignored: constraints not satisfied [with T = char]}}
 // expected-note@-2{{candidate template ignored: constraints not satisfied [with T = char [9]]}}
 // expected-note@-3{{candidate template ignored: constraints not satisfied [with T = char [20]]}}
 // expected-note@-4{{because 'sizeof(char [9]) <= 8' (9 <= 8) evaluated to false}}
 
 void bar() {
   foo<char>(); // expected-error{{no matching function for call to 'foo'}}
   foo<int>();
   foo<unsigned long long int>();
   foo<char[9]>(); // expected-error{{no matching function for call to 'foo'}}
   foo<char[20]>(); // expected-error{{no matching function for call to 'foo'}}
 }
 No newline at end of file

clang/test/CXX/expr/expr.prim/expr.prim.id/p4.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 namespace functions
 {
   void foo(int) requires false {}
   // expected-note@-1 3{{because 'false' evaluated to false}}
   // expected-note@-2 {{candidate function not viable: constraints not satisfied}}
   void bar(int) requires true {}
 
struct A {
     A<T> operator-(A<T> b) requires (sizeof(T) == 1) { return b; } // expected-note{{because 'sizeof(int) == 1' (4 == 1) evaluated to false}}
   };
 
   void baz() {
     auto* x = &A<int>::operator-; // expected-error{{invalid reference to function 'operator-': constraints not satisfied}}
     auto y = &A<char>::operator-;
   }
 }
 No newline at end of file

clang/test/CXX/expr/expr.prim/expr.prim.lambda/expr.prim.lambda.closure/p3.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 auto l1 = [] (auto x) requires (sizeof(decltype(x)) == 1) { return x; };
 // expected-note@-1{{candidate template ignored: constraints not satisfied [with x:auto = int]}}
 // expected-note@-2{{because 'sizeof(decltype(x)) == 1' (4 == 1) evaluated to false}}
 
 auto l1t1 = l1('a');
 auto l1t2 = l1(1);
 // expected-error@-1{{no matching function for call to object of type '(lambda at}}
 
 auto l2 = [] (auto... x) requires ((sizeof(decltype(x)) >= 2) && ...) { return (x + ...); };
 // expected-note@-1{{candidate template ignored: constraints not satisfied [with x:auto = <char>]}}
 // expected-note@-2{{candidate template ignored: constraints not satisfied [with x:auto = <int, char>]}}
 // expected-note@-3 2{{because 'sizeof(decltype(x)) >= 2' (1 >= 2) evaluated to false}}
 
 auto l2t1 = l2('a');
 // expected-error@-1{{no matching function for call to object of type '(lambda at}}
 auto l2t2 = l2(1, 'a');
 // expected-error@-1{{no matching function for call to object of type '(lambda at}}
 auto l2t3 = l2((short)1, (short)1);
 No newline at end of file

clang/test/CXX/expr/expr.prim/expr.prim.req/compound-requirement.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 static_assert(requires { { 0 }; });
 static_assert(requires { { "aaaa" }; });
 static_assert(requires { { (0).da }; }); // expected-error{{member reference base type 'int' is not a structure or union}}
 
 void foo() {}
 static_assert(requires { { foo() }; });
 
template<typename T> concept C5 =
     requires(T x) {
       {g(x)} noexcept; // expected-note{{because 'g(x)' may throw an exception}}
     };
 
   static_assert(C5<char>);
   template<C5 T> struct C5_check {}; // expected-note{{because 'short' does not satisfy 'C5'}}
   using c5 = C5_check<short>; // expected-error{{constraints not satisfied for class template 'C5_check' [with T = short]}}
 }
 No newline at end of file

clang/test/CXX/expr/expr.prim/expr.prim.req/equivalence.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 template<typename T, typename U> constexpr bool is_same_v = false;
 template<typename T> constexpr bool is_same_v<T, T> = true;
 
 template<typename T> struct identity { using type = T; };
 template<typename T> using identity_t = T;
 
 // Type requirements

clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 static_assert(requires { requires true; });
 
 template<typename T> requires requires { requires false; } // expected-note{{because 'false' evaluated to false}}
 struct r1 {};
 
 using r1i = r1<int>; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}}
 
namespace std_example {
   using dc1 = D_check<short>; // expected-error{{constraints not satisfied for class template 'D_check' [with T = short]}}
 
   template<typename T>
   concept C2 = requires (T a) { // expected-note{{'a' declared here}}
       requires sizeof(a) == 4; // OK
       requires a == 0; // expected-error{{constraint variable 'a' cannot be used in an evaluated context}}
     };
 }
 No newline at end of file

clang/test/CXX/expr/expr.prim/expr.prim.req/p3.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 // Examples from standard
 
 template<typename T, typename U>
 concept convertible_to = requires(T t) { U(t); };
 
 template<typename T>
 concept R = requires (T i) {

 
 template<typename T>
 concept C = requires (T x) { x + x; }; // expected-note{{because 'x + x' would be invalid: invalid operands to binary expression ('T' and 'T')}}
 template<typename T> requires C<T> // expected-note{{because 'T' does not satisfy 'C'}}
 T add2(T a, T b) { return a + b; } // expected-note{{candidate template ignored: constraints not satisfied [with T = T]}}
 
 int z = add2(1, 2);
 int w = add2(T{}, T{}); // expected-error{{no matching function for call to 'add2'}}
 No newline at end of file

clang/test/CXX/expr/expr.prim/expr.prim.req/requires-expr.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 using A = int;
 
 template<typename T, typename U>
 constexpr bool is_same_v = false;
 
 template<typename T>
 constexpr bool is_same_v<T, T> = true;

 struct S { static const int s = T::value; };
 
 template<typename T> requires requires { T::value; S<T>::s; }
 // expected-note@-1 {{because 'T::value' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
 struct r4 { };
 
 using r4i = r4<int>;
 // expected-error@-1 {{constraints not satisfied for class template 'r4' [with T = int]}}
 No newline at end of file

clang/test/CXX/expr/expr.prim/expr.prim.req/simple-requirement.cpp

-// RUN: %clang_cc1 %s -I%S -std=c++2a -fconcepts-ts -verify
+// RUN: %clang_cc1 %s -I%S -std=c++2a -verify
 
 namespace std { struct type_info; }
 
 static_assert(requires { 0; });
 static_assert(requires { "aaaa"; });
 static_assert(requires { (0).da; }); // expected-error{{member reference base type 'int' is not a structure or union}}
 
 struct A {};

clang/test/CXX/expr/expr.prim/expr.prim.req/type-requirement.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 using A = int;
 
 template<typename T> using identity_t = T; // expected-note 4{{template is declared here}}}
 
 template<typename T> struct identity { using type = T; };
 // expected-note@-1 2{{template is declared here}}
 
namespace std_example {
   // expected-note@-1 {{because 'std_example::has_inner' does not satisfy 'C2'}}
   template<C3 T> struct C3_check {};
   // expected-note@-1 {{because 'void' does not satisfy 'C3'}}
   using c1 = C1_check<int>; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = int]}}
   using c2 = C1_check<has_type>; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = std_example::has_type]}}
   using c3 = C2_check<has_inner>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = std_example::has_inner]}}
   using c4 = C3_check<void>; // expected-error{{constraints not satisfied for class template 'C3_check' [with T = void]}}
 }
 No newline at end of file

clang/test/CXX/over/over.match/over.match.best/p1-2a.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T, typename U>
 constexpr static bool is_same_v = false;
 
 template<typename T>
 constexpr static bool is_same_v<T, T> = true;
 
 namespace templates

clang/test/CXX/over/over.match/over.match.viable/p3.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 struct S2 {};
 // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'S1' to 'const S2' for 1st argument}}
 // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'S1' to 'S2' for 1st argument}}
 // expected-note@-3 {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
 
 struct S1 {
   void foo() const requires true {}
void bar() {
   // expected-error@-1{{invalid reference to function '~S': constraints not satisfied}}
   // Note - this behavior w.r.t. constrained dtors is a consequence of current
   // wording, which does not invoke overload resolution when a dtor is called.
   // P0848 is set to address this issue.
   S s = 1;
   // expected-error@-1{{invalid reference to function '~S': constraints not satisfied}}
   int a = s;
 }
 No newline at end of file

clang/test/CXX/over/over.over/p4-2a.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T, typename U>
 constexpr static bool is_same_v = false;
 
 template<typename T>
 constexpr static bool is_same_v<T, T> = true;
 
 template<typename T>

 
 void a() {
   static_assert(is_same_v<decltype(&foo), int(*)()>);
   static_assert(is_same_v<decltype(&bar), long(*)()>);
   // expected-error@-1{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
   // expected-error@-2{{call to 'bar' is ambiguous}}
   static_assert(is_same_v<decltype(&baz), long(*)()>);
 }
 No newline at end of file

clang/test/CXX/temp/temp.arg/temp.arg.template/p3-2a.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -frelaxed-template-template-args -verify %s
+// RUN:  %clang_cc1 -std=c++2a -frelaxed-template-template-args -verify %s
 
 template<typename T> concept C = T::f();
 // expected-note@-1{{similar constraint}}
 template<typename T> concept D = C<T> && T::g();
 template<typename T> concept F = T::f();
 // expected-note@-1{{similar constraint expressions not considered equivalent}}
 template<template<C> class P> struct S1 { }; // expected-note 2{{'P' declared here}}
 

clang/test/CXX/temp/temp.constr/temp.constr.constr/function-templates.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T>
 constexpr bool is_ptr_v = false;
 
 template<typename T>
 constexpr bool is_ptr_v<T*> = true;
 
 template<typename T, typename U>

 auto bar(T t) { // expected-note {{candidate template ignored: constraints not satisfied [with T = A]}}
   return t + t;
 }
 
 struct A { };
 
 static_assert(foo(A{})); // expected-error {{no matching function for call to 'foo'}}
 static_assert(bar(A{})); // expected-error {{no matching function for call to 'bar'}}
 No newline at end of file

clang/test/CXX/temp/temp.constr/temp.constr.constr/non-function-templates.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T> requires (sizeof(T) >= 2) // expected-note{{because 'sizeof(char) >= 2' (1 >= 2) evaluated to false}}
 struct A {
   static constexpr int value = sizeof(T);
 };
 
 static_assert(A<int>::value == 4);
 static_assert(A<char>::value == 1); // expected-error{{constraints not satisfied for class template 'A' [with T = char]}}

clang/test/CXX/temp/temp.constr/temp.constr.constr/partial-specializations.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 namespace class_templates
 {
   template<typename T, typename U> requires (sizeof(T) >= 4) // expected-note {{because 'sizeof(char) >= 4' (1 >= 4) evaluated to false}}
   struct is_same { static constexpr bool value = false; };
 
   template<typename T> requires (sizeof(T*) >= 4 && sizeof(T) >= 4)
   struct is_same<T*, T*> { static constexpr bool value = true; };
namespace variable_templates
 
   static_assert(v1<int**>); // expected-note{{while checking constraint satisfaction for variable template partial specialization 'v1<int *>' required here}}
   // expected-note@-1{{while checking constraint satisfaction for variable template partial specialization 'v1<int>' required here}}
   // expected-note@-2{{during template argument deduction for variable template partial specialization 'v1<T *>' [with T = int *]}}
   // expected-note@-3{{during template argument deduction for variable template partial specialization 'v1<T **>' [with T = int]}}
   // expected-error@-4{{static_assert failed due to requirement 'v1<int **>'}}
 
 }
 No newline at end of file

clang/test/CXX/temp/temp.constr/temp.constr.decl/class-template-decl.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 namespace nodiag {
 
 template <typename T> requires (bool(T()))
 struct A;
 template <typename U> requires (bool(U()))
 struct A;
 

clang/test/CXX/temp/temp.constr/temp.constr.decl/p3.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T>
 struct X {
     using Y = typename T::invalid;
 };
 
 template<typename T>
 concept Invalid = X<T>{};

 
 template<False T> // expected-note{{because 'int' does not satisfy 'False'}}
   requires Invalid<T>
 void g2(); // requires Invalid<T>;
 // expected-note@-1{{candidate template ignored: constraints not satisfied [with T = int]}}
 
 using g2i = decltype(g2<int>());
 // expected-error@-1{{no matching function for call to 'g2'}}
 No newline at end of file

clang/test/CXX/temp/temp.constr/temp.constr.normal/p1.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T> concept True = true;
 template<typename T> concept Foo = True<T*>;
 template<typename T> concept Bar = Foo<T&>;
 template<typename T> requires Bar<T> struct S { };
 template<typename T> requires Bar<T> && true struct S<T> { };
 
 template<typename T> concept True2 = sizeof(T) >= 0;

clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T> requires (sizeof(T) >= 4)
 // expected-note@-1{{similar constraint expressions not considered equivalen}}
 class A{}; // expected-note{{template is declared here}}
 
 template<typename T> requires (sizeof(T) >= 4 && sizeof(T) <= 10)
 // expected-note@-1{{similar constraint expression here}}
 

clang/test/CXX/temp/temp.constr/temp.constr.order/function-templates.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T> requires (sizeof(T) >= 4)
 // expected-note@-1{{similar constraint expressions not considered equivalent}}
 bool a() { return false; } // expected-note {{candidate function [with T = unsigned int]}}
 
 template<typename T> requires (sizeof(T) >= 4 && sizeof(T) <= 10)
 // expected-note@-1{{similar constraint expression here}}
 bool a() { return true; } // expected-note {{candidate function [with T = unsigned int]}}

clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T> requires (sizeof(T) >= 4)
 // expected-note@-1{{similar constraint expressions not considered equivalent}}
 bool a = false; // expected-note{{template is declared here}}
 
 template<typename T> requires (sizeof(T) >= 4 && sizeof(T) <= 10)
 // expected-note@-1{{similar constraint expression here}}
 bool a<T> = true; // expected-error{{variable template partial specialization is not more specialized than the primary template}}

clang/test/CXX/temp/temp.explicit/p8.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T, typename S = char> requires (sizeof(T) + sizeof(S) < 10)
 // expected-note@-1{{because 'sizeof(char [100]) + sizeof(char) < 10' (101 < 10) evaluated to false}}
 void f(T t, S s) requires (sizeof(t) == 1 && sizeof(s) == 1) { };
 // expected-note@-1{{candidate template ignored: constraints not satisfied [with T = int, S = char]}}
 // expected-note@-2{{because 'sizeof (t) == 1' (4 == 1) evaluated to false}}
 // expected-note@-3{{candidate template ignored: constraints not satisfied [with T = char, S = short]}}
 // expected-note@-4{{because 'sizeof (s) == 1' (2 == 1) evaluated to false}}
 // expected-note@-5{{candidate template ignored: constraints not satisfied [with T = char [100], S = char]}}
 
 template<>
 void f<int>(int t, char s) { };
 // expected-error@-1{{no function template matches function template specialization 'f'}}
 
 template<>
 void f<char, short>(char t, short s) { };
 // expected-error@-1{{no function template matches function template specialization 'f'}}
 
 template<>
 void f<char[100]>(char t[100], char s) { };
 // expected-error@-1{{no function template matches function template specialization 'f'}}
 No newline at end of file

clang/test/CXX/temp/temp.param/p10-2a.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T>
 concept C1 = sizeof(T) == 1;
 // expected-note@-1 2{{because 'sizeof(short) == 1' (2 == 1) evaluated to false}}
 // expected-note@-2 {{because 'sizeof(int) == 1' (4 == 1) evaluated to false}}
 
 template<C1 T> // expected-note {{because 'int' does not satisfy 'C1'}}
 using A = T;

clang/test/CodeGenCXX/mangle-concept.cpp

-// RUN: %clang_cc1 -verify -Wno-return-type -Wno-main -std=c++2a -fconcepts-ts -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
+// RUN: %clang_cc1 -verify -Wno-return-type -Wno-main -std=c++2a -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
 // expected-no-diagnostics
 
 namespace test1 {
 template <bool> struct S {};
 template <typename> concept C = true;
 template <typename T = int> S<C<T>> f0() { return S<C<T>>{}; }
 template S<C<int>> f0<>();
 // CHECK: @_ZN5test12f0IiEENS_1SIXL_ZNS_1CIT_EEEEEEv(
 }
 
 template <bool> struct S {};
 template <typename> concept C = true;
 template <typename T = int> S<C<T>> f0() { return S<C<T>>{}; }
 template S<C<int>> f0<>();
 // CHECK: @_Z2f0IiE1SIXL_Z1CIT_EEEEv(

clang/test/Lexer/cxx-features.cpp

 // RUN: %clang_cc1 -std=c++98 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++2a -fcxx-exceptions -fsized-deallocation -verify %s
 //
 // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -frelaxed-template-template-args -DRELAXED_TEMPLATE_TEMPLATE_ARGS=1 -verify %s
-// RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -fconcepts-ts -DCONCEPTS_TS=1 -verify %s
+// RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -DCONCEPTS_TS=1 -verify %s
 // RUN: %clang_cc1 -std=c++14 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS -fsized-deallocation
 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -DNO_EXCEPTIONS -DCOROUTINES -verify -fsized-deallocation %s
 // RUN: %clang_cc1 -std=c++14 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify -fsized-deallocation %s
 // RUN: %clang_cc1 -std=c++2a -fno-char8_t -DNO_EXCEPTIONS -DNO_CHAR8_T -verify -fsized-deallocation %s
 
 // expected-no-diagnostics
 
 // FIXME using `defined` in a macro has undefined behavior.

clang/test/Lexer/keywords_test.cpp

 // RUN: %clang_cc1 -std=c++03 -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++11 -DCXX11 -fsyntax-only %s
-// RUN: %clang_cc1 -std=c++14 -fconcepts-ts -DCXX11 -DCONCEPTS -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++14 -DCXX11 -DCONCEPTS -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++2a -DCXX11 -DCXX2A -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fdeclspec -DDECLSPEC -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fms-extensions -DDECLSPEC -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fborland-extensions -DDECLSPEC -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fms-extensions -fno-declspec -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fborland-extensions -fno-declspec -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fno-declspec -fdeclspec -DDECLSPEC -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++03 -fdeclspec -fno-declspec -fsyntax-only %s

 #ifndef MS
 CXX11_KEYWORD(static_assert);
 #else
 // MS compiler recognizes static_assert in all modes. So should we.
 IS_KEYWORD(static_assert);
 #endif
 CXX11_KEYWORD(thread_local);
 
-// Concepts TS keywords
+// Concepts keywords
 CONCEPTS_KEYWORD(concept);
 CONCEPTS_KEYWORD(requires);
 
 // __declspec extension
 DECLSPEC_KEYWORD(__declspec);
 
 // Clang extension
 IS_KEYWORD(__char16_t);
 IS_TYPE(__char16_t);
 IS_KEYWORD(__char32_t);
 IS_TYPE(__char32_t);

clang/test/PCH/cxx2a-requires-expr.cpp

-// RUN: %clang_cc1 -emit-pch -std=c++2a -fconcepts-ts -o %t %s
-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x ast -ast-print %t | FileCheck %s
+// RUN: %clang_cc1 -emit-pch -std=c++2a -o %t %s
+// RUN: %clang_cc1 -std=c++2a -x ast -ast-print %t | FileCheck %s
 
 template<typename T>
 concept C = true;
 
 template<typename T, typename U>
 concept C2 = true;
 
 template<typename T>

clang/test/Parser/cxx-concept-declaration.cpp

 
 // Support parsing of concepts
 // Disabled for now.
 // expected-no-diagnostics
 
-// RUN:  %clang_cc1 -std=c++14 -fconcepts-ts -x c++ -verify %s
+// RUN:  %clang_cc1 -std=c++14 -x c++ -verify %s
 // template<typename T> concept C1 = true;

clang/test/Parser/cxx-concepts-ambig-constraint-expr.cpp

-// RUN: %clang_cc1 -std=c++14 -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++14 -x c++ %s -verify
 
 // Test parsing of constraint-expressions in cases where the grammar is
 // ambiguous with the expectation that the longest token sequence which matches
 // the syntax is consumed without backtracking.
 
 // type-specifier-seq in conversion-type-id
 template <typename T> requires T::operator short
 unsigned int foo(); // expected-error {{C++ requires a type specifier for all declarations}}
 No newline at end of file

clang/test/Parser/cxx-concepts-requires-clause.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 // Test parsing of the optional requires-clause in a template-declaration.
 
 template <typename T> requires true
 void foo() { }
 
 template <typename T> requires (!0)
 struct A {

 };
 
 auto lambda1 = [] (auto x) requires (sizeof(decltype(x)) == 1) { };
 
 auto lambda2 = [] (auto x) constexpr -> int requires (sizeof(decltype(x)) == 1) { return 0; };
 
 auto lambda3 = [] requires (sizeof(char) == 1) { };
 // expected-error@-1{{lambda requires '()' before 'requires' clause}}
 No newline at end of file

clang/test/Parser/cxx2a-concept-declaration.cpp

 // Support parsing of concepts
 
-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 template<typename T> concept C1 = true; // expected-note 2{{previous}}
 
 template<typename T> concept C1 = true; // expected-error{{redefinition}}
 
 template<concept T> concept D1 = true;
 // expected-error@-1{{expected template parameter}}
 // expected-error@-2{{concept template parameter list must have at least one parameter; explicit specialization of concepts is not allowed}}
 

clang/test/Parser/cxx2a-concepts-requires-expr.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 bool r1 = requires () {};
 // expected-error@-1 {{a requires expression must contain at least one requirement}}
 
 bool r2 = requires { requires true; };
 
 bool r3 = requires (int a, ...) { requires true; };
 // expected-error@-1 {{varargs not allowed in requires expression}}

clang/test/Parser/cxx2a-constrained-template-param-with-partial-id.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 template<typename T, int a>
 concept C1 = true;
 
 template<C1 T>
 // expected-error@-1 {{'C1' requires more than 1 template argument; provide the remaining arguments explicitly to use it here}}
 using badA = T[10];
 

 // expected-error@-1 {{'C2' requires more than 1 template argument; provide the remaining arguments explicitly to use it here}}
 struct badC { };
 
 template<ns::C2<int>... T1>
 struct C { };
 
 using c1 = C<char, char, char>;
 using c2 = C<char, char, char, char>;
 No newline at end of file

clang/test/Parser/cxx2a-constrained-template-param.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 namespace type
 {
   template<typename T>
   concept C1 = true;
 
   template<C1 T, C1 U = int>
   using A = T[10];
namespace temp
 
   template<template<typename> typename T>
   concept C1 = true;
 
   template<C1 TT, C1 UU = test1> // expected-error{{use of class template 'test1' requires template arguments}}
   // expected-error@-1 2{{concept named in type constraint is not a type concept}}
   using A = TT<int>; // expected-error{{expected ';' after alias declaration}}
 }
 No newline at end of file

clang/test/Parser/cxx2a-placeholder-type-constraint.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 template<typename T, typename U=void>
 concept C = true;
 
 int foo() {
   C auto a4 = 1;
   C<> auto a5 = 1;
   C<int> auto a6 = 1;
int foo() {
   // expected-error@-1{{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
   C a15 = 1;
   // expected-error@-1{{expected 'auto' or 'decltype(auto)' after concept name}}
   C decltype a19 = 1;
   // expected-error@-1{{expected '('}}
   C decltype(1) a20 = 1;
   // expected-error@-1{{expected 'auto' or 'decltype(auto)' after concept name}}
 }
 No newline at end of file

clang/test/SemaTemplate/cxx2a-constraint-caching.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s -fno-concept-satisfaction-caching -DNO_CACHE
+// RUN:  %clang_cc1 -std=c++2a -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s -fno-concept-satisfaction-caching -DNO_CACHE
 // expected-no-diagnostics
 
 template<typename T>
 concept C = (f(T()), true);
 
 template<typename T>
 constexpr bool foo() { return false; }
 

 }
 #ifdef NO_CACHE
 static_assert(!C<a::A>);
 static_assert(!foo<a::A>());
 #else
 static_assert(C<a::A>);
 static_assert(foo<a::A>());
 #endif
 No newline at end of file

clang/test/SemaTemplate/instantiate-expanded-type-constraint.cpp

-// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T, typename U>
 constexpr bool is_same_v = false;
 
 template<typename T>
 constexpr bool is_same_v<T, T> = true;
 
 template<typename T, typename U>

clang/test/SemaTemplate/instantiate-requires-clause.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
 
 template <typename... Args> requires ((sizeof(Args) == 1), ...)
 // expected-note@-1 {{because '(sizeof(int) == 1) , (sizeof(char) == 1) , (sizeof(int) == 1)' evaluated to false}}
 void f1(Args&&... args) { }
 // expected-note@-1 {{candidate template ignored: constraints not satisfied [with Args = <int, char, int>]}}
 
 using f11 = decltype(f1('a'));
 using f12 = decltype(f1(1, 'b'));

clang/test/SemaTemplate/instantiate-requires-expr.cpp

-// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify -Wno-unused-value
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify -Wno-unused-value
 
 template<typename T, typename U>
 constexpr bool is_same_v = false;
 
 template<typename T>
 constexpr bool is_same_v<T, T> = true;
 
 // We use a hack in this file to make the compiler print out the requires

clang/www/cxx_status.html

</tr>
     <tr>
       <td><i>template-parameter-list</i> for generic lambdas</td>
       <td><a href="https://wg21.link/p0428r2">P0428R2</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr id="p0734">
       <td rowspan="9">Concepts</td>
       <td><a href="https://wg21.link/p0734r0">P0734R0</a></td>
-      <td rowspan="9" class="none" align="center">No</td>
+      <td rowspan="9" class="full" align="center">Clang 10</td>
     </tr>
       <tr> <!-- from Albuquerque -->
         <td><a href="https://wg21.link/p0857r0">P0857R0</a></td>
       </tr>
       <tr> <!-- from San Diego -->
         <td><a href="https://wg21.link/p1084r2">P1084R2</a></td>
       </tr>
       <tr>