[AST] Introduce explicit actions for ASTWalker

Replace the use of bool and pointer returns for
`walkToXXXPre`/`walkToXXXPost`, and instead use
explicit actions such as `Action::Continue(E)`,
`Action::SkipChildren(E)`, and `Action::Stop()`.
There are also conditional variants, e.g
`Action::SkipChildrenIf`, `Action::VisitChildrenIf`,
and `Action::StopIf`.

There is still more work that can be done here, in
particular:

- SourceEntityWalker still needs to be migrated.
- Some uses of `return false` in pre-visitation
methods can likely now be replaced by
`Action::Stop`.
- We still use bool and pointer returns internally
within the ASTWalker traversal, which could likely
be improved.

But I'm leaving those as future work for now as
this patch is already large enough.

Author: hamishknight

include/swift/AST/ASTWalker.h

@@ -66,7 +66,8 @@ class TypeReprIdentFinder : public ASTWalker {
   /// The function to call when a ComponentIdentTypeRepr is seen.
   llvm::function_ref<bool(const ComponentIdentTypeRepr *)> Callback;
 
-  bool walkToTypeReprPost(TypeRepr *TR) override;
+  PostWalkAction walkToTypeReprPost(TypeRepr *TR) override;
+
 public:
   explicit TypeReprIdentFinder(
       llvm::function_ref<bool(const ComponentIdentTypeRepr *)> callback)

include/swift/AST/TypeDeclFinder.h

@@ -54,6 +54,7 @@ namespace swift {
 /// call will *not* receive a \c walkTo*Post call.
 /// If \c walkTo*Post returns \c true, the traversal continues.
 class SourceEntityWalker {
+  // TODO: Switch to using explicit ASTWalker actions.
 public:
   /// Walks the provided source file.
   /// \returns true if traversal was aborted, false otherwise.

include/swift/IDE/SourceEntityWalker.h

@@ -284,18 +284,18 @@ class NameMatcher: public ASTWalker {
   bool handleCustomAttrs(Decl *D);
   ArgumentList *getApplicableArgsFor(Expr* E);
 
-  std::pair<bool, Expr*> walkToExprPre(Expr *E) override;
-  Expr* walkToExprPost(Expr *E) override;
-  bool walkToDeclPre(Decl *D) override;
-  bool walkToDeclPost(Decl *D) override;
-  std::pair<bool, Stmt*> walkToStmtPre(Stmt *S) override;
-  Stmt* walkToStmtPost(Stmt *S) override;
-  bool walkToTypeReprPre(TypeRepr *T) override;
-  bool walkToTypeReprPost(TypeRepr *T) override;
-  std::pair<bool, Pattern*> walkToPatternPre(Pattern *P) override;
+  PreWalkResult<Expr *> walkToExprPre(Expr *E) override;
+  PostWalkResult<Expr *> walkToExprPost(Expr *E) override;
+  PreWalkAction walkToDeclPre(Decl *D) override;
+  PostWalkAction walkToDeclPost(Decl *D) override;
+  PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override;
+  PostWalkResult<Stmt *> walkToStmtPost(Stmt *S) override;
+  PreWalkAction walkToTypeReprPre(TypeRepr *T) override;
+  PostWalkAction walkToTypeReprPost(TypeRepr *T) override;
+  PreWalkResult<Pattern *> walkToPatternPre(Pattern *P) override;
   bool shouldWalkIntoGenericParams() override { return true; }
 
-  std::pair<bool, ArgumentList *>
+  PreWalkResult<ArgumentList *>
   walkToArgumentListPre(ArgumentList *ArgList) override;
 
   // FIXME: Remove this

include/swift/IDE/Utils.h

@@ -64,9 +64,9 @@ class CompletionContextFinder : public ASTWalker {
     InitialDC->walkContext(*this);
   }
 
-  std::pair<bool, Expr *> walkToExprPre(Expr *E) override;
+  PreWalkResult<Expr *> walkToExprPre(Expr *E) override;
 
-  Expr *walkToExprPost(Expr *E) override;
+  PostWalkResult<Expr *> walkToExprPost(Expr *E) override;
 
   /// Check whether code completion expression is located inside of a
   /// multi-statement closure.

include/swift/Sema/CompletionContextFinder.h

@@ -3307,10 +3307,10 @@ class ConstraintSystem {
     CacheExprTypes(Expr *expr, ConstraintSystem &cs, bool excludeRoot)
         : RootExpr(expr), CS(cs), ExcludeRoot(excludeRoot) {}
 
-    Expr *walkToExprPost(Expr *expr) override {
+    PostWalkResult<Expr *> walkToExprPost(Expr *expr) override {
       if (ExcludeRoot && expr == RootExpr) {
         assert(!expr->getType() && "Unexpected type in root of expression!");
-        return expr;
+        return Action::Continue(expr);
       }
 
       if (expr->getType())
@@ -3321,16 +3321,18 @@ class ConstraintSystem {
           if (kp->getComponents()[i].getComponentType())
             CS.cacheType(kp, i);
 
-      return expr;
+      return Action::Continue(expr);
     }
 
     /// Ignore statements.
-    std::pair<bool, Stmt *> walkToStmtPre(Stmt *stmt) override {
-      return { false, stmt };
+    PreWalkResult<Stmt *> walkToStmtPre(Stmt *stmt) override {
+      return Action::SkipChildren(stmt);
     }
 
     /// Ignore declarations.
-    bool walkToDeclPre(Decl *decl) override { return false; }
+    PreWalkAction walkToDeclPre(Decl *decl) override {
+      return Action::SkipChildren();
+    }
   };
 
 public:
@@ -6751,7 +6753,7 @@ class OverloadSetCounter : public ASTWalker {
   : NumOverloads(overloads)
   {}
 
-  std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
+  PreWalkResult<Expr *> walkToExprPre(Expr *expr) override {
     if (auto applyExpr = dyn_cast<ApplyExpr>(expr)) {
       // If we've found function application and it's
       // function is an overload set, count it.
@@ -6760,7 +6762,7 @@ class OverloadSetCounter : public ASTWalker {
     }
 
     // Always recur into the children.
-    return { true, expr };
+    return Action::Continue(expr);
   }
 };
 

include/swift/Sema/ConstraintSystem.h

@@ -2387,16 +2387,17 @@ class ConstExtractor: public ASTWalker {
     }
     return false;
   }
-  std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
+  PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
     if (E->isSemanticallyConstExpr()) {
       record(E, E);
-      return { false, E };
+      return Action::SkipChildren(E);
     }
     if (handleSimpleReference(E)) {
-      return { false, E };
+      return Action::SkipChildren(E);
     }
-    return { true, E };
+    return Action::Continue(E);
   }
+
 public:
   ConstExtractor(SDKContext &SCtx, ASTContext &Ctx): SCtx(SCtx),
     SM(Ctx.SourceMgr) {}

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -108,33 +108,39 @@ class ScopeCreator final : public ASTAllocated<ScopeCreator> {
       ClosureFinder(ScopeCreator &scopeCreator, ASTScopeImpl *parent)
           : scopeCreator(scopeCreator), parent(parent) {}
 
-      std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
+      PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
         if (auto *closure = dyn_cast<ClosureExpr>(E)) {
           scopeCreator
               .constructExpandAndInsert<ClosureParametersScope>(
                   parent, closure);
-          return {false, E};
+          return Action::SkipChildren(E);
         }
         if (auto *capture = dyn_cast<CaptureListExpr>(E)) {
           scopeCreator
               .constructExpandAndInsert<CaptureListScope>(
                   parent, capture);
-          return {false, E};
+          return Action::SkipChildren(E);
         }
-        return {true, E};
+        return Action::Continue(E);
       }
-      std::pair<bool, Stmt *> walkToStmtPre(Stmt *S) override {
+      PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
         if (isa<BraceStmt>(S)) { // closures hidden in here
-          return {true, S};
+          return Action::Continue(S);
         }
-        return {false, S};
+        return Action::SkipChildren(S);
       }
-      std::pair<bool, Pattern *> walkToPatternPre(Pattern *P) override {
-        return {false, P};
+      PreWalkResult<Pattern *> walkToPatternPre(Pattern *P) override {
+        return Action::SkipChildren(P);
+      }
+      PreWalkAction walkToDeclPre(Decl *D) override {
+        return Action::SkipChildren();
+      }
+      PreWalkAction walkToTypeReprPre(TypeRepr *T) override {
+        return Action::SkipChildren();
+      }
+      PreWalkAction walkToParameterListPre(ParameterList *PL) override {
+        return Action::SkipChildren();
       }
-      bool walkToDeclPre(Decl *D) override { return false; }
-      bool walkToTypeReprPre(TypeRepr *T) override { return false; }
-      bool walkToParameterListPre(ParameterList *PL) override { return false; }
     };
 
     expr->walk(ClosureFinder(*this, parent));