Refactor how FunctionDecl handles constexpr:

[nwilson]

Summary

• This distinguishes between whether a function has constexpr specified and if a function is implicitly constexpr (implicitly inline).
• This also gives the ability to mark a function concept as implicitly constexpr (and implicitly inline)

[hubert.reinterpretcast]

include/clang/AST/Decl.h

1916

How is the inline property transmitted here? Why does the setImplicitlyConstexpr function need to call setImplicitlyInline?

1920

The quote does not seem to be pertinent here. Maybe have it a few lines down?

1924

I am quite sure this is not the right thing to do when IC is false.

lib/Sema/SemaDecl.cpp

8084–8085

The parenthetical here seems to be no longer needed.

9107

This reads wrong to me. I get that the idea is that the function should not be semantically considered constexpr, but the choice of setImplicitlyConstexpr seems odd.

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

21

This does not strike me as being very portable (I may be mistaken about how clang -cc1 works though). I think it would be much safer to use char [8] here (and in general for the size matching).

[nwilson]

include/clang/AST/Decl.h

1916

inline isn't really transmitted here. When we create a FunctionDecl in CreateNewFunctionDecl we could use this rather than passing isConstexpr as a parameter to the constructor. setImplicitlyConstexpr is intended to be used downstream such as in ActOnFunctionDeclarator or CheckExplicitlyDefaultedSpecialMember.

1920

Sorry, can you point to where you're thinking below?

1924

Good point. I could do if (IC) setImplicitlyInline();, but that doesn't seem great with these smaller functions. Any suggestions by you or @rsmith would be great!

lib/Sema/SemaDecl.cpp

8084–8085

I'll remove it.

9107

Hmm, I'm not sure if we should keep around setConstexpr to handle cases either... Do you or @rsmith have any opinion?

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

21

Yeah, good point. I'll fix this.

[nwilson]

• Initialize IsConstexprSpecified
• Remove unnecessary parenthetical in comment
• Fix non-portable test

[nwilson]

This comment was removed by nwilson.

[nwilson]

Ping

[rsmith]

include/clang/AST/Decl.h

1924

Doing something automatic here with the inline specifier is turning out to be too complex. Instead, let's just remove the setImplicitlyInline() call from here and call it explicitly when handling a concept.

[nwilson]

• Remove the call to setImplicitlyInline() within setImplicitlyConstexpr() and call setImplicitlyInline() directly for function concepts.

[nwilson]

Small Ping. @rsmith - did you have anymore thoughts about this patch?

include/clang/AST/Decl.h

private:
   unsigned HasWrittenPrototype : 1;
   unsigned IsDeleted : 1;
   unsigned IsTrivial : 1; // sunk from CXXMethodDecl
   unsigned IsDefaulted : 1; // sunk from CXXMethoDecl
   unsigned IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl
   unsigned HasImplicitReturnZero : 1;
   unsigned IsLateTemplateParsed : 1;
   unsigned IsConstexpr : 1;
+  unsigned IsConstexprSpecified : 1;
 
   /// \brief Indicates if the function uses __try.
   unsigned UsesSEHTry : 1;
 
   /// \brief Indicates if the function was a definition but its body was
   /// skipped.
   unsigned HasSkippedBody : 1;
 
FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                        StartLoc),
         DeclContext(DK), redeclarable_base(C), ParamInfo(nullptr), Body(),
         SClass(S), IsInline(isInlineSpecified),
         IsInlineSpecified(isInlineSpecified), IsVirtualAsWritten(false),
         IsPure(false), HasInheritedPrototype(false), HasWrittenPrototype(true),
         IsDeleted(false), IsTrivial(false), IsDefaulted(false),
         IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
         IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
+        IsConstexprSpecified(isConstexprSpecified),
         UsesSEHTry(false), HasSkippedBody(false), WillHaveBody(false),
         EndRangeLoc(NameInfo.getEndLoc()), TemplateOrSpecialization(),
         DNLoc(NameInfo.getInfo()) {}
 
   typedef Redeclarable<FunctionDecl> redeclarable_base;
   FunctionDecl *getNextRedeclarationImpl() override {
     return getNextRedeclaration();
   }
public:
 
   /// \brief Whether this function inherited its prototype from a
   /// previous declaration.
   bool hasInheritedPrototype() const { return HasInheritedPrototype; }
   void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; }
 
   /// Whether this is a (C++11) constexpr function or constexpr constructor.
   bool isConstexpr() const { return IsConstexpr; }
-  void setConstexpr(bool IC) { IsConstexpr = IC; }
+
+  /// Set whether the "constexpr" keyword was specified for this function.
+  void setConstexprSpecified(bool IC) {
+    IsConstexprSpecified = IC;
+    IsConstexpr = IC;
+  }
+
+  /// Flag that this function as implicitly constexpr
+  /// C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
+  /// are implicitly inline functions (7.1.2).
+  void setImplicitlyConstexpr(bool IC) {
+    IsConstexpr = IC;
+    setImplicitlyInline();
+  }
 
   /// \brief Indicates the function uses __try.
   bool usesSEHTry() const { return UsesSEHTry; }
   void setUsesSEHTry(bool UST) { UsesSEHTry = UST; }
 
   /// \brief Whether this function has been deleted.
   ///
   /// A function that is "deleted" (via the C++0x "= delete" syntax)

lib/Sema/SemaDecl.cpp

if (isConcept) {
         // C++ Concepts TS [dcl.spec.concept]p5: A function concept has the
         // following restrictions:
         // - The declaration's parameter list shall be equivalent to an empty
         //   parameter list.
         if (FPT->getNumParams() > 0 || FPT->isVariadic())
           Diag(NewFD->getLocation(), diag::err_function_concept_with_params);
       }
 
       // C++ Concepts TS [dcl.spec.concept]p2: Every concept definition is
