[Concepts] Add diagnostic; invalid specifier on function or variable concept declaration

[nwilson]

Summary

Diagnose variable and function concept declarations when an invalid specifier appears

[hubert.reinterpretcast]

include/clang/Basic/DiagnosticSemaKinds.td

1982

The wording seems unwieldy. There are a number of messages of the form:

[ ... ] cannot be declared '<blah>'

Perhaps something along those lines would work here?

btw, there's a typo in the message identifier.

[nwilson]

include/clang/Basic/DiagnosticSemaKinds.td

1982

I'll fix the typo. Thanks. I can change the wording as well; I don't feel too strongly about it unless someone has a different opinion. Are you okay with the second select?

So, it would be:
"%select{variable|function}0 concept cannot be declared %select{thread_local|constexpr|inline}1"

[hubert.reinterpretcast]

include/clang/Basic/DiagnosticSemaKinds.td

1982

Not sure if other people have an opinion, but the single quotes around, e.g., 'inline' would fit. For 'friend', the quoted version is terser (without quotes, it would be awkward). On that note, if we plan to use this message for the "friend" case, let's add it in the same order as the quoted portion of the TS now.

[nwilson]

Change the wording of diagnostic message and quote the invalid specifier. Add 'friend' as an invalid specifier and diagnose function concepts when 'friend' is specified. Reorder the list of invalid specifiers and corresponding checks in the code to match the TS.

[nwilson]

Ping

[hubert.reinterpretcast]

LGTM

include/clang/Basic/DiagnosticSemaKinds.td

 def err_concept_decls_may_only_appear_in_namespace_scope : Error<
   "concept declarations may only appear in namespace scope">;
 def err_function_concept_not_defined : Error<
   "function concept declaration must be a definition">;
 def err_var_concept_not_initialized : Error<
   "variable concept declaration must be initialized">;
 def err_function_concept_exception_spec : Error<
   "function concept cannot have exception specification">;
+def err_concept_decl_invalid_sepcifiers : Error<
+  "%select{variable|function}0 concept cannot be declared with "
+  "%select{thread_local|constexpr|inline}1 specified">;
 
 // C++11 char16_t/char32_t
 def warn_cxx98_compat_unicode_type : Warning<
   "'%0' type specifier is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
  
 // Objective-C++
 def err_objc_decls_may_only_appear_in_global_scope : Error<

lib/Sema/SemaDecl.cpp

if (!getLangOpts().CPlusPlus) {
     unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
     if (TemplateParamLists.size() > VDTemplateParamLists)
       NewVD->setTemplateParameterListsInfo(
           Context, TemplateParamLists.drop_back(VDTemplateParamLists));
 
     if (D.getDeclSpec().isConstexprSpecified())
       NewVD->setConstexpr(true);
 
-    if (D.getDeclSpec().isConceptSpecified())
+    if (D.getDeclSpec().isConceptSpecified()) {
       NewVD->setConcept(true);
+
+      // C++ Concepts TS [dcl.spec.concept]p2: A concept definition shall not
+      // be declared with the thread_local, inline, friend, or constexpr
+      // specifiers, [...]
+      if (D.getDeclSpec().getThreadStorageClassSpec() == TSCS_thread_local) {
+        Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
+             diag::err_concept_decl_invalid_sepcifiers)
+            << 0 << 0;
+        NewVD->setInvalidDecl(true);
+      }
+
+      if (D.getDeclSpec().isConstexprSpecified()) {
+        Diag(D.getDeclSpec().getConstexprSpecLoc(),
+             diag::err_concept_decl_invalid_sepcifiers)
+            << 0 << 1;
+        NewVD->setInvalidDecl(true);
+      }
+    }
   }
 
   // Set the lexical context. If the declarator has a C++ scope specifier, the
   // lexical context will be different from the semantic context.
   NewVD->setLexicalDeclContext(CurContext);
   if (NewTemplate)
     NewTemplate->setLexicalDeclContext(CurContext);
 
if (isConcept) {
         } else {
           Context.adjustExceptionSpec(NewFD, EST_BasicNoexcept);
         }
       }
 
       // C++ Concepts TS [dcl.spec.concept]p2: Every concept definition is
       // implicity defined to be a constexpr declaration (implicitly inline)
       NewFD->setImplicitlyInline();
+
+      // C++ Concepts TS [dcl.spec.concept]p2: A concept definition shall not
+      // be declared with the thread_local, inline, friend, or constexpr
+      // specifiers, [...]
+      if (isConstexpr) {
+        Diag(D.getDeclSpec().getConstexprSpecLoc(),
+             diag::err_concept_decl_invalid_sepcifiers)
+            << 1 << 1;
+        NewFD->setInvalidDecl(true);
+      }
+
+      if (isInline) {
+        Diag(D.getDeclSpec().getInlineSpecLoc(),
+             diag::err_concept_decl_invalid_sepcifiers)
+            << 1 << 2;
+        NewFD->setInvalidDecl(true);
+      }
     }
 
     // If __module_private__ was specified, mark the function accordingly.
     if (D.getDeclSpec().isModulePrivateSpecified()) {
       if (isFunctionTemplateSpecialization) {
         SourceLocation ModulePrivateLoc
           = D.getDeclSpec().getModulePrivateSpecLoc();
         Diag(ModulePrivateLoc, diag::err_module_private_specialization)

test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.concept/p2.cpp

+// RUN:  %clang_cc1 -std=c++14 -fconcepts-ts -x c++ -verify %s
+
+template<typename T> concept thread_local bool VCTL = true; // expected-error {{variable concept cannot be declared with thread_local specified}}
+
+template<typename T> concept constexpr bool VCC = true; // expected-error {{variable concept cannot be declared with constexpr specified}}
+
+template<typename T> concept constexpr bool FCC() { return true; } // expected-error {{function concept cannot be declared with constexpr specified}}
+
+template<typename T> concept inline bool FCI() { return true; } // expected-error {{function concept cannot be declared with inline specified}}