[clang] Add support for consteval constructors

[Tyker]

Summary

Changes:

• handle immediate invocations for constructors.
• add tests

after this patch i believe the implementation of consteval is standard compliant, but IR-gen still needs to be taught not to emit consteval declarations.

[rsmith]

clang/lib/Sema/SemaExpr.cpp

15314

* on the right, please.

15408–15435

It's unfortunate that TreeTransform has this quirk. :( I think we can maybe deal with this without duplicating the rebuilding code from TreeTransform, though: perhaps you could add a flag to TreeTransform::TransformCXXConstructExpr to enable / disable skipping implicit conversions (with a default argument), and call Transformer.TransformCXXConstructExpr(..., false) instead of Transformer.TransformExpr(...) when the expression is a CXXConstructExpr?

15409

situtation -> situation
Remove final "is"

15411

rebuild -> rebuilt

[Tyker]

fixed comments.

clang/lib/Sema/SemaExpr.cpp

15408–15435

I didn't change the prototype of TreeTransform::TransformCXXConstructExpr because i rather keep the prototypes of all TreeTransform::Transform* the same. but i added a option to TreeTransform to remove the code duplication.

[Tyker]

ping

[Tyker]

ping

[rsmith]

clang/lib/Sema/TreeTransform.h

160

Typo "Wether" -> "Whether"

162

"usefull" -> "useful", "cause" -> "causes"

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def warn_cxx14_compat_constexpr_not_const : Warning<
   "'constexpr' non-static member function will not be implicitly 'const' "
   "in C++14; add 'const' to avoid a change in behavior">,
   InGroup<DiagGroup<"constexpr-not-const">>;
 def err_invalid_consteval_take_address : Error<
   "cannot take address of consteval function %0 outside"
   " of an immediate invocation">;
 def err_invalid_consteval_call : Error<
-  "call to consteval function '%q0' is not a constant expression">;
+  "call to consteval function %q0 is not a constant expression">;
 def err_invalid_consteval_decl_kind : Error<
   "%0 cannot be declared consteval">;
 def err_invalid_constexpr : Error<
   "%select{function parameter|typedef}0 "
   "cannot be %sub{select_constexpr_spec_kind}1">;
 def err_invalid_constexpr_member : Error<"non-static data member cannot be "
   "constexpr%select{; did you intend to make it %select{const|static}0?|}1">;
 def err_constexpr_tag : Error<

clang/lib/Sema/SemaDeclCXX.cpp

Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
   assert(declaresSameEntity(
              Constructor->getParent(),
              DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
          "given constructor for wrong type");
   MarkFunctionReferenced(ConstructLoc, Constructor);
   if (getLangOpts().CUDA && !CheckCUDACall(ConstructLoc, Constructor))
     return ExprError();
 
-  return CXXConstructExpr::Create(
-      Context, DeclInitType, ConstructLoc, Constructor, Elidable,
-      ExprArgs, HadMultipleCandidates, IsListInitialization,
+  return CheckForImmediateInvocation(
+      CXXConstructExpr::Create(
+          Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
+          HadMultipleCandidates, IsListInitialization,
           IsStdInitListInitialization, RequiresZeroInit,
           static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
-      ParenRange);
+          ParenRange),
+      Constructor);
 }
 
 ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
   assert(Field->hasInClassInitializer());
 
   // If we already have the in-class initializer nothing needs to be done.
   if (Field->getInClassInitializer())
     return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);

clang/lib/Sema/SemaExpr.cpp

