Vendor things
This commit is contained in:
parent
5deceec006
commit
977e3c17e5
19434 changed files with 10682014 additions and 0 deletions
544
third-party/vendor/swc_visit/src/lib.rs
vendored
Normal file
544
third-party/vendor/swc_visit/src/lib.rs
vendored
Normal file
|
|
@ -0,0 +1,544 @@
|
|||
//! Visitor generator for the rust language.
|
||||
//!
|
||||
//!
|
||||
//! There are three variants of visitor in swc. Those are `Fold`, `VisitMut`,
|
||||
//! `Visit`.
|
||||
//!
|
||||
//! # Comparisons
|
||||
//!
|
||||
//! ## `Fold` vs `VisitMut`
|
||||
//!
|
||||
//! `Fold` and `VisitMut` do almost identical tasks, but `Fold` is easier to use
|
||||
//! while being slower and weak to stack overflow for very deep asts. `Fold` is
|
||||
//! fast enough for almost all cases so it would be better to start with `Fold`.
|
||||
//!
|
||||
//! By very deep asts, I meant code like thousands of `a + a + a + a + ...`.
|
||||
//!
|
||||
//!
|
||||
//! # `Fold`
|
||||
//!
|
||||
//! > WARNING: `Fold` is slow, and it's recommended to use VisitMut if you are
|
||||
//! experienced.
|
||||
//!
|
||||
//!
|
||||
//! `Fold` takes ownership of value, which means you have to return the new
|
||||
//! value. Returning new value means returning ownership of the value. But you
|
||||
//! don't have to care about ownership or about managing memories while using
|
||||
//! such visitors. `rustc` handles them automatically and all allocations will
|
||||
//! be freed when it goes out of the scope.
|
||||
//!
|
||||
//! You can invoke your `Fold` implementation like `node.fold_with(&mut
|
||||
//! visitor)` where `visitor` is your visitor. Note that as it takes ownership
|
||||
//! of value, you have to call `node.fold_children_with(self)` in e.g. `fn
|
||||
//! fold_module(&mut self, m: Module) -> Module` if you override the default
|
||||
//! behavior. Also you have to store return value from `fold_children_with`,
|
||||
//! like `let node = node.fold_children_with(self)`. Order of execution can be
|
||||
//! controlled using this. If there is some logic that should be applied to the
|
||||
//! parent first, you can call `fold_children_with` after such logic.
|
||||
//!
|
||||
//! # `VisitMut`
|
||||
//!
|
||||
//! `VisitMut` uses a mutable reference to AST nodes (e.g. `&mut Expr`). You can
|
||||
//! use `Take` from `swc_common::util::take::Take` to get owned value from a
|
||||
//! mutable reference.
|
||||
//!
|
||||
//! You will typically use code like
|
||||
//!
|
||||
//! ```ignore
|
||||
//! *e = return_value.take();
|
||||
//! ```
|
||||
//!
|
||||
//! where `e = &mut Expr` and `return_value` is also `&mut Expr`. `take()` is an
|
||||
//! extension method defined on `MapWithMut`. It's almost identical to `Fold`,
|
||||
//! so I'll skip memory management.
|
||||
//!
|
||||
//! You can invoke your `VisitMut` implementation like `node.visit_mut_with(&mut
|
||||
//! visitor)` where `visitor` is your visitor. Again, you need to call
|
||||
//! `node.visit_mut_children_with(self)` in visitor implementation if you want
|
||||
//! to modify children nodes. You don't need to store the return value in this
|
||||
//! case.
|
||||
//!
|
||||
//!
|
||||
//! # `Visit`
|
||||
//!
|
||||
//!`Visit` uses non-mutable references to AST nodes. It can be used to see if
|
||||
//! an AST node contains a specific node nested deeply in the AST. This is
|
||||
//! useful for checking if AST node contains `this`. This is useful for lots of
|
||||
//! cases - `this` in arrow expressions are special and we need to generate
|
||||
//! different code if a `this` expression is used.
|
||||
//!
|
||||
//! You can use your `Visit` implementation like `node.visit_with(&Invalid{
|
||||
//! span: DUMMY_SP, }, &mut visitor`. I think API is mis-designed, but it works
|
||||
//! and there are really lots of code using `Visit` already.
|
||||
//!
|
||||
//!
|
||||
//!
|
||||
//! # Cargo features
|
||||
//!
|
||||
//! You should add
|
||||
//! ```toml
|
||||
//! [features]
|
||||
//! path = []
|
||||
//! ```
|
||||
//!
|
||||
//! If you want to allow using path-aware visitor.
|
||||
//!
|
||||
//!
|
||||
//! # Path-aware visitor
|
||||
//!
|
||||
//! Path-aware visitor is a visitor that can be used to visit AST nodes with
|
||||
//! current path from the entrypoint.
|
||||
//!
|
||||
//! `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;
|
||||
|
||||
pub mod util;
|
||||
|
||||
/// Visit all children nodes. This converts `VisitAll` to `Visit`. The type
|
||||
/// parameter `V` should implement `VisitAll` and `All<V>` implements `Visit`.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct All<V> {
|
||||
pub visitor: V,
|
||||
}
|
||||
|
||||
/// A visitor which visits node only if `enabled` is true.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct Optional<V> {
|
||||
pub enabled: bool,
|
||||
pub visitor: V,
|
||||
}
|
||||
|
||||
impl<V> Optional<V> {
|
||||
pub const fn new(visitor: V, enabled: bool) -> Self {
|
||||
Self { enabled, visitor }
|
||||
}
|
||||
}
|
||||
|
||||
/// Trait for a pass which is designed to invoked multiple time to same input.
|
||||
///
|
||||
/// See [Repeat].
|
||||
pub trait Repeated {
|
||||
/// Should run again?
|
||||
fn changed(&self) -> bool;
|
||||
|
||||
/// Reset.
|
||||
fn reset(&mut self);
|
||||
}
|
||||
|
||||
/// A visitor which applies `A` and then `B`.
|
||||
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct AndThen<A, B> {
|
||||
pub first: A,
|
||||
pub second: B,
|
||||
}
|
||||
|
||||
/// Chains multiple visitor.
|
||||
#[macro_export]
|
||||
macro_rules! chain {
|
||||
($a:expr, $b:expr) => {{
|
||||
use $crate::AndThen;
|
||||
|
||||
AndThen {
|
||||
first: $a,
|
||||
second: $b,
|
||||
}
|
||||
}};
|
||||
|
||||
($a:expr, $b:expr,) => {
|
||||
chain!($a, $b)
|
||||
};
|
||||
|
||||
($a:expr, $b:expr, $($rest:tt)+) => {{
|
||||
use $crate::AndThen;
|
||||
|
||||
AndThen{
|
||||
first: $a,
|
||||
second: chain!($b, $($rest)*),
|
||||
}
|
||||
}};
|
||||
}
|
||||
|
||||
/// A visitor which applies `V` again and again if `V` modifies the node.
|
||||
///
|
||||
/// # Note
|
||||
/// `V` should return `true` from `changed()` to make the pass run multiple
|
||||
/// time.
|
||||
///
|
||||
/// See: [Repeated]
|
||||
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct Repeat<V>
|
||||
where
|
||||
V: Repeated,
|
||||
{
|
||||
pub pass: V,
|
||||
}
|
||||
|
||||
impl<V> Repeat<V>
|
||||
where
|
||||
V: Repeated,
|
||||
{
|
||||
pub fn new(pass: V) -> Self {
|
||||
Self { pass }
|
||||
}
|
||||
}
|
||||
|
||||
impl<V> Repeated for Repeat<V>
|
||||
where
|
||||
V: Repeated,
|
||||
{
|
||||
fn changed(&self) -> bool {
|
||||
self.pass.changed()
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.pass.reset()
|
||||
}
|
||||
}
|
||||
|
||||
impl<A, B> Repeated for AndThen<A, B>
|
||||
where
|
||||
A: Repeated,
|
||||
B: Repeated,
|
||||
{
|
||||
fn changed(&self) -> bool {
|
||||
self.first.changed() || self.second.changed()
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.first.reset();
|
||||
self.second.reset();
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct AstKindPath<K>
|
||||
where
|
||||
K: ParentKind,
|
||||
{
|
||||
path: Vec<K>,
|
||||
}
|
||||
|
||||
impl<K> std::ops::Deref for AstKindPath<K>
|
||||
where
|
||||
K: ParentKind,
|
||||
{
|
||||
type Target = Vec<K>;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.path
|
||||
}
|
||||
}
|
||||
|
||||
impl<K> Default for AstKindPath<K>
|
||||
where
|
||||
K: ParentKind,
|
||||
{
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
path: Default::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<K> AstKindPath<K>
|
||||
where
|
||||
K: ParentKind,
|
||||
{
|
||||
pub fn new(path: Vec<K>) -> Self {
|
||||
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);
|
||||
self.path.last_mut().unwrap().set_index(usize::MAX);
|
||||
res
|
||||
}
|
||||
}
|
||||
|
||||
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
|
||||
N: NodeRef,
|
||||
{
|
||||
kinds: AstKindPath<N::ParentKind>,
|
||||
path: Vec<N>,
|
||||
}
|
||||
|
||||
impl<N> std::ops::Deref for AstNodePath<N>
|
||||
where
|
||||
N: NodeRef,
|
||||
{
|
||||
type Target = Vec<N>;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.path
|
||||
}
|
||||
}
|
||||
|
||||
impl<N> Default for AstNodePath<N>
|
||||
where
|
||||
N: NodeRef,
|
||||
{
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
kinds: Default::default(),
|
||||
path: Default::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<N> AstNodePath<N>
|
||||
where
|
||||
N: NodeRef,
|
||||
{
|
||||
pub fn new(kinds: AstKindPath<N::ParentKind>, path: Vec<N>) -> Self {
|
||||
Self { kinds, path }
|
||||
}
|
||||
|
||||
pub fn kinds(&self) -> &AstKindPath<N::ParentKind> {
|
||||
&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,
|
||||
{
|
||||
let kind = node.kind();
|
||||
|
||||
self.kinds.path.push(kind);
|
||||
self.path.push(node);
|
||||
let ret = op(self);
|
||||
self.path.pop();
|
||||
self.kinds.path.pop();
|
||||
|
||||
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,
|
||||
{
|
||||
self.kinds.path.last_mut().unwrap().set_index(index);
|
||||
self.path.last_mut().unwrap().set_index(index);
|
||||
|
||||
let res = op(self);
|
||||
|
||||
self.path.last_mut().unwrap().set_index(usize::MAX);
|
||||
self.kinds.path.last_mut().unwrap().set_index(usize::MAX);
|
||||
res
|
||||
}
|
||||
}
|
||||
|
||||
pub trait NodeRef: Copy {
|
||||
type ParentKind: ParentKind;
|
||||
|
||||
fn kind(&self) -> Self::ParentKind;
|
||||
|
||||
fn set_index(&mut self, index: usize);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue