[ASTWalker] NFC: Rename SkipChildren -> SkipNode

This better describes what the action currently
does, and allows us to re-introduce `SkipChildren`
with the correct behavior.

Author: hamishknight

include/swift/AST/ASTWalker.h

@@ -216,28 +216,27 @@ class ASTWalker {
       return {Continue(), std::move(node)};
     }
 
-    /// Continue the current walk, replacing the current node with \p node.
-    /// However, skip visiting the children of \p node, and instead resume the
-    /// walk of the parent node.
+    /// Skips visiting both the node's children and its post-visitation.
     template <typename T>
-    static _Detail::SkipChildrenIfWalkResult<T> SkipChildren(T node) {
-      return SkipChildrenIf(true, std::move(node));
+    static _Detail::SkipChildrenIfWalkResult<T>
+    SkipNode(T node) {
+      return SkipNodeIf(true, std::move(node));
     }
 
-    /// If \p cond is true, this is equivalent to \c Action::SkipChildren(node).
+    /// If \p cond is true, this is equivalent to \c Action::SkipNode(node).
     /// Otherwise, it is equivalent to \c Action::Continue(node).
     template <typename T>
     static _Detail::SkipChildrenIfWalkResult<T>
-    SkipChildrenIf(bool cond, T node) {
-      return {SkipChildrenIf(cond), std::move(node)};
+    SkipNodeIf(bool cond, T node) {
+      return {SkipNodeIf(cond), std::move(node)};
     }
 
     /// If \p cond is true, this is equivalent to \c Action::Continue(node).
-    /// Otherwise, it is equivalent to \c Action::SkipChildren(node).
+    /// Otherwise, it is equivalent to \c Action::SkipNode(node).
     template <typename T>
     static _Detail::SkipChildrenIfWalkResult<T>
-    VisitChildrenIf(bool cond, T node) {
-      return SkipChildrenIf(!cond, std::move(node));
+    VisitNodeIf(bool cond, T node) {
+      return SkipNodeIf(!cond, std::move(node));
     }
 
     /// If \p cond is true, this is equivalent to \c Action::Stop().
@@ -250,22 +249,23 @@ class ASTWalker {
     /// Continue the current walk.
     static _Detail::ContinueWalkAction Continue() { return {}; }
 
-    /// Continue the current walk, but do not visit the children of the current
-    /// node. Instead, resume at the parent's post-walk.
-    static _Detail::SkipChildrenIfWalkAction SkipChildren() {
-      return SkipChildrenIf(true);
+    /// Skips visiting both the node's children and its post-visitation.
+    static _Detail::SkipChildrenIfWalkAction SkipNode() {
+      return SkipNodeIf(true);
     }
 
-    /// If \p cond is true, this is equivalent to \c Action::SkipChildren().
+    /// If \p cond is true, this is equivalent to \c Action::SkipNode().
     /// Otherwise, it is equivalent to \c Action::Continue().
-    static _Detail::SkipChildrenIfWalkAction SkipChildrenIf(bool cond) {
+    static _Detail::SkipChildrenIfWalkAction
+    SkipNodeIf(bool cond) {
       return {cond};
     }
 
     /// If \p cond is true, this is equivalent to \c Action::Continue().
-    /// Otherwise, it is equivalent to \c Action::SkipChildren().
-    static _Detail::SkipChildrenIfWalkAction VisitChildrenIf(bool cond) {
-      return SkipChildrenIf(!cond);
+    /// Otherwise, it is equivalent to \c Action::SkipNode().
+    static _Detail::SkipChildrenIfWalkAction
+    VisitNodeIf(bool cond) {
+      return SkipNodeIf(!cond);
     }
 
     /// Terminate the walk, returning without visiting any other nodes.
@@ -281,14 +281,14 @@ class ASTWalker {
   /// A pre-visitation action for AST nodes that do not support being replaced
   /// while walking.
   struct PreWalkAction {
-    enum Kind { Stop, SkipChildren, Continue };
+    enum Kind { Stop, SkipNode, Continue };
     Kind Action;
 
     PreWalkAction(_Detail::ContinueWalkAction) : Action(Continue) {}
     PreWalkAction(_Detail::StopWalkAction) : Action(Stop) {}
 
     PreWalkAction(_Detail::SkipChildrenIfWalkAction action)
-        : Action(action.Cond ? SkipChildren : Continue) {}
+        : Action(action.Cond ? SkipNode : Continue) {}
 
     PreWalkAction(_Detail::StopIfWalkAction action)
         : Action(action.Cond ? Stop : Continue) {}

include/swift/Sema/ConstraintSystem.h

@@ -2685,12 +2685,12 @@ class ConstraintSystem {
 
     /// Ignore statements.
     PreWalkResult<Stmt *> walkToStmtPre(Stmt *stmt) override {
-      return Action::SkipChildren(stmt);
+      return Action::SkipNode(stmt);
     }
 
     /// Ignore declarations.
     PreWalkAction walkToDeclPre(Decl *decl) override {
-      return Action::SkipChildren();
+      return Action::SkipNode();
     }
   };
 
@@ -6389,7 +6389,7 @@ class TypeVarRefCollector : public ASTWalker {
   PreWalkAction walkToDeclPre(Decl *D) override {
     // We only need to walk into PatternBindingDecls, other kinds of decls
     // cannot reference outer vars.
-    return Action::VisitChildrenIf(isa<PatternBindingDecl>(D));
+    return Action::VisitNodeIf(isa<PatternBindingDecl>(D));
   }
 
   ArrayRef<TypeVariableType *> getTypeVars() const {

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -2445,10 +2445,10 @@ class ConstExtractor: public ASTWalker {
   PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
     if (E->isSemanticallyConstExpr()) {
       record(E, E);
-      return Action::SkipChildren(E);
+      return Action::SkipNode(E);
     }
     if (handleSimpleReference(E)) {
-      return Action::SkipChildren(E);
+      return Action::SkipNode(E);
     }
     return Action::Continue(E);
   }

lib/AST/ASTScopeCreation.cpp

@@ -115,47 +115,45 @@ class ScopeCreator final : public ASTAllocated<ScopeCreator> {
           scopeCreator
               .constructExpandAndInsert<ClosureParametersScope>(
                   parent, closure);
-          return Action::SkipChildren(E);
+          return Action::SkipNode(E);
         }
         if (auto *capture = dyn_cast<CaptureListExpr>(E)) {
           scopeCreator
               .constructExpandAndInsert<CaptureListScope>(
                   parent, capture);
-          return Action::SkipChildren(E);
+          return Action::SkipNode(E);
         }
 
         // If we have a single value statement expression, we need to add any
         // scopes in the underlying statement.
         if (auto *SVE = dyn_cast<SingleValueStmtExpr>(E)) {
           scopeCreator.addToScopeTree(SVE->getStmt(), parent);
-          return Action::SkipChildren(E);
+          return Action::SkipNode(E);
         }
 
         // If we have a try/try!/try?, we need to add a scope for it
         if (auto anyTry = dyn_cast<AnyTryExpr>(E)) {
           scopeCreator.constructExpandAndInsert<TryScope>(parent, anyTry);
-          return Action::SkipChildren(E);
+          return Action::SkipNode(E);
         }
 
         return Action::Continue(E);
       }
       PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
-        if (isa<BraceStmt>(S)) { // closures hidden in here
-          return Action::Continue(S);
-        }
-        return Action::SkipChildren(S);
+        // Closures can occur in BraceStmts.
+        return Action::VisitNodeIf(isa<BraceStmt>(S), S);
       }
       PreWalkResult<Pattern *> walkToPatternPre(Pattern *P) override {
-        return Action::SkipChildren(P);
+        return Action::SkipNode(P);
       }
       PreWalkAction walkToDeclPre(Decl *D) override {
-        return Action::SkipChildren();
+        return Action::SkipNode();
       }
       PreWalkAction walkToTypeReprPre(TypeRepr *T) override {
-        return Action::SkipChildren();
+        return Action::SkipNode();
       }
       PreWalkAction walkToParameterListPre(ParameterList *PL) override {
-        return Action::SkipChildren();
+        return Action::SkipNode();
       }
 
       MacroWalking getMacroWalkingBehavior() const override {

lib/AST/ASTVerifier.cpp

@@ -125,7 +125,7 @@ ASTWalker::PreWalkResult<Expr *> dispatchVisitPreExprHelper(
     return ASTWalker::Action::Continue(node);
   }
   V.cleanup(node);
-  return ASTWalker::Action::SkipChildren(node);
+  return ASTWalker::Action::SkipNode(node);
 }
 
 template <typename Verifier, typename Kind>
@@ -141,7 +141,7 @@ ASTWalker::PreWalkResult<Expr *> dispatchVisitPreExprHelper(
     return ASTWalker::Action::Continue(node);
   }
   V.cleanup(node);
-  return ASTWalker::Action::SkipChildren(node);
+  return ASTWalker::Action::SkipNode(node);
 }
 
 template <typename Verifier, typename Kind>
@@ -157,7 +157,7 @@ ASTWalker::PreWalkResult<Expr *> dispatchVisitPreExprHelper(
     return ASTWalker::Action::Continue(node);
   }
   V.cleanup(node);
-  return ASTWalker::Action::SkipChildren(node);
+  return ASTWalker::Action::SkipNode(node);
 }
 
 template <typename Verifier, typename Kind>
@@ -170,7 +170,7 @@ ASTWalker::PreWalkResult<Expr *> dispatchVisitPreExprHelper(
     return ASTWalker::Action::Continue(node);
   }
   V.cleanup(node);
-  return ASTWalker::Action::SkipChildren(node);
+  return ASTWalker::Action::SkipNode(node);
 }
 
 namespace {
@@ -401,7 +401,7 @@ class Verifier : public ASTWalker {
       if (shouldVerify(node))
         return Action::Continue();
       cleanup(node);
-      return Action::SkipChildren();
+      return Action::SkipNode();
     }
 
     /// Helper template for dispatching pre-visitation.
@@ -419,7 +419,7 @@ class Verifier : public ASTWalker {
       if (shouldVerify(node))
         return Action::Continue(node);
       cleanup(node);
-      return Action::SkipChildren(node);
+      return Action::SkipNode(node);
     }
 
     /// Helper template for dispatching pre-visitation.
@@ -430,7 +430,7 @@ class Verifier : public ASTWalker {
       if (shouldVerify(node))
         return Action::Continue(node);
       cleanup(node);
-      return Action::SkipChildren(node);
+      return Action::SkipNode(node);
     }
 
     /// Helper template for dispatching post-visitation.

lib/AST/ASTWalker.cpp

@@ -1455,7 +1455,7 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     switch (Pre.Action) {
     case PreWalkAction::Stop:
       return true;
-    case PreWalkAction::SkipChildren:
+    case PreWalkAction::SkipNode:
       return false;
     case PreWalkAction::Continue:
       break;
@@ -1479,7 +1479,7 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     switch (Pre.Action.Action) {
     case PreWalkAction::Stop:
       return nullptr;
-    case PreWalkAction::SkipChildren:
+    case PreWalkAction::SkipNode:
       assert(*Pre.Value && "Use Action::Stop instead of returning nullptr");
       return *Pre.Value;
     case PreWalkAction::Continue:

lib/AST/Decl.cpp

@@ -8645,11 +8645,11 @@ swift::findWrappedValuePlaceholder(Expr *init) {
 
     virtual PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
       if (placeholder)
-        return Action::SkipChildren(E);
+        return Action::SkipNode(E);
 
       if (auto *value = dyn_cast<PropertyWrapperValuePlaceholderExpr>(E)) {
         placeholder = value;
-        return Action::SkipChildren(value);
+        return Action::SkipNode(value);
       }
 
       return Action::Continue(E);
@@ -9548,7 +9548,7 @@ AbstractFunctionDecl::getBodyFingerprintIncludingLocalTypeMembers() const {
 
     PreWalkAction walkToDeclPre(Decl *D) override {
       if (D->isImplicit())
-        return Action::SkipChildren();
+        return Action::SkipNode();
 
       if (auto *idc = dyn_cast<IterableDeclContext>(D)) {
         if (auto fp = idc->getBodyFingerprint())
@@ -9559,7 +9559,7 @@ AbstractFunctionDecl::getBodyFingerprintIncludingLocalTypeMembers() const {
         for (auto *d : idc->getParsedMembers())
           const_cast<Decl *>(d)->walk(*this);
 
-        return Action::SkipChildren();
+        return Action::SkipNode();
       }
 
       if (auto *afd = dyn_cast<AbstractFunctionDecl>(D)) {

lib/AST/Expr.cpp

@@ -516,21 +516,21 @@ forEachImmediateChildExpr(llvm::function_ref<Expr *(Expr *)> callback) {
 
       // We're only interested in the immediate children, so don't walk any
       // further.
-      return Action::SkipChildren(E);
+      return Action::SkipNode(E);
     }
 
     PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
-      return Action::SkipChildren(S);
+      return Action::SkipNode(S);
     }
 
     PreWalkResult<Pattern *> walkToPatternPre(Pattern *P) override {
-      return Action::SkipChildren(P);
+      return Action::SkipNode(P);
     }
     PreWalkAction walkToDeclPre(Decl *D) override {
-      return Action::SkipChildren();
+      return Action::SkipNode();
     }
     PreWalkAction walkToTypeReprPre(TypeRepr *T) override {
-      return Action::SkipChildren();
+      return Action::SkipNode();
     }
   };
 
@@ -562,17 +562,17 @@ void Expr::forEachChildExpr(llvm::function_ref<Expr *(Expr *)> callback) {
     }
 
     PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
-      return Action::SkipChildren(S);
+      return Action::SkipNode(S);
     }
 
     PreWalkResult<Pattern *> walkToPatternPre(Pattern *P) override {
-      return Action::SkipChildren(P);
+      return Action::SkipNode(P);
     }
     PreWalkAction walkToDeclPre(Decl *D) override {
-      return Action::SkipChildren();
+      return Action::SkipNode();
     }
     PreWalkAction walkToTypeReprPre(TypeRepr *T) override {
-      return Action::SkipChildren();
+      return Action::SkipNode();
     }
   };
 

lib/AST/InlinableText.cpp

@@ -69,7 +69,7 @@ class IsFeatureCheck : public ASTWalker {
       }
     }
 
-    return Action::SkipChildrenIf(foundFeature, expr);
+    return Action::SkipNodeIf(foundFeature, expr);
   }
 };
 
@@ -145,13 +145,13 @@ struct ExtractInactiveRanges : public ASTWalker {
     // If there's no active clause, add the entire #if...#endif block.
     if (!clause) {
       addRange(start, end);
-      return Action::SkipChildren();
+      return Action::SkipNode();
     }
 
     // If the clause is checking for a particular feature with $ or a compiler
     // version, keep the whole thing.
     if (anyClauseIsFeatureCheck(icd->getClauses())) {
-      return Action::SkipChildren();
+      return Action::SkipNode();
     }
 
     // Ignore range from beginning of '#if', '#elseif', or '#else' to the
@@ -174,7 +174,7 @@ struct ExtractInactiveRanges : public ASTWalker {
       if (elt.isDecl(DeclKind::IfConfig))
         elt.get<Decl *>()->walk(*this);
 
-    return Action::SkipChildren();
+    return Action::SkipNode();
   }
 
   /// Gets the ignored ranges in source order.