-      // implicity defined to be a constexpr declaration (implicitly inline)
-      NewFD->setImplicitlyInline();
+      // implicity defined to be a constexpr declaration
+      NewFD->setImplicitlyConstexpr(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 (isInline) {
         Diag(D.getDeclSpec().getInlineSpecLoc(),
              diag::err_concept_decl_invalid_specifiers)
             << 1 << 1;
if (DS.isNoreturnSpecified()) {
     SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
     Diag(NoreturnLoc, diag::ext_noreturn_main);
     Diag(NoreturnLoc, diag::note_main_remove_noreturn)
       << FixItHint::CreateRemoval(NoreturnRange);
   }
   if (FD->isConstexpr()) {
     Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
       << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
-    FD->setConstexpr(false);
+    FD->setImplicitlyConstexpr(false);
   }
 
   if (getLangOpts().OpenCL) {
     Diag(FD->getLocation(), diag::err_opencl_no_main)
         << FD->hasAttr<OpenCLKernelAttr>();
     FD->setInvalidDecl();
     return;
   }

lib/Sema/SemaDeclCXX.cpp

if (Type->hasExceptionSpec()) {
     } else
       CheckExplicitlyDefaultedMemberExceptionSpec(MD, Type);
   }
 
   //   If a function is explicitly defaulted on its first declaration,
   if (First) {
     //  -- it is implicitly considered to be constexpr if the implicit
     //     definition would be,
-    MD->setConstexpr(Constexpr);
+    MD->setImplicitlyConstexpr(Constexpr);
 
     //  -- it is implicitly considered to have the same exception-specification
     //     as if it had been implicitly declared,
     FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
     EPI.ExceptionSpec.Type = EST_Unevaluated;
     EPI.ExceptionSpec.SourceDecl = MD;
     MD->setType(Context.getFunctionType(ReturnType,
                                         llvm::makeArrayRef(&ArgType,

lib/Sema/SemaLambda.cpp

LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange,
                                           ContainsUnexpandedParameterPack);
   // If the lambda expression's call operator is not explicitly marked constexpr
   // and we are not in a dependent context, analyze the call operator to infer
   // its constexpr-ness, supressing diagnostics while doing so.
   if (getLangOpts().CPlusPlus1z && !CallOperator->isInvalidDecl() &&
       !CallOperator->isConstexpr() &&
       !Class->getDeclContext()->isDependentContext()) {
     TentativeAnalysisScope DiagnosticScopeGuard(*this);
-    CallOperator->setConstexpr(
+    CallOperator->setImplicitlyConstexpr(
         CheckConstexprFunctionDecl(CallOperator) &&
         CheckConstexprFunctionBody(CallOperator, CallOperator->getBody()));
   }
 
   // Emit delayed shadowing warnings now that the full capture list is known.
   DiagnoseShadowingLambdaDecls(LSI);
 
   if (!CurContext->isDependentContext()) {

lib/Sema/SemaTemplate.cpp

bool Sema::CheckFunctionTemplateSpecialization(
   // Note: do not overwrite location info if previous template
   // specialization kind was explicit.
   TemplateSpecializationKind TSK = SpecInfo->getTemplateSpecializationKind();
   if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
     Specialization->setLocation(FD->getLocation());
     // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
     // function can differ from the template declaration with respect to
     // the constexpr specifier.
-    Specialization->setConstexpr(FD->isConstexpr());
+    Specialization->setImplicitlyConstexpr(FD->isConstexpr());
   }
 
   // FIXME: Check if the prior specialization has a point of instantiation.
   // If so, we have run afoul of .
 
   // If this is a friend declaration, then we're not really declaring
   // an explicit specialization.
   bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);

test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.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 'thread_local'}}
 
 template<typename T> concept constexpr bool VCC = true; // expected-error {{variable concept cannot be declared 'constexpr'}}
 
 template<typename T> concept inline bool FCI() { return true; } // expected-error {{function concept cannot be declared 'inline'}}
 
 struct X {
   template<typename T> concept friend bool FCF() { return true; } // expected-error {{function concept cannot be declared 'friend'}}
 };
 
 template<typename T> concept constexpr bool FCC() { return true; } // expected-error {{function concept cannot be declared 'constexpr'}}
+
+template <typename T> concept bool FCSizeOf() { return sizeof(T) == 8; }
+static_assert(FCSizeOf<char[8]>(), "");
+static_assert(FCSizeOf<char[9]>(), "size of argument not equal to expected (8)"); // expected-error {{static_assert failed "size of argument not equal to expected (8)"}}
+
+struct TestType {};
+template <typename T, typename U> concept bool FCSameType() { return __is_same(T, U); }
+static_assert(FCSameType<TestType, TestType>(), "");
+
+template <typename T>
+struct remove_reference { typedef T type; };
+template <typename T>
+struct remove_reference<T &> { typedef T type; };
+template <typename T>
+struct remove_reference<T &&> { typedef T type; };
+
+template <typename T>
+constexpr T &&forward(typename remove_reference<T>::type &t) noexcept { return static_cast<T &&>(t); }
+template <typename T>
+constexpr T &&forward(typename remove_reference<T>::type &&t) noexcept { return static_cast<T &&>(t); }
+
+template <typename F, typename... Args>
+constexpr decltype(auto) CFFwdCall(F &&func, Args &&... args) {
+  return forward<F>(func)(forward<Args>(args)...);
+}
+
+static_assert(CFFwdCall(FCSameType<short, short int>), "");