Add const children() accessors to all AST nodes.

[nicolas]

Summary

Add const children() accessors to all AST nodes.
Previously, only Exprs had const accessors.

[riccibruno]

+1. I wanted to do this but never bothered. Did you go over all the statements on Stmt.h systematically ? You could also do the same thing for all of the statements/expressions in StmtCXX.h, Expr.h, ExprCXX.h, and so on. Apart from this did you run clang-format on the patch ?

[nicolas]

In D60029#1448938, @riccibruno wrote:

Did you go over all the statements on Stmt.h systematically ?

Yes.

You could also do the same thing for all of the statements/expressions in StmtCXX.h, Expr.h, ExprCXX.h, and so on.

I will go over those soon. I believe that Expr.h is mostly done.

Apart from this did you run clang-format on the patch ?

I tried to stick to the style of the non-const functions, even when it was wrong. I will clang-format the next patch!

[riccibruno]

In D60029#1448944, @nicolas wrote:

In D60029#1448938, @riccibruno wrote:

Did you go over all the statements on Stmt.h systematically ?

Yes.

You could also do the same thing for all of the statements/expressions in StmtCXX.h, Expr.h, ExprCXX.h, and so on.

I will go over those soon. I believe that Expr.h is mostly done.

Apart from this did you run clang-format on the patch ?

I tried to stick to the style of the non-const functions, even when it was wrong. I will clang-format the next patch!

Ah I see. Yeah I know that a fair amount of code is not formatted unfortunately.

[nicolas]

Added children() const to all AST nodes.

[nicolas]

Ping

[riccibruno]

Sorry for the delay. Thanks a lot for the patch!

Some of these casts are rather questionable. However this has nothing to do with your patch since you are just adding the const-qualified version of children(). Therefore I believe this patch looks good. Do you want me to commit it for you ?

[nicolas]

Yes, thank you very much!

clang/include/clang/AST/Stmt.h

public:
   }
 
   // Iterators over subexpressions.
   child_range children() {
     return child_range(child_iterator(DG.begin(), DG.end()),
                        child_iterator(DG.end(), DG.end()));
   }
 
+  const_child_range children() const {
+    auto Children = const_cast<DeclStmt *>(this)->children();
+    return const_child_range(Children.begin(), Children.end());
+  }
+
   using decl_iterator = DeclGroupRef::iterator;
   using const_decl_iterator = DeclGroupRef::const_iterator;
   using decl_range = llvm::iterator_range<decl_iterator>;
   using decl_const_range = llvm::iterator_range<const_decl_iterator>;
 
   decl_range decls() { return decl_range(decl_begin(), decl_end()); }
 
   decl_const_range decls() const {
public:
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == NullStmtClass;
   }
 
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
 };
 
 /// CompoundStmt - This represents a group of statements like { stmt stmt }.
 class CompoundStmt final : public Stmt,
                            private llvm::TrailingObjects<CompoundStmt, Stmt *> {
   friend class ASTStmtReader;
   friend TrailingObjects;
 
public:
   }
 
   // Iterators
   child_range children() {
     return child_range(getTrailingObjects<Stmt *>(),
                        getTrailingObjects<Stmt *>() +
                            numTrailingObjects(OverloadToken<Stmt *>()));
   }
+
+  const_child_range children() const {
+    return const_child_range(getTrailingObjects<Stmt *>(),
+                             getTrailingObjects<Stmt *>() +
+                                 numTrailingObjects(OverloadToken<Stmt *>()));
+  }
 };
 
 class DefaultStmt : public SwitchCase {
   Stmt *SubStmt;
 
 public:
   DefaultStmt(SourceLocation DL, SourceLocation CL, Stmt *substmt)
       : SwitchCase(DefaultStmtClass, DL, CL), SubStmt(substmt) {}
public:
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == DefaultStmtClass;
   }
 
   // Iterators
   child_range children() { return child_range(&SubStmt, &SubStmt + 1); }
+
+  const_child_range children() const {
+    return const_child_range(&SubStmt, &SubStmt + 1);
+  }
 };
 
 SourceLocation SwitchCase::getEndLoc() const {
   if (const auto *CS = dyn_cast<CaseStmt>(this))
     return CS->getEndLoc();
   else if (const auto *DS = dyn_cast<DefaultStmt>(this))
     return DS->getEndLoc();
   llvm_unreachable("SwitchCase is neither a CaseStmt nor a DefaultStmt!");
public:
   const Stmt *getSubStmt() const { return SubStmt; }
   void setSubStmt(Stmt *SS) { SubStmt = SS; }
 
   SourceLocation getBeginLoc() const { return getIdentLoc(); }
   SourceLocation getEndLoc() const LLVM_READONLY { return SubStmt->getEndLoc();}
 
   child_range children() { return child_range(&SubStmt, &SubStmt + 1); }
 
+  const_child_range children() const {
+    return const_child_range(&SubStmt, &SubStmt + 1);
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == LabelStmtClass;
   }
 };
 
 /// Represents an attribute applied to a statement.
 ///
 /// Represents an attribute applied to a statement. For example:
public:
   Stmt *getSubStmt() { return SubStmt; }
   const Stmt *getSubStmt() const { return SubStmt; }
 
   SourceLocation getBeginLoc() const { return getAttrLoc(); }
   SourceLocation getEndLoc() const LLVM_READONLY { return SubStmt->getEndLoc();}
 
   child_range children() { return child_range(&SubStmt, &SubStmt + 1); }
 
+  const_child_range children() const {
+    return const_child_range(&SubStmt, &SubStmt + 1);
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == AttributedStmtClass;
   }
 };
 
 /// IfStmt - This represents an if/then/else.
 class IfStmt final
     : public Stmt,
public:
   // Iterators over subexpressions.  The iterators will include iterating
   // over the initialization expression referenced by the condition variable.
   child_range children() {
     return child_range(getTrailingObjects<Stmt *>(),
                        getTrailingObjects<Stmt *>() +
                            numTrailingObjects(OverloadToken<Stmt *>()));
   }
 
+  const_child_range children() const {
+    return const_child_range(getTrailingObjects<Stmt *>(),
+                             getTrailingObjects<Stmt *>() +
+                                 numTrailingObjects(OverloadToken<Stmt *>()));
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == IfStmtClass;
   }
 };
 
 /// SwitchStmt - This represents a 'switch' stmt.
 class SwitchStmt final : public Stmt,
                          private llvm::TrailingObjects<SwitchStmt, Stmt *> {
public:
 
   // Iterators
   child_range children() {
     return child_range(getTrailingObjects<Stmt *>(),
                        getTrailingObjects<Stmt *>() +
                            numTrailingObjects(OverloadToken<Stmt *>()));
   }
 
+  const_child_range children() const {
+    return const_child_range(getTrailingObjects<Stmt *>(),
+                       getTrailingObjects<Stmt *>() +
+                           numTrailingObjects(OverloadToken<Stmt *>()));
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SwitchStmtClass;
   }
 };
 
 /// WhileStmt - This represents a 'while' stmt.
 class WhileStmt final : public Stmt,
                         private llvm::TrailingObjects<WhileStmt, Stmt *> {
public:
   }
 
   // Iterators
   child_range children() {
     return child_range(getTrailingObjects<Stmt *>(),
                        getTrailingObjects<Stmt *>() +
                            numTrailingObjects(OverloadToken<Stmt *>()));
   }
+
+  const_child_range children() const {
+    return const_child_range(getTrailingObjects<Stmt *>(),
+                             getTrailingObjects<Stmt *>() +
+                                 numTrailingObjects(OverloadToken<Stmt *>()));
+  }
 };
 
 /// DoStmt - This represents a 'do/while' stmt.
 class DoStmt : public Stmt {
   enum { BODY, COND, END_EXPR };
   Stmt *SubExprs[END_EXPR];
   SourceLocation WhileLoc;
   SourceLocation RParenLoc; // Location of final ')' in do stmt condition.
public:
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == DoStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
   }
+
+  const_child_range children() const {
+    return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
+  }
 };
 
 /// ForStmt - This represents a 'for (init;cond;inc)' stmt.  Note that any of
 /// the init/cond/inc parts of the ForStmt will be null if they were not
 /// specified in the source.
 class ForStmt : public Stmt {
   enum { INIT, CONDVAR, COND, INC, BODY, END_EXPR };
   Stmt* SubExprs[END_EXPR]; // SubExprs[INIT] is an expression or declstmt.
public:
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ForStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
   }
