Mark if a null statement is the result of constexpr folding

[xazax.hun]

Summary

I did not add tests yet because first I wanted to be sure whether this approach is OK.

[rsmith]

Can you say something about why you want to track this?

Perhaps we should just use a null pointer for the not-instantiated arm of an if constexpr instead, rather than tracking a flag on an empty statement that is meaningless for real empty statements.

[xazax.hun]

In D46234#1082307, @rsmith wrote:

Can you say something about why you want to track this?

The original motivation was to fix this false positive in clang tidy: https://reviews.llvm.org/D46027

Perhaps we should just use a null pointer for the not-instantiated arm of an if constexpr instead, rather than tracking a flag on an empty statement that is meaningless for real empty statements.

I will look into that, thanks. I wonder if any of the code assumes that the than branch always present.

[rsmith]

In D46234#1082332, @xazax.hun wrote:

In D46234#1082307, @rsmith wrote:

Perhaps we should just use a null pointer for the not-instantiated arm of an if constexpr instead, rather than tracking a flag on an empty statement that is meaningless for real empty statements.

I will look into that, thanks. I wonder if any of the code assumes that the than branch always present.

I expect some code does. But this is fundamentally a special property of an if constexpr statement, not of an empty statement, so I think it makes most sense that whatever special handling we choose to use for this should live in the IfStmt.

[xazax.hun]

Just a note for anyone willing to pick this up, PR32203 is also related.

[rsmith]

In D46234#1762104, @xazax.hun wrote:

Just a note for anyone willing to pick this up, PR32203 is also related.

Further note: the right approach here would likely be to add a DiscardedStmt class deriving from Stmt that represents a discarded arm of an if constexpr, rather than modeling this as a NullStmt.

include/clang/AST/Stmt.h

class NullStmt : public Stmt {
 
   /// \brief True if the null statement was preceded by an empty macro, e.g:
   /// @code
   ///   #define CALL(x)
   ///   CALL(0);
   /// @endcode
   bool HasLeadingEmptyMacro = false;
 
+  /// \brief True if the null statement was produced by folding a part of the
+  ///        code away, e.g:
+  /// @code
+  ///   if constexpr(0 > 1) { willBeFoldedAway(); }
+  ///   // After constexpr evaluation:
+  ///   if constexpr(0 > 1) ;
+  /// @endcode
+  bool ResultOfConstexprFolding = false;
+
 public:
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
-  NullStmt(SourceLocation L, bool hasLeadingEmptyMacro = false)
+  NullStmt(SourceLocation L, bool hasLeadingEmptyMacro = false,
+           bool resultOfConstexprFolding = false)
       : Stmt(NullStmtClass), SemiLoc(L),
-        HasLeadingEmptyMacro(hasLeadingEmptyMacro) {}
+        HasLeadingEmptyMacro(hasLeadingEmptyMacro),
+        ResultOfConstexprFolding(resultOfConstexprFolding) {}
 
   /// \brief Build an empty null statement.
   explicit NullStmt(EmptyShell Empty) : Stmt(NullStmtClass, Empty) {}
 
   SourceLocation getSemiLoc() const { return SemiLoc; }
   void setSemiLoc(SourceLocation L) { SemiLoc = L; }
 
   bool hasLeadingEmptyMacro() const { return HasLeadingEmptyMacro; }
+  bool resultOfConstexprFolding() const { return ResultOfConstexprFolding; }
 
   SourceLocation getLocStart() const LLVM_READONLY { return SemiLoc; }
   SourceLocation getLocEnd() const LLVM_READONLY { return SemiLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == NullStmtClass;
   }
 

lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
 
   // Transform the "then" branch.
   StmtResult Then;
   if (!ConstexprConditionValue || *ConstexprConditionValue) {
     Then = getDerived().TransformStmt(S->getThen());
     if (Then.isInvalid())
       return StmtError();
   } else {
-    Then = new (getSema().Context) NullStmt(S->getThen()->getLocStart());
+    Then = new (getSema().Context) NullStmt(S->getThen()->getLocStart(),
+                                            /*hasLeadingEmptyMacro=*/false,
+                                            /*resultOfConstexprFolding=*/true);
   }
 
   // Transform the "else" branch.
   StmtResult Else;
   if (!ConstexprConditionValue || !*ConstexprConditionValue) {
     Else = getDerived().TransformStmt(S->getElse());
     if (Else.isInvalid())
       return StmtError();