refactor(visit): Reduce expanded LOCs (#7442)

**Description:**

x-ref: https://vercel.slack.com/archives/C03EWR7LGEN/p1684898884673379

**Related issue:**

 - web-infra-dev/rspack#3058.

Author: kdy1

crates/swc_ecma_utils/Cargo.toml

@@ -8,9 +8,9 @@ name          = "swc_ecma_utils"
 repository    = "https://github.com/swc-project/swc.git"
 version       = "0.117.10"
 
-    [package.metadata.docs.rs]
-    all-features = true
-    rustdoc-args = ["--cfg", "docsrs"]
+  [package.metadata.docs.rs]
+  all-features = true
+  rustdoc-args = ["--cfg", "docsrs"]
 
 [lib]
 bench = false

crates/swc_visit/src/lib.rs

@@ -92,6 +92,8 @@
 //! `VisitMutAstPath` and `FoldAstPath` can be used to transform AST nodes with
 //! the path to the node.
 
+use std::ops::{Deref, DerefMut};
+
 pub use either::Either;
 pub use swc_visit_macros::define;
 
@@ -251,13 +253,27 @@ where
         Self { path }
     }
 
+    pub fn with_guard(&mut self, kind: K) -> AstKindPathGuard<K> {
+        self.path.push(kind);
+
+        AstKindPathGuard { path: self }
+    }
+
+    pub fn with_index_guard(&mut self, index: usize) -> AstKindPathIndexGuard<K> {
+        self.path.last_mut().unwrap().set_index(index);
+
+        AstKindPathIndexGuard { path: self }
+    }
+
+    #[deprecated = "Use with_guard instead"]
     pub fn with<Ret>(&mut self, path: K, op: impl FnOnce(&mut Self) -> Ret) -> Ret {
         self.path.push(path);
         let ret = op(self);
         self.path.pop();
         ret
     }
 
+    #[deprecated = "Use with_index_guard instead"]
     pub fn with_index<Ret>(&mut self, index: usize, op: impl FnOnce(&mut Self) -> Ret) -> Ret {
         self.path.last_mut().unwrap().set_index(index);
         let res = op(self);
@@ -266,6 +282,82 @@ where
     }
 }
 
+pub struct AstKindPathGuard<'a, K>
+where
+    K: ParentKind,
+{
+    path: &'a mut AstKindPath<K>,
+}
+
+impl<K> Deref for AstKindPathGuard<'_, K>
+where
+    K: ParentKind,
+{
+    type Target = AstKindPath<K>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.path
+    }
+}
+
+impl<K> DerefMut for AstKindPathGuard<'_, K>
+where
+    K: ParentKind,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.path
+    }
+}
+
+impl<K> Drop for AstKindPathGuard<'_, K>
+where
+    K: ParentKind,
+{
+    fn drop(&mut self) {
+        self.path.path.pop();
+    }
+}
+
+pub struct AstKindPathIndexGuard<'a, K>
+where
+    K: ParentKind,
+{
+    path: &'a mut AstKindPath<K>,
+}
+
+impl<K> Deref for AstKindPathIndexGuard<'_, K>
+where
+    K: ParentKind,
+{
+    type Target = AstKindPath<K>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.path
+    }
+}
+
+impl<K> DerefMut for AstKindPathIndexGuard<'_, K>
+where
+    K: ParentKind,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.path
+    }
+}
+
+impl<K> Drop for AstKindPathIndexGuard<'_, K>
+where
+    K: ParentKind,
+{
+    fn drop(&mut self) {
+        self.path.path.last_mut().unwrap().set_index(usize::MAX);
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AstNodePath<N>
 where
@@ -310,6 +402,21 @@ where
         &self.kinds
     }
 
+    pub fn with_guard(&mut self, node: N) -> AstNodePathGuard<N> {
+        self.kinds.path.push(node.kind());
+        self.path.push(node);
+
+        AstNodePathGuard { path: self }
+    }
+
+    pub fn with_index_guard(&mut self, index: usize) -> AstNodePathIndexGuard<N> {
+        self.kinds.path.last_mut().unwrap().set_index(index);
+        self.path.last_mut().unwrap().set_index(index);
+
+        AstNodePathIndexGuard { path: self }
+    }
+
+    #[deprecated = "Use with_guard instead"]
     pub fn with<F, Ret>(&mut self, node: N, op: F) -> Ret
     where
         F: for<'aa> FnOnce(&'aa mut AstNodePath<N>) -> Ret,
@@ -325,6 +432,7 @@ where
         ret
     }
 
+    #[deprecated = "Use with_index_guard instead"]
     pub fn with_index<F, Ret>(&mut self, index: usize, op: F) -> Ret
     where
         F: for<'aa> FnOnce(&'aa mut AstNodePath<N>) -> Ret,
