Merge pull request #60955 from hamishknight/walk-this-way

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));