feat(es/visit): Introduce core-only visitors (#10049)

**Description:**

These types will be used by core transforms.

Author: kdy1

Cargo.lock

@@ -0,0 +1,33 @@
+[package]
+authors       = ["강동윤 <kdy1997.dev@gmail.com>"]
+description   = "Visitors for swc ecmascript nodes which works on stable rustc"
+documentation = "https://rustdoc.swc.rs/swc_ecma_visit_std/"
+edition       = { workspace = true }
+license       = { workspace = true }
+name          = "swc_ecma_visit_std"
+repository    = { workspace = true }
+version       = "1.0.0"
+
+  [package.metadata.docs.rs]
+  all-features = true
+  rustdoc-args = ["--cfg", "docsrs"]
+
+[lib]
+bench = false
+
+[features]
+debug      = []
+default    = []
+path       = []
+serde-impl = ["serde"]
+
+[dependencies]
+new_debug_unreachable = { workspace = true }
+num-bigint            = { workspace = true, features = ["serde"] }
+serde                 = { workspace = true, optional = true, features = ["derive"] }
+tracing               = { workspace = true }
+
+swc_atoms    = { version = "4.0.0", path = "../swc_atoms" }
+swc_common   = { version = "7.0.0", path = "../swc_common" }
+swc_ecma_ast = { version = "7.0.0", path = "../swc_ecma_ast" }
+swc_visit    = { version = "2.0.0", path = "../swc_visit" }

crates/swc_ecma_visit_std/Cargo.toml

@@ -0,0 +1,8 @@
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+#[doc(hidden)]
+pub extern crate swc_ecma_ast;
+
+pub use self::generated::*;
+
+mod generated;

crates/swc_ecma_visit_std/src/generated.rs

@@ -12,5 +12,6 @@ anyhow      = { workspace = true }
 clap        = { version = "4.5.9", features = ["derive"] }
 proc-macro2 = { workspace = true }
 quote       = { workspace = true }
+swc_cached  = { version = "2.0.0", path = "../../crates/swc_cached" }
 syn         = { workspace = true, features = ["full", "visit-mut", "extra-traits"] }
 walkdir     = { workspace = true }

crates/swc_ecma_visit_std/src/lib.rs

@@ -3,18 +3,28 @@ use std::collections::HashSet;
 use inflector::Inflector;
 use proc_macro2::{Span, TokenStream};
 use quote::{quote, ToTokens};
+use swc_cached::regex::CachedRegex;
 use syn::{
     parse_quote, Arm, Attribute, Expr, Field, Fields, File, GenericArgument, Ident, Item, Lit,
     LitInt, Path, PathArguments, Stmt, TraitItem, Type,
 };
 
-pub fn generate(crate_name: &Ident, node_types: &[&Item]) -> File {
+pub fn generate(crate_name: &Ident, node_types: &[&Item], excluded_types: &[String]) -> File {
     let mut output = File {
         shebang: None,
         attrs: Vec::new(),
         items: Vec::new(),
     };
     let mut all_types = all_field_types(node_types).into_iter().collect::<Vec<_>>();
+
+    if !excluded_types.is_empty() {
+        all_types.retain(|ty| {
+            !excluded_types
+                .iter()
+                .any(|type_name| ty.contains_type(type_name))
+        });
+    }
+
     all_types.sort_by_cached_key(|v| v.method_name());
 
     let mut typedefs = HashSet::new();
@@ -59,7 +69,11 @@ pub fn generate(crate_name: &Ident, node_types: &[&Item]) -> File {
 
     for &kind in [TraitKind::Visit, TraitKind::VisitMut, TraitKind::Fold].iter() {
         for &variant in [Variant::Normal, Variant::AstPath].iter() {
-            let g = Generator { kind, variant };
+            let g = Generator {
+                kind,
+                variant,
+                excluded_types,
+            };
 
             output.items.extend(g.declare_visit_trait(&all_types));
 
@@ -135,6 +149,15 @@ impl FieldType {
             },
         }
     }
+
+    fn contains_type(&self, type_name: &str) -> bool {
+        let regex = CachedRegex::new(type_name).expect("failed to create regex");
+
+        match self {
+            FieldType::Normal(name) => regex.is_match(name),
+            FieldType::Generic(name, ty) => regex.is_match(name) || ty.contains_type(type_name),
+        }
+    }
 }
 
 fn all_field_types(node_types: &[&Item]) -> HashSet<FieldType> {
@@ -283,12 +306,14 @@ impl Variant {
     }
 }
 
-struct Generator {
+struct Generator<'a> {
     kind: TraitKind,
     variant: Variant,
+
+    excluded_types: &'a [String],
 }
 
-impl Generator {
+impl Generator<'_> {
     fn should_skip(&self, ty: &Type) -> bool {
         if let Some(ty) = extract_generic("Box", ty) {
             return self.should_skip(ty);
@@ -304,9 +329,16 @@ impl Generator {
 
         let ty = to_field_ty(ty);
         match ty {
-            Some(..) => {}
+            Some(ty) => {
+                for excluded_type in self.excluded_types {
+                    if ty.contains_type(excluded_type) {
+                        return true;
+                    }
+                }
+            }
             None => return true,
         }
+
         false
     }
 

tools/generate-code/Cargo.toml

@@ -5,6 +5,7 @@ use std::path::{Path, PathBuf};
 use anyhow::{bail, Context, Result};
 use clap::Parser;
 use proc_macro2::Span;
+use swc_cached::regex::CachedRegex;
 use syn::{Ident, Item};
 
 use crate::types::qualify_types;
@@ -39,7 +40,7 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn run_visitor_codegen(input_dir: &Path, output: &Path, excludes: &[String]) -> Result<()> {
+fn run_visitor_codegen(input_dir: &Path, output: &Path, excluded_types: &[String]) -> Result<()> {
     let crate_name = Ident::new(
         input_dir.file_name().unwrap().to_str().unwrap(),
         Span::call_site(),
@@ -72,7 +73,14 @@ fn run_visitor_codegen(input_dir: &Path, output: &Path, excludes: &[String]) ->
             _ => return false,
         };
 
-        !excludes.contains(&ident.to_string())
+        for type_name in excluded_types {
+            let regex = CachedRegex::new(type_name).expect("failed to create regex");
+            if regex.is_match(&ident.to_string()) {
+                return false;
+            }
+        }
+
+        true
     });
 
     all_type_defs.sort_by_key(|item| match item {
@@ -81,7 +89,7 @@ fn run_visitor_codegen(input_dir: &Path, output: &Path, excludes: &[String]) ->
         _ => None,
     });
 
-    let file = generators::visitor::generate(&crate_name, &all_type_defs);
+    let file = generators::visitor::generate(&crate_name, &all_type_defs, excluded_types);
 
     let output_content = quote::quote!(#file).to_string();
 
@@ -125,6 +133,23 @@ fn test_ecmascript() {
     .unwrap();
 }
 
+#[test]
+fn test_ecmascript_std() {
+    run_visitor_codegen(
+        Path::new("../../crates/swc_ecma_ast"),
+        Path::new("../../crates/swc_ecma_visit_std/src/generated.rs"),
+        &[
+            "Align64".into(),
+            "EncodeBigInt".into(),
+            "EsVersion".into(),
+            "FnPass".into(),
+            "Accessibility".into(),
+            "^Ts.*".into(),
+        ],
+    )
+    .unwrap();
+}
+
 #[test]
 fn test_css() {
     run_visitor_codegen(