@@ -351,3 +459,86 @@ pub trait NodeRef: Copy {
 pub trait ParentKind: Copy {
     fn set_index(&mut self, index: usize);
 }
+
+pub struct AstNodePathGuard<'a, N>
+where
+    N: NodeRef,
+{
+    path: &'a mut AstNodePath<N>,
+}
+
+impl<N> Deref for AstNodePathGuard<'_, N>
+where
+    N: NodeRef,
+{
+    type Target = AstNodePath<N>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.path
+    }
+}
+
+impl<N> DerefMut for AstNodePathGuard<'_, N>
+where
+    N: NodeRef,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.path
+    }
+}
+
+impl<N> Drop for AstNodePathGuard<'_, N>
+where
+    N: NodeRef,
+{
+    fn drop(&mut self) {
+        self.path.path.pop();
+        self.path.kinds.path.pop();
+    }
+}
+
+pub struct AstNodePathIndexGuard<'a, N>
+where
+    N: NodeRef,
+{
+    path: &'a mut AstNodePath<N>,
+}
+
+impl<N> Deref for AstNodePathIndexGuard<'_, N>
+where
+    N: NodeRef,
+{
+    type Target = AstNodePath<N>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.path
+    }
+}
+
+impl<N> DerefMut for AstNodePathIndexGuard<'_, N>
+where
+    N: NodeRef,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.path
+    }
+}
+
+impl<N> Drop for AstNodePathIndexGuard<'_, N>
+where
+    N: NodeRef,
+{
+    fn drop(&mut self) {
+        self.path.path.last_mut().unwrap().set_index(usize::MAX);
+        self.path
+            .kinds
+            .path
+            .last_mut()
+            .unwrap()
+            .set_index(usize::MAX);
+    }
+}

crates/swc_visit_macros/src/lib.rs

@@ -2249,9 +2249,10 @@ fn visit_expr(
                         ast_path_expr,
                     },
                     {
-                        __ast_path.with(ast_path_expr, |__ast_path| {
-                            visitor.visit_name(expr, __ast_path)
-                        })
+                        {
+                            let mut __ast_path = __ast_path.with_guard(ast_path_expr);
+                            visitor.visit_name(expr, &mut *__ast_path)
+                        }
                     }
                 )
                 .parse()
@@ -2983,10 +2984,11 @@ fn create_method_body(mode: Mode, ty: &Type) -> Block {
                                             n.into_iter()
                                                 .enumerate()
                                                 .map(|(idx, v)| {
-                                                    __ast_path.with_index(idx, |__ast_path| {
-                                                        swc_visit::util::map::Map::map(v, |v| {
-                                                            _visitor.ident(v, __ast_path)
-                                                        })
+                                                    let mut __ast_path =
+                                                        __ast_path.with_index_guard(idx);
+
+                                                    swc_visit::util::map::Map::map(v, |v| {
+                                                        _visitor.ident(v, &mut *__ast_path)
                                                     })
                                                 })
                                                 .collect()
@@ -3017,9 +3019,9 @@ fn create_method_body(mode: Mode, ty: &Type) -> Block {
                                     n.into_iter()
                                         .enumerate()
                                         .map(|(idx, v)| {
-                                            __ast_path.with_index(idx, |__ast_path| {
-                                                _visitor.ident(v, __ast_path)
-                                            })
+                                            let mut __ast_path = __ast_path.with_index_guard(idx);
+
+                                            _visitor.ident(v, &mut *__ast_path)
                                         })
                                         .collect()
                                 })
@@ -3036,9 +3038,9 @@ fn create_method_body(mode: Mode, ty: &Type) -> Block {
                                 Vars { ident },
                                 ({
                                     n.iter_mut().enumerate().for_each(|(idx, v)| {
-                                        __ast_path.with_index(idx, |__ast_path| {
-                                            _visitor.ident(v, __ast_path)
-                                        })
+                                        let mut __ast_path = __ast_path.with_index_guard(idx);
+
+                                        _visitor.ident(v, &mut *__ast_path)
                                     })
                                 })
                             )
@@ -3054,9 +3056,9 @@ fn create_method_body(mode: Mode, ty: &Type) -> Block {
                                 Vars { ident },
                                 ({
                                     n.iter().enumerate().for_each(|(idx, v)| {
-                                        __ast_path.with_index(idx, |__ast_path| {
-                                            _visitor.ident(v.as_ref(), __ast_path)
-                                        })
+                                        let mut __ast_path = __ast_path.with_index_guard(idx);
+
+                                        _visitor.ident(v.as_ref(), &mut *__ast_path)
                                     })
                                 })
                             )
@@ -3080,9 +3082,8 @@ fn create_method_body(mode: Mode, ty: &Type) -> Block {
                                     n.into_iter()
                                         .enumerate()
                                         .map(|(idx, v)| {
-                                            __ast_path.with_index(idx, |__ast_path| {
-                                                _visitor.ident(v, __ast_path)
-                                            })
+                                            let mut __ast_path = __ast_path.with_index_guard(idx);
+                                            _visitor.ident(v, &mut *__ast_path)
                                         })
                                         .collect()
                                 })
@@ -3099,9 +3100,9 @@ fn create_method_body(mode: Mode, ty: &Type) -> Block {
                                 Vars { ident },
                                 ({
                                     n.iter_mut().enumerate().for_each(|(idx, v)| {
-                                        __ast_path.with_index(idx, |__ast_path| {
-                                            _visitor.ident(v, __ast_path)
-                                        })
+                                        let mut __ast_path = __ast_path.with_index_guard(idx);
+
+                                        _visitor.ident(v, &mut *__ast_path)
                                     })
                                 })
                             )
@@ -3117,9 +3118,9 @@ fn create_method_body(mode: Mode, ty: &Type) -> Block {
                                 Vars { ident },
                                 ({
                                     n.iter().enumerate().for_each(|(idx, v)| {
-                                        __ast_path.with_index(idx, |__ast_path| {
-                                            _visitor.ident(v, __ast_path)
-                                        })
+                                        let mut __ast_path = __ast_path.with_index_guard(idx);
+
+                                        _visitor.ident(v, &mut *__ast_path)
                                     })
                                 })
                             )