+
+  const_child_range children() const {
+    return const_child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
+  }
 };
 
 /// GotoStmt - This represents a direct goto.
 class GotoStmt : public Stmt {
   LabelDecl *Label;
   SourceLocation LabelLoc;
 
 public:
public:
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == GotoStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
 };
 
 /// IndirectGotoStmt - This represents an indirect goto.
 class IndirectGotoStmt : public Stmt {
   SourceLocation StarLoc;
   Stmt *Target;
 
 public:
public:
   SourceLocation getEndLoc() const LLVM_READONLY { return Target->getEndLoc(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == IndirectGotoStmtClass;
   }
 
   // Iterators
   child_range children() { return child_range(&Target, &Target + 1); }
+
+  const_child_range children() const { return const_child_range(&Target, &Target + 1); }
 };
 
 /// ContinueStmt - This represents a continue.
 class ContinueStmt : public Stmt {
 public:
   ContinueStmt(SourceLocation CL) : Stmt(ContinueStmtClass) {
     setContinueLoc(CL);
   }
public:
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ContinueStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
 };
 
 /// BreakStmt - This represents a break.
 class BreakStmt : public Stmt {
 public:
   BreakStmt(SourceLocation BL) : Stmt(BreakStmtClass) {
     setBreakLoc(BL);
   }
public:
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == BreakStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
 };
 
 /// ReturnStmt - This represents a return, optionally of an expression:
 ///   return;
 ///   return 4;
 ///
 /// Note that GCC allows return with no argument in a function declared to
 /// return a value, and it allows returning a value in functions declared to
public:
   }
 
   // Iterators
   child_range children() {
     if (RetExpr)
       return child_range(&RetExpr, &RetExpr + 1);
     return child_range(child_iterator(), child_iterator());
   }
+
+  const_child_range children() const {
+    if (RetExpr)
+      return const_child_range(&RetExpr, &RetExpr + 1);
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
 };
 
 /// AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
 class AsmStmt : public Stmt {
 protected:
   friend class ASTStmtReader;
 
   SourceLocation AsmLoc;
public:
 
   outputs_const_range outputs() const {
     return outputs_const_range(begin_outputs(), end_outputs());
   }
 
   child_range children() {
     return child_range(&Exprs[0], &Exprs[0] + NumOutputs + NumInputs);
   }
+
+  const_child_range children() const {
+    return const_child_range(&Exprs[0], &Exprs[0] + NumOutputs + NumInputs);
+  }
 };
 
 /// This represents a GCC inline-assembly statement extension.
 class GCCAsmStmt : public AsmStmt {
   friend class ASTStmtReader;
 
   SourceLocation RParenLoc;
   StringLiteral *AsmStr;
public:
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == MSAsmStmtClass;
   }
 
   child_range children() {
     return child_range(&Exprs[0], &Exprs[NumInputs + NumOutputs]);
   }
+
+  const_child_range children() const {
+    return const_child_range(&Exprs[0], &Exprs[NumInputs + NumOutputs]);
+  }
 };
 
 class SEHExceptStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
 
   SourceLocation  Loc;
   Stmt *Children[2];
public:
   CompoundStmt *getBlock() const {
     return cast<CompoundStmt>(Children[BLOCK]);
   }
 
   child_range children() {
     return child_range(Children, Children+2);
   }
 
+  const_child_range children() const {
+    return const_child_range(Children, Children+2);
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHExceptStmtClass;
   }
 };
 
 class SEHFinallyStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
public:
   SourceLocation getEndLoc() const { return Block->getEndLoc(); }
 
   CompoundStmt *getBlock() const { return cast<CompoundStmt>(Block); }
 
   child_range children() {
     return child_range(&Block,&Block+1);
   }
 
+  const_child_range children() const {
+    return const_child_range(&Block, &Block+1);
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHFinallyStmtClass;
   }
 };
 
 class SEHTryStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
public:
   /// Returns 0 if not defined
   SEHExceptStmt  *getExceptHandler() const;
   SEHFinallyStmt *getFinallyHandler() const;
 
   child_range children() {
     return child_range(Children, Children+2);
   }
 
+  const_child_range children() const {
+    return const_child_range(Children, Children+2);
+  }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHTryStmtClass;
   }
 };
 
 /// Represents a __leave statement.
 class SEHLeaveStmt : public Stmt {
   SourceLocation LeaveLoc;
public:
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHLeaveStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
 };
 
 /// This captures a statement into a function. For example, the following
 /// pragma annotated compound statement can be represented as a CapturedStmt,
 /// and this compound statement is the body of an anonymous outlined function.
 /// @code
 /// #pragma omp parallel
 /// {
SourceRange getSourceRange() const LLVM_READONLY {
     return getCapturedStmt()->getSourceRange();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CapturedStmtClass;
   }
 
   child_range children();
+
+  const_child_range children() const;
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_STMT_H

clang/lib/AST/Stmt.cpp

CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context,
   return new (Mem) CapturedStmt(EmptyShell(), NumCaptures);
 }
 
 Stmt::child_range CapturedStmt::children() {
   // Children are captured field initializers.
   return child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
 }
 
+Stmt::const_child_range CapturedStmt::children() const {
+  return const_child_range(getStoredStmts(), getStoredStmts() + NumCaptures);
+}
+
 CapturedDecl *CapturedStmt::getCapturedDecl() {
   return CapDeclAndKind.getPointer();
 }
 
 const CapturedDecl *CapturedStmt::getCapturedDecl() const {
   return CapDeclAndKind.getPointer();
 }