static void EvaluateAndDiagnoseImmediateInvocation(
     Sema &SemaRef, Sema::ImmediateInvocationCandidate Candidate) {
   llvm::SmallVector<PartialDiagnosticAt, 8> Notes;
   Expr::EvalResult Eval;
   Eval.Diag = &Notes;
   ConstantExpr *CE = Candidate.getPointer();
   if (!CE->EvaluateAsConstantExpr(Eval, Expr::EvaluateForCodeGen,
                                   SemaRef.getASTContext(), true)) {
     Expr *InnerExpr = CE->getSubExpr()->IgnoreImplicit();
+    if (auto *FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
+      InnerExpr = FunctionalCast->getSubExpr();
     FunctionDecl *FD = nullptr;
     if (auto *Call = dyn_cast<CallExpr>(InnerExpr))
       FD = cast<FunctionDecl>(Call->getCalleeDecl());
     else if (auto *Call = dyn_cast<CXXConstructExpr>(InnerExpr))
       FD = Call->getConstructor();
     else
       llvm_unreachable("unhandled decl kind");
     assert(FD->isConsteval());
ExprResult TransformInitializer(Expr *Init, bool NotCopyInit) {
       return Base::TransformInitializer(Init, NotCopyInit);
     }
     ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
       DRSet.erase(E);
       return E;
     }
     bool AlwaysRebuild() { return false; }
     bool ReplacingOriginal() { return true; }
+    bool AllowSkippingCXXConstructExpr() {
+      bool Res = AllowSkippingFirstCXXConstructExpr;
+      AllowSkippingFirstCXXConstructExpr = true;
+      return Res;
+    }
+    bool AllowSkippingFirstCXXConstructExpr = true;
   } Transformer(SemaRef, Rec.ReferenceToConsteval,
                 Rec.ImmediateInvocationCandidates, It);
+
+  /// CXXConstructExpr with a single argument are getting skipped by
+  /// TreeTransform in some situtation because they could be implicit. This
+  /// can only occur for the top-level CXXConstructExpr because it is used
+  /// nowhere in the expression being transformed therefore will not be rebuilt.
+  /// Setting AllowSkippingFirstCXXConstructExpr to false will prevent from
+  /// skipping the first CXXConstructExpr.
+  if (auto *OldExpr =
+          dyn_cast<CXXConstructExpr>(It->getPointer()->IgnoreImplicit()))
+    Transformer.AllowSkippingFirstCXXConstructExpr = false;
+
   ExprResult Res = Transformer.TransformExpr(It->getPointer()->getSubExpr());
   assert(Res.isUsable());
   Res = SemaRef.MaybeCreateExprWithCleanups(Res);
   It->getPointer()->setSubExpr(Res.get());
 }
 
 static void
 HandleImmediateInvocations(Sema &SemaRef,
                            Sema::ExpressionEvaluationContextRecord &Rec) {
   if ((Rec.ImmediateInvocationCandidates.size() == 0 &&
        Rec.ReferenceToConsteval.size() == 0) ||
       SemaRef.RebuildingImmediateInvocation)
     return;
 
   /// When we have more then 1 ImmediateInvocationCandidates we need to check
   /// for nested ImmediateInvocationCandidates. when we have only 1 we only
   /// need to remove ReferenceToConsteval in the immediate invocation.
   if (Rec.ImmediateInvocationCandidates.size() > 1) {
 
     /// Prevent sema calls during the tree transform from adding pointers that
     /// are already in the sets.
     llvm::SaveAndRestore<bool> DisableIITracking(
         SemaRef.RebuildingImmediateInvocation, true);
 
     /// Prevent diagnostic during tree transfrom as they are duplicates
     Sema::TentativeAnalysisScope DisableDiag(SemaRef);
 
     for (auto It = Rec.ImmediateInvocationCandidates.rbegin();
          It != Rec.ImmediateInvocationCandidates.rend(); It++)
       if (!It->getInt())
         RemoveNestedImmediateInvocation(SemaRef, Rec, It);
   } else if (Rec.ImmediateInvocationCandidates.size() == 1 &&
              Rec.ReferenceToConsteval.size()) {
     struct SimpleRemove : RecursiveASTVisitor<SimpleRemove> {
       llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
       SimpleRemove(llvm::SmallPtrSetImpl<DeclRefExpr *> &S) : DRSet(S) {}
       bool VisitDeclRefExpr(DeclRefExpr *E) {
         DRSet.erase(E);
         return DRSet.size();

clang/lib/Sema/SemaInit.cpp

if (isExplicitTemporary(Entity, Kind, NumArgs)) {
     if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
             Step.Function.FoundDecl.getDecl())) {
       Constructor = S.findInheritingConstructor(Loc, Constructor, Shadow);
       if (S.DiagnoseUseOfDecl(Constructor, Loc))
         return ExprError();
     }
     S.MarkFunctionReferenced(Loc, Constructor);
 
-    CurInit = CXXTemporaryObjectExpr::Create(
+    CurInit = S.CheckForImmediateInvocation(
+        CXXTemporaryObjectExpr::Create(
             S.Context, Constructor,
             Entity.getType().getNonLValueExprType(S.Context), TSInfo,
             ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
             IsListInitialization, IsStdInitListInitialization,
-        ConstructorInitRequiresZeroInit);
+            ConstructorInitRequiresZeroInit),
+        Constructor);
   } else {
     CXXConstructExpr::ConstructionKind ConstructKind =
       CXXConstructExpr::CK_Complete;
 
     if (Entity.getKind() == InitializedEntity::EK_Base) {
       ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
         CXXConstructExpr::CK_VirtualBase :
         CXXConstructExpr::CK_NonVirtualBase;

clang/lib/Sema/TreeTransform.h

public:
   /// statement node appears at most once in its containing declaration.
   bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; }
 
   /// Whether the transformation is forming an expression or statement that
   /// replaces the original. In this case, we'll reuse mangling numbers from
   /// existing lambdas.
   bool ReplacingOriginal() { return false; }
 
+  /// Wether CXXConstructExpr can be skipped when they are implicit.
+  /// They will be reconstructed when used if needed.
+  /// This is usefull when the user that cause rebuilding of the
+  /// CXXConstructExpr is outside of the expression at which the TreeTransform
+  /// started.
+  bool AllowSkippingCXXConstructExpr() { return true; }
+
   /// Returns the location of the entity being transformed, if that
   /// information was not available elsewhere in the AST.
   ///
   /// By default, returns no source-location information. Subclasses can
   /// provide an alternative implementation that provides better location
   /// information.
   SourceLocation getBaseLocation() { return SourceLocation(); }
 

 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
   // CXXConstructExprs other than for list-initialization and
   // CXXTemporaryObjectExpr are always implicit, so when we have
   // a 1-argument construction we just transform that argument.
-  if ((E->getNumArgs() == 1 ||
+  if (getDerived().AllowSkippingCXXConstructExpr() &&
+      ((E->getNumArgs() == 1 ||
         (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
        (!getDerived().DropCallArgument(E->getArg(0))) &&
-      !E->isListInitialization())
+       !E->isListInitialization()))
     return getDerived().TransformExpr(E->getArg(0));
 
   TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName());
 
   QualType T = getDerived().TransformType(E->getType());
   if (T.isNull())
     return ExprError();
 

clang/test/SemaCXX/cxx2a-consteval.cpp

// expected-note@-1 {{declared here}}
   int t = f(i);
 // expected-error@-1 {{is not a constant expression}}
 // expected-note@-2 {{read of non-const variable}}
   return f(0);  
 };
 
 }
 
+namespace std {
+
+template <typename T> struct remove_reference { using type = T; };
+template <typename T> struct remove_reference<T &> { using type = T; };
+template <typename T> struct remove_reference<T &&> { using type = T; };
+
+template <typename T>
+constexpr typename std::remove_reference<T>::type&& move(T &&t) noexcept {
+  return static_cast<typename std::remove_reference<T>::type &&>(t);
+}
+
+}
+
 namespace temporaries {
 
 struct A {
   consteval int ret_i() const { return 0; }
   consteval A ret_a() const { return A{}; }
   constexpr ~A() { }
 };
 
void test() {
   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
   { A k = to_lvalue_ref(A().ret_a()); } // expected-error {{is not a constant expression}}
   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
   { int k = A().ret_a().ret_i(); }
   { int k = by_value_a(A()); }
   { int k = const_a_ref(A()); }
   { int k = const_a_ref(a); }
   { int k = rvalue_ref(A()); }
-  { int k = rvalue_ref(static_cast<const A&&>(a)); }
+  { int k = rvalue_ref(std::move(a)); }
   { int k = const_a_ref(A().ret_a()); }
   { int k = const_a_ref(to_lvalue_ref(A().ret_a())); }
-  { int k = const_a_ref(to_lvalue_ref(static_cast<const A&&>(a))); }
+  { int k = const_a_ref(to_lvalue_ref(std::move(a))); }
   { int k = by_value_a(A().ret_a()); }
-  { int k = by_value_a(to_lvalue_ref(static_cast<const A&&>(a))); }
+  { int k = by_value_a(to_lvalue_ref(std::move(a))); }
   { int k = (A().ret_a(), A().ret_i()); }
   { int k = (const_a_ref(A().ret_a()), A().ret_i()); }//
 }
 
 }
 
 namespace alloc {
 
void test() {
   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
   { A k = to_lvalue_ref(A().ret_a()); } // expected-error {{is not a constant expression}}
   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
   { int k = A().ret_a().ret_i(); }
   { int k = by_value_a(A()); }
   { int k = const_a_ref(A()); }
   { int k = const_a_ref(a); }
   { int k = rvalue_ref(A()); }
-  { int k = rvalue_ref(static_cast<const A&&>(a)); }
+  { int k = rvalue_ref(std::move(a)); }
   { int k = const_a_ref(A().ret_a()); }
   { int k = const_a_ref(to_lvalue_ref(A().ret_a())); }
-  { int k = const_a_ref(to_lvalue_ref(static_cast<const A&&>(a))); }
+  { int k = const_a_ref(to_lvalue_ref(std::move(a))); }
   { int k = by_value_a(A().ret_a()); }
   { int k = by_value_a(to_lvalue_ref(static_cast<const A&&>(a))); }
   { int k = (A().ret_a(), A().ret_i()); }// expected-error {{is not a constant expression}}
   // expected-note@-1 {{is not a constant expression}}
   { int k = (const_a_ref(A().ret_a()), A().ret_i()); }
 }
 
 }

 
 void test() {
   S s(1);
   s = f(1);
   s = f(0); // expected-error {{is not a constant expression}}
   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
 }
 
+struct S1 {
+  S1* ptr = nullptr;
+  consteval S1(int i) : ptr(this) {
+    if (this == ptr && i)
+      ptr = nullptr;
+  }
+  constexpr ~S1() {}
+};
+
+void test1() {
+  S1 s(1);
+  s = S1(1);
+  s = S1(0); // expected-error {{is not a constant expression}}
+  // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
+}
+
+}
+namespace ctor {
+
+consteval int f_eval() { // expected-note+ {{declared here}}
+  return 0;
+}
+
+struct A {
+  int(*ptr)();
+  consteval A(int(*p)() = nullptr) : ptr(p) {}
+};
+
+struct B {
+  int(*ptr)();
+  B() : ptr(nullptr) {}
+  consteval B(int(*p)(), int) : ptr(p) {}
+};
+
+void test() {
+  { A a; }
+  { A a(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { B b(nullptr, 0); }
+  { B b(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { A a{}; }
+  { A a{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { B b{nullptr, 0}; }
+  { B b{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { A a = A(); }
+  { A a = A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { B b = B(nullptr, 0); }
+  { B b = B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { A a = A{}; }
+  { A a = A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { B b = B{nullptr, 0}; }
+  { B b = B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { A a; a = A(); }
+  { A a; a = A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { B b; b = B(nullptr, 0); }
+  { B b; b = B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { A a; a = A{}; }
+  { A a; a = A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { B b; b = B{nullptr, 0}; }
+  { B b; b = B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { A* a; a = new A(); }
+  { A* a; a = new A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { B* b; b = new B(nullptr, 0); }
+  { B* b; b = new B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { A* a; a = new A{}; }
+  { A* a; a = new A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { B* b; b = new B{nullptr, 0}; }
+  { B* b; b = new B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+}
+
+}
+
+namespace copy_ctor {
+
+consteval int f_eval() { // expected-note+ {{declared here}}
+  return 0;
+}
+
+struct Copy {
+  int(*ptr)();
+  constexpr Copy(int(*p)() = nullptr) : ptr(p) {}
+  consteval Copy(const Copy&) = default;
+};
+
+constexpr const Copy &to_lvalue_ref(const Copy &&a) {
+  return a;
+}
+
+void test() {
+  constexpr const Copy C;
+  // there is no the copy constructor call when its argument is a prvalue because of garanteed copy elision.
+  // so we need to test with both prvalue and xvalues.
+  { Copy c(C); }
+  { Copy c((Copy(&f_eval))); }// expected-error {{cannot take address of consteval}}
+  { Copy c(std::move(C)); }
+  { Copy c(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy c(to_lvalue_ref((Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy c(to_lvalue_ref(std::move(C))); }
+  { Copy c(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy c = Copy(C); }
+  { Copy c = Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
+  { Copy c = Copy(std::move(C)); }
+  { Copy c = Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy c = Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy c = Copy(to_lvalue_ref(std::move(C))); }
+  { Copy c = Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy c; c = Copy(C); }
+  { Copy c; c = Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
+  { Copy c; c = Copy(std::move(C)); }
+  { Copy c; c = Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy c; c = Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy c; c = Copy(to_lvalue_ref(std::move(C))); }
+  { Copy c; c = Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy* c; c = new Copy(C); }
+  { Copy* c; c = new Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
+  { Copy* c; c = new Copy(std::move(C)); }
+  { Copy* c; c = new Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy* c; c = new Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
+  { Copy* c; c = new Copy(to_lvalue_ref(std::move(C))); }
+  { Copy* c; c = new Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
 }
+
+} // namespace special_ctor