Enum Either

pub enum Either<L, R> {
    Left(L),
    Right(R),
}

Available on crate feature __common only.

The enum Either with variants Left and Right is a general purpose sum type with two cases.

The Either type is symmetric and treats its variants the same way, without preference. (For representing success or error, use the regular Result enum instead.)

Variants

Left(L)

A value of type L.

Right(R)

A value of type R.

Implementations

impl<L, R> Either<L, R>

pub fn is_left(&self) -> bool

Available on crate features __ecma and __utils only.

Return true if the value is the Left variant.

use either::*;

let values = [Left(1), Right("the right value")];
assert_eq!(values[0].is_left(), true);
assert_eq!(values[1].is_left(), false);

pub fn is_right(&self) -> bool

Available on crate features __ecma and __utils only.

Return true if the value is the Right variant.

use either::*;

let values = [Left(1), Right("the right value")];
assert_eq!(values[0].is_right(), false);
assert_eq!(values[1].is_right(), true);

pub fn left(self) -> Option<L>

Available on crate features __ecma and __utils only.

Convert the left side of Either<L, R> to an Option<L>.

use either::*;

let left: Either<_, ()> = Left("some value");
assert_eq!(left.left(),  Some("some value"));

let right: Either<(), _> = Right(321);
assert_eq!(right.left(), None);

pub fn right(self) -> Option<R>

Available on crate features __ecma and __utils only.

Convert the right side of Either<L, R> to an Option<R>.

use either::*;

let left: Either<_, ()> = Left("some value");
assert_eq!(left.right(),  None);

let right: Either<(), _> = Right(321);
assert_eq!(right.right(), Some(321));

pub fn as_ref(&self) -> Either<&L, &R>

Available on crate features __ecma and __utils only.

Convert &Either<L, R> to Either<&L, &R>.

use either::*;

let left: Either<_, ()> = Left("some value");
assert_eq!(left.as_ref(), Left(&"some value"));

let right: Either<(), _> = Right("some value");
assert_eq!(right.as_ref(), Right(&"some value"));

pub fn as_mut(&mut self) -> Either<&mut L, &mut R>

Available on crate features __ecma and __utils only.

Convert &mut Either<L, R> to Either<&mut L, &mut R>.

use either::*;

fn mutate_left(value: &mut Either<u32, u32>) {
    if let Some(l) = value.as_mut().left() {
        *l = 999;
    }
}

let mut left = Left(123);
let mut right = Right(123);
mutate_left(&mut left);
mutate_left(&mut right);
assert_eq!(left, Left(999));
assert_eq!(right, Right(123));

pub fn as_pin_ref(self: Pin<&Either<L, R>>) -> Either<Pin<&L>, Pin<&R>>

Available on crate features __ecma and __utils only.

Convert Pin<&Either<L, R>> to Either<Pin<&L>, Pin<&R>>, pinned projections of the inner variants.

pub fn as_pin_mut( self: Pin<&mut Either<L, R>>, ) -> Either<Pin<&mut L>, Pin<&mut R>>

Available on crate features __ecma and __utils only.

Convert Pin<&mut Either<L, R>> to Either<Pin<&mut L>, Pin<&mut R>>, pinned projections of the inner variants.

pub fn flip(self) -> Either<R, L>

Available on crate features __ecma and __utils only.

Convert Either<L, R> to Either<R, L>.

use either::*;

let left: Either<_, ()> = Left(123);
assert_eq!(left.flip(), Right(123));

let right: Either<(), _> = Right("some value");
assert_eq!(right.flip(), Left("some value"));

pub fn map_left<F, M>(self, f: F) -> Either<M, R>

where F: FnOnce(L) -> M,

Available on crate features __ecma and __utils only.

Apply the function f on the value in the Left variant if it is present rewrapping the result in Left.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.map_left(|x| x * 2), Left(246));

let right: Either<u32, _> = Right(123);
assert_eq!(right.map_left(|x| x * 2), Right(123));

pub fn map_right<F, S>(self, f: F) -> Either<L, S>

where F: FnOnce(R) -> S,

Available on crate features __ecma and __utils only.

Apply the function f on the value in the Right variant if it is present rewrapping the result in Right.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.map_right(|x| x * 2), Left(123));

let right: Either<u32, _> = Right(123);
assert_eq!(right.map_right(|x| x * 2), Right(246));

pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S>

where F: FnOnce(L) -> M, G: FnOnce(R) -> S,

Available on crate features __ecma and __utils only.

Apply the functions f and g to the Left and Right variants respectively. This is equivalent to bimap in functional programming.

use either::*;

let f = |s: String| s.len();
let g = |u: u8| u.to_string();

let left: Either<String, u8> = Left("loopy".into());
assert_eq!(left.map_either(f, g), Left(5));

let right: Either<String, u8> = Right(42);
assert_eq!(right.map_either(f, g), Right("42".into()));

pub fn map_either_with<Ctx, F, G, M, S>( self, ctx: Ctx, f: F, g: G, ) -> Either<M, S>

where F: FnOnce(Ctx, L) -> M, G: FnOnce(Ctx, R) -> S,

Available on crate features __ecma and __utils only.

Similar to map_either, with an added context ctx accessible to both functions.

use either::*;

let mut sum = 0;

// Both closures want to update the same value, so pass it as context.
let mut f = |sum: &mut usize, s: String| { *sum += s.len(); s.to_uppercase() };
let mut g = |sum: &mut usize, u: usize| { *sum += u; u.to_string() };

let left: Either<String, usize> = Left("loopy".into());
assert_eq!(left.map_either_with(&mut sum, &mut f, &mut g), Left("LOOPY".into()));

let right: Either<String, usize> = Right(42);
assert_eq!(right.map_either_with(&mut sum, &mut f, &mut g), Right("42".into()));

assert_eq!(sum, 47);

pub fn either<F, G, T>(self, f: F, g: G) -> T

where F: FnOnce(L) -> T, G: FnOnce(R) -> T,

Available on crate features __ecma and __utils only.

Apply one of two functions depending on contents, unifying their result. If the value is Left(L) then the first function f is applied; if it is Right(R) then the second function g is applied.

use either::*;

fn square(n: u32) -> i32 { (n * n) as i32 }
fn negate(n: i32) -> i32 { -n }

let left: Either<u32, i32> = Left(4);
assert_eq!(left.either(square, negate), 16);

let right: Either<u32, i32> = Right(-4);
assert_eq!(right.either(square, negate), 4);

pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T

where F: FnOnce(Ctx, L) -> T, G: FnOnce(Ctx, R) -> T,

Available on crate features __ecma and __utils only.

Like either, but provide some context to whichever of the functions ends up being called.

// In this example, the context is a mutable reference
use either::*;

let mut result = Vec::new();

let values = vec![Left(2), Right(2.7)];

for value in values {
    value.either_with(&mut result,
                      |ctx, integer| ctx.push(integer),
                      |ctx, real| ctx.push(f64::round(real) as i32));
}

assert_eq!(result, vec![2, 3]);

pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>

where F: FnOnce(L) -> Either<S, R>,

Available on crate features __ecma and __utils only.

Apply the function f on the value in the Left variant if it is present.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246));

let right: Either<u32, _> = Right(123);
assert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));

pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>

where F: FnOnce(R) -> Either<L, S>,

Available on crate features __ecma and __utils only.

Apply the function f on the value in the Right variant if it is present.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));

let right: Either<u32, _> = Right(123);
assert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));

pub fn into_iter( self, ) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>

where L: IntoIterator, R: IntoIterator<Item = <L as IntoIterator>::Item>,

Available on crate features __ecma and __utils only.

Convert the inner value to an iterator.

This requires the Left and Right iterators to have the same item type. See factor_into_iter to iterate different types.

use either::*;

let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);
let mut right: Either<Vec<u32>, _> = Right(vec![]);
right.extend(left.into_iter());
assert_eq!(right, Right(vec![1, 2, 3, 4, 5]));

pub fn iter( &self, ) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>

where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator<Item = <&'a L as IntoIterator>::Item>,

Available on crate features __ecma and __utils only.

Borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type. See factor_iter to iterate different types.

use either::*;

let left: Either<_, &[u32]> = Left(vec![2, 3]);
let mut right: Either<Vec<u32>, _> = Right(&[4, 5][..]);
let mut all = vec![1];
all.extend(left.iter());
all.extend(right.iter());
assert_eq!(all, vec![1, 2, 3, 4, 5]);

pub fn iter_mut( &mut self, ) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>

where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

Available on crate features __ecma and __utils only.

Mutably borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type. See factor_iter_mut to iterate different types.

use either::*;

let mut left: Either<_, &mut [u32]> = Left(vec![2, 3]);
for l in left.iter_mut() {
    *l *= *l
}
assert_eq!(left, Left(vec![4, 9]));

let mut inner = [4, 5];
let mut right: Either<Vec<u32>, _> = Right(&mut inner[..]);
for r in right.iter_mut() {
    *r *= *r
}
assert_eq!(inner, [16, 25]);

pub fn factor_into_iter( self, ) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>

where L: IntoIterator, R: IntoIterator,

Available on crate features __ecma and __utils only.

Converts an Either of Iterators to be an Iterator of Eithers

Unlike into_iter, this does not require the Left and Right iterators to have the same item type.

use either::*;
let left: Either<_, Vec<u8>> = Left(&["hello"]);
assert_eq!(left.factor_into_iter().next(), Some(Left(&"hello")));
let right: Either<&[&str], _> = Right(vec![0, 1]);
assert_eq!(right.factor_into_iter().collect::<Vec<_>>(), vec![Right(0), Right(1)]);

pub fn factor_iter( &self, ) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>

where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator,

Available on crate features __ecma and __utils only.

Borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter, this does not require the Left and Right iterators to have the same item type.

use either::*;
let left: Either<_, Vec<u8>> = Left(["hello"]);
assert_eq!(left.factor_iter().next(), Some(Left(&"hello")));
let right: Either<[&str; 2], _> = Right(vec![0, 1]);
assert_eq!(right.factor_iter().collect::<Vec<_>>(), vec![Right(&0), Right(&1)]);

pub fn factor_iter_mut( &mut self, ) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>

where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator,

Available on crate features __ecma and __utils only.

Mutably borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter_mut, this does not require the Left and Right iterators to have the same item type.

use either::*;
let mut left: Either<_, Vec<u8>> = Left(["hello"]);
left.factor_iter_mut().for_each(|x| *x.unwrap_left() = "goodbye");
assert_eq!(left, Left(["goodbye"]));
let mut right: Either<[&str; 2], _> = Right(vec![0, 1, 2]);
right.factor_iter_mut().for_each(|x| if let Right(r) = x { *r = -*r; });
assert_eq!(right, Right(vec![0, -1, -2]));

pub fn left_or(self, other: L) -> L

Available on crate features __ecma and __utils only.

Return left value or given value

Arguments passed to left_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use left_or_else, which is lazily evaluated.

Examples

let left: Either<&str, &str> = Left("left");
assert_eq!(left.left_or("foo"), "left");

let right: Either<&str, &str> = Right("right");
assert_eq!(right.left_or("left"), "left");

pub fn left_or_default(self) -> L

where L: Default,

Available on crate features __ecma and __utils only.

Return left or a default

Examples

let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.left_or_default(), "left");

let right: Either<String, u32> = Right(42);
assert_eq!(right.left_or_default(), String::default());

pub fn left_or_else<F>(self, f: F) -> L

where F: FnOnce(R) -> L,

Available on crate features __ecma and __utils only.

Returns left value or computes it from a closure

Examples

let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.left_or_else(|_| unreachable!()), "3");

let right: Either<String, u32> = Right(3);
assert_eq!(right.left_or_else(|x| x.to_string()), "3");

pub fn right_or(self, other: R) -> R

Available on crate features __ecma and __utils only.

Return right value or given value

Arguments passed to right_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use right_or_else, which is lazily evaluated.

Examples

let right: Either<&str, &str> = Right("right");
assert_eq!(right.right_or("foo"), "right");

let left: Either<&str, &str> = Left("left");
assert_eq!(left.right_or("right"), "right");

pub fn right_or_default(self) -> R

where R: Default,

Available on crate features __ecma and __utils only.

Return right or a default

Examples

let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.right_or_default(), u32::default());

let right: Either<String, u32> = Right(42);
assert_eq!(right.right_or_default(), 42);

pub fn right_or_else<F>(self, f: F) -> R

where F: FnOnce(L) -> R,

Available on crate features __ecma and __utils only.

Returns right value or computes it from a closure

Examples

let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3);

let right: Either<String, u32> = Right(3);
assert_eq!(right.right_or_else(|_| unreachable!()), 3);

pub fn unwrap_left(self) -> L

where R: Debug,

Available on crate features __ecma and __utils only.

Returns the left value

Examples

let left: Either<_, ()> = Left(3);
assert_eq!(left.unwrap_left(), 3);

Panics

When Either is a Right value

let right: Either<(), _> = Right(3);
right.unwrap_left();

pub fn unwrap_right(self) -> R

where L: Debug,

Available on crate features __ecma and __utils only.

Returns the right value

Examples

let right: Either<(), _> = Right(3);
assert_eq!(right.unwrap_right(), 3);

Panics

When Either is a Left value

let left: Either<_, ()> = Left(3);
left.unwrap_right();

pub fn expect_left(self, msg: &str) -> L

where R: Debug,

Available on crate features __ecma and __utils only.

Returns the left value

Examples

let left: Either<_, ()> = Left(3);
assert_eq!(left.expect_left("value was Right"), 3);

Panics

When Either is a Right value

let right: Either<(), _> = Right(3);
right.expect_left("value was Right");

pub fn expect_right(self, msg: &str) -> R

where L: Debug,

Available on crate features __ecma and __utils only.

Returns the right value

Examples

let right: Either<(), _> = Right(3);
assert_eq!(right.expect_right("value was Left"), 3);

Panics

When Either is a Left value

let left: Either<_, ()> = Left(3);
left.expect_right("value was Right");

pub fn either_into<T>(self) -> T

where L: Into<T>, R: Into<T>,

Available on crate features __ecma and __utils only.

Convert the contained value into T

Examples

// Both u16 and u32 can be converted to u64.
let left: Either<u16, u32> = Left(3u16);
assert_eq!(left.either_into::<u64>(), 3u64);
let right: Either<u16, u32> = Right(7u32);
assert_eq!(right.either_into::<u64>(), 7u64);

impl<L, R> Either<Option<L>, Option<R>>

pub fn factor_none(self) -> Option<Either<L, R>>

Available on crate features __ecma and __utils only.

Factors out None from an Either of Option.

use either::*;
let left: Either<_, Option<String>> = Left(Some(vec![0]));
assert_eq!(left.factor_none(), Some(Left(vec![0])));

let right: Either<Option<Vec<u8>>, _> = Right(Some(String::new()));
assert_eq!(right.factor_none(), Some(Right(String::new())));

impl<L, R, E> Either<Result<L, E>, Result<R, E>>

pub fn factor_err(self) -> Result<Either<L, R>, E>

Available on crate features __ecma and __utils only.

Factors out a homogenous type from an Either of Result.

Here, the homogeneous type is the Err type of the Result.

use either::*;
let left: Either<_, Result<String, u32>> = Left(Ok(vec![0]));
assert_eq!(left.factor_err(), Ok(Left(vec![0])));

let right: Either<Result<Vec<u8>, u32>, _> = Right(Ok(String::new()));
assert_eq!(right.factor_err(), Ok(Right(String::new())));

impl<T, L, R> Either<Result<T, L>, Result<T, R>>

pub fn factor_ok(self) -> Result<T, Either<L, R>>

Available on crate features __ecma and __utils only.

Factors out a homogenous type from an Either of Result.

Here, the homogeneous type is the Ok type of the Result.

use either::*;
let left: Either<_, Result<u32, String>> = Left(Err(vec![0]));
assert_eq!(left.factor_ok(), Err(Left(vec![0])));

let right: Either<Result<u32, Vec<u8>>, _> = Right(Err(String::new()));
assert_eq!(right.factor_ok(), Err(Right(String::new())));

impl<T, L, R> Either<(T, L), (T, R)>

pub fn factor_first(self) -> (T, Either<L, R>)

Available on crate features __ecma and __utils only.

Factor out a homogeneous type from an either of pairs.

Here, the homogeneous type is the first element of the pairs.

use either::*;
let left: Either<_, (u32, String)> = Left((123, vec![0]));
assert_eq!(left.factor_first().0, 123);

let right: Either<(u32, Vec<u8>), _> = Right((123, String::new()));
assert_eq!(right.factor_first().0, 123);

impl<T, L, R> Either<(L, T), (R, T)>

pub fn factor_second(self) -> (Either<L, R>, T)

Available on crate features __ecma and __utils only.

Factor out a homogeneous type from an either of pairs.

Here, the homogeneous type is the second element of the pairs.

use either::*;
let left: Either<_, (String, u32)> = Left((vec![0], 123));
assert_eq!(left.factor_second().1, 123);

let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123));
assert_eq!(right.factor_second().1, 123);

impl<T> Either<T, T>

pub fn into_inner(self) -> T

Available on crate features __ecma and __utils only.

Extract the value of an either over two equivalent types.

use either::*;

let left: Either<_, u32> = Left(123);
assert_eq!(left.into_inner(), 123);

let right: Either<u32, _> = Right(123);
assert_eq!(right.into_inner(), 123);

pub fn map<F, M>(self, f: F) -> Either<M, M>

where F: FnOnce(T) -> M,

Available on crate features __ecma and __utils only.

Map f over the contained value and return the result in the corresponding variant.

use either::*;

let value: Either<_, i32> = Right(42);

let other = value.map(|x| x * 2);
assert_eq!(other, Right(84));

impl<L, R> Either<&L, &R>

pub fn cloned(self) -> Either<L, R>

where L: Clone, R: Clone,

Available on crate features __ecma and __utils only.

Maps an Either<&L, &R> to an Either<L, R> by cloning the contents of either branch.

pub fn copied(self) -> Either<L, R>

where L: Copy, R: Copy,

Available on crate features __ecma and __utils only.

Maps an Either<&L, &R> to an Either<L, R> by copying the contents of either branch.

impl<L, R> Either<&mut L, &mut R>

pub fn cloned(self) -> Either<L, R>

where L: Clone, R: Clone,

Available on crate features __ecma and __utils only.

Maps an Either<&mut L, &mut R> to an Either<L, R> by cloning the contents of either branch.

pub fn copied(self) -> Either<L, R>

where L: Copy, R: Copy,

Available on crate features __ecma and __utils only.

Maps an Either<&mut L, &mut R> to an Either<L, R> by copying the contents of either branch.

Trait Implementations

impl<L, R, Target> AsMut<[Target]> for Either<L, R>

where L: AsMut<[Target]>, R: AsMut<[Target]>,

fn as_mut(&mut self) -> &mut [Target]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, R> AsMut<CStr> for Either<L, R>

where L: AsMut<CStr>, R: AsMut<CStr>,

Requires crate feature use_std.

fn as_mut(&mut self) -> &mut CStr

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, R> AsMut<OsStr> for Either<L, R>

where L: AsMut<OsStr>, R: AsMut<OsStr>,

Requires crate feature use_std.

fn as_mut(&mut self) -> &mut OsStr

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, R> AsMut<Path> for Either<L, R>

where L: AsMut<Path>, R: AsMut<Path>,

Requires crate feature use_std.

fn as_mut(&mut self) -> &mut Path

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, R, Target> AsMut<Target> for Either<L, R>

where L: AsMut<Target>, R: AsMut<Target>,

fn as_mut(&mut self) -> &mut Target

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, R> AsMut<str> for Either<L, R>

where L: AsMut<str>, R: AsMut<str>,

fn as_mut(&mut self) -> &mut str

Converts this type into a mutable reference of the (usually inferred) input type.

impl<L, R, Target> AsRef<[Target]> for Either<L, R>

where L: AsRef<[Target]>, R: AsRef<[Target]>,

fn as_ref(&self) -> &[Target]

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, R> AsRef<CStr> for Either<L, R>

where L: AsRef<CStr>, R: AsRef<CStr>,

Requires crate feature use_std.

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, R> AsRef<OsStr> for Either<L, R>

where L: AsRef<OsStr>, R: AsRef<OsStr>,

Requires crate feature use_std.

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, R> AsRef<Path> for Either<L, R>

where L: AsRef<Path>, R: AsRef<Path>,

Requires crate feature use_std.

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, R, Target> AsRef<Target> for Either<L, R>

where L: AsRef<Target>, R: AsRef<Target>,

fn as_ref(&self) -> &Target

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, R> AsRef<str> for Either<L, R>

where L: AsRef<str>, R: AsRef<str>,

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<L, R> BufRead for Either<L, R>

where L: BufRead, R: BufRead,

Requires crate feature "use_std"

fn fill_buf(&mut self) -> Result<&[u8], Error>

Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(&mut self, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to read.

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes into buf until the delimiter byte or EOF is reached.

fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until a newline (the 0xA byte) is reached, and append them to the provided String buffer.

fn has_data_left(&mut self) -> Result<bool, Error>

🔬This is a nightly-only experimental API. (buf_read_has_data_left)

Checks if the underlying Read has any data left to be read.

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

Skips all bytes until the delimiter byte or EOF is reached.

fn split(self, byte: u8) -> Split<Self>

where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

where Self: Sized,

Returns an iterator over the lines of this reader.

impl<L, R> Clone for Either<L, R>

where L: Clone, R: Clone,

fn clone(&self) -> Either<L, R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Either<L, R>)

Performs copy-assignment from source.

impl<L, R> Debug for Either<L, R>

where L: Debug, R: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<L, R> Deref for Either<L, R>

where L: Deref, R: Deref<Target = <L as Deref>::Target>,

type Target = <L as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &<Either<L, R> as Deref>::Target

Dereferences the value.

impl<L, R> DerefMut for Either<L, R>

where L: DerefMut, R: DerefMut<Target = <L as Deref>::Target>,

fn deref_mut(&mut self) -> &mut <Either<L, R> as Deref>::Target

Mutably dereferences the value.

impl<L, R> Display for Either<L, R>

where L: Display, R: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<L, R> DoubleEndedIterator for Either<L, R>

where L: DoubleEndedIterator, R: DoubleEndedIterator<Item = <L as Iterator>::Item>,

fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>

Removes and returns an element from the end of the iterator.

fn nth_back(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>

Returns the nth element from the end of the iterator.

fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc

where G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,

An iterator method that reduces the iterator’s elements to a single, final value, starting from the back.

fn rfind<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>

where P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element of an iterator from the back that satisfies a predicate.

fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator from the back by n elements.

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

This is the reverse version of Iterator::try_fold(): it takes elements starting from the back of the iterator.

impl<L, R> Error for Either<L, R>

where L: Error, R: Error,

Either implements Error if both L and R implement it.

Requires crate feature "use_std"

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<L, R> ExactSizeIterator for Either<L, R>

where L: ExactSizeIterator, R: ExactSizeIterator<Item = <L as Iterator>::Item>,

fn len(&self) -> usize

Returns the exact remaining length of the iterator.

fn is_empty(&self) -> bool

🔬This is a nightly-only experimental API. (exact_size_is_empty)

Returns true if the iterator is empty.

impl<L, R, A> Extend<A> for Either<L, R>

where L: Extend<A>, R: Extend<A>,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A, B> Fold for Either<A, B>

where A: Fold, B: Fold,

fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility

Visit a node of type Accessibility.

fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit

Visit a node of type ArrayLit.

fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat

Visit a node of type ArrayPat.

fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr

Visit a node of type ArrowExpr.

fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr

Visit a node of type AssignExpr.

fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp

Visit a node of type AssignOp.

fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat

Visit a node of type AssignPat.

fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp

Visit a node of type AssignPatProp.

fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp

Visit a node of type AssignProp.

fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget

Visit a node of type AssignTarget.

fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat

Visit a node of type AssignTargetPat.

fn fold_atom(&mut self, node: Atom) -> Atom

Visit a node of type swc_atoms :: Atom.

fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor

Visit a node of type AutoAccessor.

fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr

Visit a node of type AwaitExpr.

fn fold_big_int(&mut self, node: BigInt) -> BigInt

Visit a node of type BigInt.

fn fold_big_int_value(&mut self, node: BigInt) -> BigInt

Visit a node of type BigIntValue.

fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr

Visit a node of type BinExpr.

fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp

Visit a node of type BinaryOp.

fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent

Visit a node of type BindingIdent.

fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt

Visit a node of type BlockStmt.

fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr

Visit a node of type BlockStmtOrExpr.

fn fold_bool(&mut self, node: Bool) -> Bool

Visit a node of type Bool.

fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt

Visit a node of type BreakStmt.

fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr

Visit a node of type CallExpr.

fn fold_callee(&mut self, node: Callee) -> Callee

Visit a node of type Callee.

fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause

Visit a node of type CatchClause.

fn fold_class(&mut self, node: Class) -> Class

Visit a node of type Class.

fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl

Visit a node of type ClassDecl.

fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr

Visit a node of type ClassExpr.

fn fold_class_member(&mut self, node: ClassMember) -> ClassMember

Visit a node of type ClassMember.

fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember>

Visit a node of type Vec < ClassMember >.

fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod

Visit a node of type ClassMethod.

fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp

Visit a node of type ClassProp.

fn fold_computed_prop_name( &mut self, node: ComputedPropName, ) -> ComputedPropName

Visit a node of type ComputedPropName.

fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr

Visit a node of type CondExpr.

fn fold_constructor(&mut self, node: Constructor) -> Constructor

Visit a node of type Constructor.

fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt

Visit a node of type ContinueStmt.

fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt

Visit a node of type DebuggerStmt.

fn fold_decl(&mut self, node: Decl) -> Decl

Visit a node of type Decl.

fn fold_decorator(&mut self, node: Decorator) -> Decorator

Visit a node of type Decorator.

fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator>

Visit a node of type Vec < Decorator >.

fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl

Visit a node of type DefaultDecl.

fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt

Visit a node of type DoWhileStmt.

fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt

Visit a node of type EmptyStmt.

fn fold_export_all(&mut self, node: ExportAll) -> ExportAll

Visit a node of type ExportAll.

fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl

Visit a node of type ExportDecl.

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, ) -> ExportDefaultDecl

Visit a node of type ExportDefaultDecl.

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, ) -> ExportDefaultExpr

Visit a node of type ExportDefaultExpr.

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, ) -> ExportDefaultSpecifier

Visit a node of type ExportDefaultSpecifier.

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, ) -> ExportNamedSpecifier

Visit a node of type ExportNamedSpecifier.

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, ) -> ExportNamespaceSpecifier

Visit a node of type ExportNamespaceSpecifier.

fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier

Visit a node of type ExportSpecifier.

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, ) -> Vec<ExportSpecifier>

Visit a node of type Vec < ExportSpecifier >.

fn fold_expr(&mut self, node: Expr) -> Expr

Visit a node of type Expr.

fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread

Visit a node of type ExprOrSpread.

fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread>

Visit a node of type Vec < ExprOrSpread >.

fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt

Visit a node of type ExprStmt.

fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>>

Visit a node of type Vec < Box < Expr > >.

fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl

Visit a node of type FnDecl.

fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr

Visit a node of type FnExpr.

fn fold_for_head(&mut self, node: ForHead) -> ForHead

Visit a node of type ForHead.

fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt

Visit a node of type ForInStmt.

fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt

Visit a node of type ForOfStmt.

fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt

Visit a node of type ForStmt.

fn fold_function(&mut self, node: Function) -> Function

Visit a node of type Function.

fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp

Visit a node of type GetterProp.

fn fold_ident(&mut self, node: Ident) -> Ident

Visit a node of type Ident.

fn fold_ident_name(&mut self, node: IdentName) -> IdentName

Visit a node of type IdentName.

fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt

Visit a node of type IfStmt.

fn fold_import(&mut self, node: Import) -> Import

Visit a node of type Import.

fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl

Visit a node of type ImportDecl.

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, ) -> ImportDefaultSpecifier

Visit a node of type ImportDefaultSpecifier.

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, ) -> ImportNamedSpecifier

Visit a node of type ImportNamedSpecifier.

fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase

Visit a node of type ImportPhase.

fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier

Visit a node of type ImportSpecifier.

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, ) -> Vec<ImportSpecifier>

Visit a node of type Vec < ImportSpecifier >.

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, ) -> ImportStarAsSpecifier

Visit a node of type ImportStarAsSpecifier.

fn fold_import_with(&mut self, node: ImportWith) -> ImportWith

Visit a node of type ImportWith.

fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem

Visit a node of type ImportWithItem.

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, ) -> Vec<ImportWithItem>

Visit a node of type Vec < ImportWithItem >.

fn fold_invalid(&mut self, node: Invalid) -> Invalid

Visit a node of type Invalid.

fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr

Visit a node of type JSXAttr.

fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName

Visit a node of type JSXAttrName.

fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread

Visit a node of type JSXAttrOrSpread.

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, ) -> Vec<JSXAttrOrSpread>

Visit a node of type Vec < JSXAttrOrSpread >.

fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue

Visit a node of type JSXAttrValue.

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, ) -> JSXClosingElement

Visit a node of type JSXClosingElement.

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, ) -> JSXClosingFragment

Visit a node of type JSXClosingFragment.

fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement

Visit a node of type JSXElement.

fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild

Visit a node of type JSXElementChild.

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, ) -> Vec<JSXElementChild>

Visit a node of type Vec < JSXElementChild >.

fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName

Visit a node of type JSXElementName.

fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr

Visit a node of type JSXEmptyExpr.

fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr

Visit a node of type JSXExpr.

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, ) -> JSXExprContainer

Visit a node of type JSXExprContainer.

fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment

Visit a node of type JSXFragment.

fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr

Visit a node of type JSXMemberExpr.

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, ) -> JSXNamespacedName

Visit a node of type JSXNamespacedName.

fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject

Visit a node of type JSXObject.

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, ) -> JSXOpeningElement

Visit a node of type JSXOpeningElement.

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, ) -> JSXOpeningFragment

Visit a node of type JSXOpeningFragment.

fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild

Visit a node of type JSXSpreadChild.

fn fold_jsx_text(&mut self, node: JSXText) -> JSXText

Visit a node of type JSXText.

fn fold_key(&mut self, node: Key) -> Key

Visit a node of type Key.

fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp

Visit a node of type KeyValuePatProp.

fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp

Visit a node of type KeyValueProp.

fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt

Visit a node of type LabeledStmt.

fn fold_lit(&mut self, node: Lit) -> Lit

Visit a node of type Lit.

fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr

Visit a node of type MemberExpr.

fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp

Visit a node of type MemberProp.

fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr

Visit a node of type MetaPropExpr.

fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind

Visit a node of type MetaPropKind.

fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind

Visit a node of type MethodKind.

fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp

Visit a node of type MethodProp.

fn fold_module(&mut self, node: Module) -> Module

Visit a node of type Module.

fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl

Visit a node of type ModuleDecl.

fn fold_module_export_name( &mut self, node: ModuleExportName, ) -> ModuleExportName

Visit a node of type ModuleExportName.

fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem

Visit a node of type ModuleItem.

fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem>

Visit a node of type Vec < ModuleItem >.

fn fold_named_export(&mut self, node: NamedExport) -> NamedExport

Visit a node of type NamedExport.

fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr

Visit a node of type NewExpr.

fn fold_null(&mut self, node: Null) -> Null

Visit a node of type Null.

fn fold_number(&mut self, node: Number) -> Number

Visit a node of type Number.

fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit

Visit a node of type ObjectLit.

fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat

Visit a node of type ObjectPat.

fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp

Visit a node of type ObjectPatProp.

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, ) -> Vec<ObjectPatProp>

Visit a node of type Vec < ObjectPatProp >.

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, ) -> Option<Accessibility>

Visit a node of type Option < Accessibility >.

fn fold_opt_atom(&mut self, node: Option<Atom>) -> Option<Atom>

Visit a node of type Option < swc_atoms :: Atom >.

fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt>

Visit a node of type Option < BlockStmt >.

fn fold_opt_call(&mut self, node: OptCall) -> OptCall

Visit a node of type OptCall.

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, ) -> Option<CatchClause>

Visit a node of type Option < CatchClause >.

fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase

Visit a node of type OptChainBase.

fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr

Visit a node of type OptChainExpr.

fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>>

Visit a node of type Option < Box < Expr > >.

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, ) -> Option<ExprOrSpread>

Visit a node of type Option < ExprOrSpread >.

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, ) -> Option<Vec<ExprOrSpread>>

Visit a node of type Option < Vec < ExprOrSpread > >.

fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident>

Visit a node of type Option < Ident >.

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, ) -> Option<JSXAttrValue>

Visit a node of type Option < JSXAttrValue >.

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, ) -> Option<JSXClosingElement>

Visit a node of type Option < JSXClosingElement >.

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, ) -> Option<ModuleExportName>

Visit a node of type Option < ModuleExportName >.

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, ) -> Option<Box<ObjectLit>>

Visit a node of type Option < Box < ObjectLit > >.

fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat>

Visit a node of type Option < Pat >.

fn fold_opt_span(&mut self, node: Option<Span>) -> Option<Span>

Visit a node of type Option < swc_common :: Span >.

fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>>

Visit a node of type Option < Box < Stmt > >.

fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>>

Visit a node of type Option < Box < Str > >.

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, ) -> Option<TruePlusMinus>

Visit a node of type Option < TruePlusMinus >.

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, ) -> Option<TsEntityName>

Visit a node of type Option < TsEntityName >.

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, ) -> Option<TsNamespaceBody>

Visit a node of type Option < TsNamespaceBody >.

fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>>

Visit a node of type Option < Box < TsType > >.

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, ) -> Option<Box<TsTypeAnn>>

Visit a node of type Option < Box < TsTypeAnn > >.

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, ) -> Option<Box<TsTypeParamDecl>>

Visit a node of type Option < Box < TsTypeParamDecl > >.

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, ) -> Option<Box<TsTypeParamInstantiation>>

Visit a node of type Option < Box < TsTypeParamInstantiation > >.

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, ) -> Option<VarDeclOrExpr>

Visit a node of type Option < VarDeclOrExpr >.

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, ) -> Vec<Option<ExprOrSpread>>

Visit a node of type Vec < Option < ExprOrSpread > >.

fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>>

Visit a node of type Vec < Option < Pat > >.

fn fold_param(&mut self, node: Param) -> Param

Visit a node of type Param.

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, ) -> ParamOrTsParamProp

Visit a node of type ParamOrTsParamProp.

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, ) -> Vec<ParamOrTsParamProp>

Visit a node of type Vec < ParamOrTsParamProp >.

fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param>

Visit a node of type Vec < Param >.

fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr

Visit a node of type ParenExpr.

fn fold_pat(&mut self, node: Pat) -> Pat

Visit a node of type Pat.

fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat>

Visit a node of type Vec < Pat >.

fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod

Visit a node of type PrivateMethod.

fn fold_private_name(&mut self, node: PrivateName) -> PrivateName

Visit a node of type PrivateName.

fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp

Visit a node of type PrivateProp.

fn fold_program(&mut self, node: Program) -> Program

Visit a node of type Program.

fn fold_prop(&mut self, node: Prop) -> Prop

Visit a node of type Prop.

fn fold_prop_name(&mut self, node: PropName) -> PropName

Visit a node of type PropName.

fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread

Visit a node of type PropOrSpread.

fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread>

Visit a node of type Vec < PropOrSpread >.

fn fold_regex(&mut self, node: Regex) -> Regex

Visit a node of type Regex.

fn fold_rest_pat(&mut self, node: RestPat) -> RestPat

Visit a node of type RestPat.

fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt

Visit a node of type ReturnStmt.

fn fold_script(&mut self, node: Script) -> Script

Visit a node of type Script.

fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr

Visit a node of type SeqExpr.

fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp

Visit a node of type SetterProp.

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, ) -> SimpleAssignTarget

Visit a node of type SimpleAssignTarget.

fn fold_span(&mut self, node: Span) -> Span

Visit a node of type swc_common :: Span.

fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement

Visit a node of type SpreadElement.

fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock

Visit a node of type StaticBlock.

fn fold_stmt(&mut self, node: Stmt) -> Stmt

Visit a node of type Stmt.

fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt>

Visit a node of type Vec < Stmt >.

fn fold_str(&mut self, node: Str) -> Str

Visit a node of type Str.

fn fold_super(&mut self, node: Super) -> Super

Visit a node of type Super.

fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp

Visit a node of type SuperProp.

fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr

Visit a node of type SuperPropExpr.

fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase

Visit a node of type SwitchCase.

fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase>

Visit a node of type Vec < SwitchCase >.

fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt

Visit a node of type SwitchStmt.

fn fold_syntax_context(&mut self, node: SyntaxContext) -> SyntaxContext

Visit a node of type swc_common :: SyntaxContext.

fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl

Visit a node of type TaggedTpl.

fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr

Visit a node of type ThisExpr.

fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt

Visit a node of type ThrowStmt.

fn fold_tpl(&mut self, node: Tpl) -> Tpl

Visit a node of type Tpl.

fn fold_tpl_element(&mut self, node: TplElement) -> TplElement

Visit a node of type TplElement.

fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement>

Visit a node of type Vec < TplElement >.

fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus

Visit a node of type TruePlusMinus.

fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt

Visit a node of type TryStmt.

fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType

Visit a node of type TsArrayType.

fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr

Visit a node of type TsAsExpr.

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, ) -> TsCallSignatureDecl

Visit a node of type TsCallSignatureDecl.

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, ) -> TsConditionalType

Visit a node of type TsConditionalType.

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, ) -> TsConstAssertion

Visit a node of type TsConstAssertion.

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, ) -> TsConstructSignatureDecl

Visit a node of type TsConstructSignatureDecl.

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, ) -> TsConstructorType

Visit a node of type TsConstructorType.

fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName

Visit a node of type TsEntityName.

fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl

Visit a node of type TsEnumDecl.

fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember

Visit a node of type TsEnumMember.

fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId

Visit a node of type TsEnumMemberId.

fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember>

Visit a node of type Vec < TsEnumMember >.

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, ) -> TsExportAssignment

Visit a node of type TsExportAssignment.

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, ) -> TsExprWithTypeArgs

Visit a node of type TsExprWithTypeArgs.

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, ) -> Vec<TsExprWithTypeArgs>

Visit a node of type Vec < TsExprWithTypeArgs >.

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, ) -> TsExternalModuleRef

Visit a node of type TsExternalModuleRef.

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, ) -> TsFnOrConstructorType

Visit a node of type TsFnOrConstructorType.

fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam

Visit a node of type TsFnParam.

fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam>

Visit a node of type Vec < TsFnParam >.

fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType

Visit a node of type TsFnType.

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, ) -> TsGetterSignature

Visit a node of type TsGetterSignature.

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, ) -> TsImportEqualsDecl

Visit a node of type TsImportEqualsDecl.

fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType

Visit a node of type TsImportType.

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, ) -> TsIndexSignature

Visit a node of type TsIndexSignature.

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, ) -> TsIndexedAccessType

Visit a node of type TsIndexedAccessType.

fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType

Visit a node of type TsInferType.

fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation

Visit a node of type TsInstantiation.

fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody

Visit a node of type TsInterfaceBody.

fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl

Visit a node of type TsInterfaceDecl.

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, ) -> TsIntersectionType

Visit a node of type TsIntersectionType.

fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType

Visit a node of type TsKeywordType.

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, ) -> TsKeywordTypeKind

Visit a node of type TsKeywordTypeKind.

fn fold_ts_lit(&mut self, node: TsLit) -> TsLit

Visit a node of type TsLit.

fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType

Visit a node of type TsLitType.

fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType

Visit a node of type TsMappedType.

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, ) -> TsMethodSignature

Visit a node of type TsMethodSignature.

fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock

Visit a node of type TsModuleBlock.

fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl

Visit a node of type TsModuleDecl.

fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName

Visit a node of type TsModuleName.

fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef

Visit a node of type TsModuleRef.

fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody

Visit a node of type TsNamespaceBody.

fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl

Visit a node of type TsNamespaceDecl.

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, ) -> TsNamespaceExportDecl

Visit a node of type TsNamespaceExportDecl.

fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr

Visit a node of type TsNonNullExpr.

fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType

Visit a node of type TsOptionalType.

fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp

Visit a node of type TsParamProp.

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, ) -> TsParamPropParam

Visit a node of type TsParamPropParam.

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, ) -> TsParenthesizedType

Visit a node of type TsParenthesizedType.

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, ) -> TsPropertySignature

Visit a node of type TsPropertySignature.

fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName

Visit a node of type TsQualifiedName.

fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType

Visit a node of type TsRestType.

fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr

Visit a node of type TsSatisfiesExpr.

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, ) -> TsSetterSignature

Visit a node of type TsSetterSignature.

fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType

Visit a node of type TsThisType.

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, ) -> TsThisTypeOrIdent

Visit a node of type TsThisTypeOrIdent.

fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType

Visit a node of type TsTplLitType.

fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement

Visit a node of type TsTupleElement.

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, ) -> Vec<TsTupleElement>

Visit a node of type Vec < TsTupleElement >.

fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType

Visit a node of type TsTupleType.

fn fold_ts_type(&mut self, node: TsType) -> TsType

Visit a node of type TsType.

fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl

Visit a node of type TsTypeAliasDecl.

fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn

Visit a node of type TsTypeAnn.

fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion

Visit a node of type TsTypeAssertion.

fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement

Visit a node of type TsTypeElement.

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, ) -> Vec<TsTypeElement>

Visit a node of type Vec < TsTypeElement >.

fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit

Visit a node of type TsTypeLit.

fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator

Visit a node of type TsTypeOperator.

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, ) -> TsTypeOperatorOp

Visit a node of type TsTypeOperatorOp.

fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam

Visit a node of type TsTypeParam.

fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl

Visit a node of type TsTypeParamDecl.

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, ) -> TsTypeParamInstantiation

Visit a node of type TsTypeParamInstantiation.

fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam>

Visit a node of type Vec < TsTypeParam >.

fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate

Visit a node of type TsTypePredicate.

fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery

Visit a node of type TsTypeQuery.

fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr

Visit a node of type TsTypeQueryExpr.

fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef

Visit a node of type TsTypeRef.

fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>>

Visit a node of type Vec < Box < TsType > >.

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, ) -> TsUnionOrIntersectionType

Visit a node of type TsUnionOrIntersectionType.

fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType

Visit a node of type TsUnionType.

fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr

Visit a node of type UnaryExpr.

fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp

Visit a node of type UnaryOp.

fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr

Visit a node of type UpdateExpr.

fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp

Visit a node of type UpdateOp.

fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl

Visit a node of type UsingDecl.

fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl

Visit a node of type VarDecl.

fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind

Visit a node of type VarDeclKind.

fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr

Visit a node of type VarDeclOrExpr.

fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator

Visit a node of type VarDeclarator.

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, ) -> Vec<VarDeclarator>

Visit a node of type Vec < VarDeclarator >.

fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt

Visit a node of type WhileStmt.

fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt

Visit a node of type WithStmt.

fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr

Visit a node of type YieldExpr.

impl<A, B> Fold for Either<A, B>

where A: Fold, B: Fold,

fn fold_absolute_color_base( &mut self, node: AbsoluteColorBase, ) -> AbsoluteColorBase

Visit a node of type AbsoluteColorBase.

fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue

Visit a node of type AlphaValue.

fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB

Visit a node of type AnPlusB.

fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation

Visit a node of type AnPlusBNotation.

fn fold_angle(&mut self, node: Angle) -> Angle

Visit a node of type Angle.

fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage

Visit a node of type AnglePercentage.

fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace

Visit a node of type AnyNamespace.

fn fold_at_rule(&mut self, node: AtRule) -> AtRule

Visit a node of type AtRule.

fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName

Visit a node of type AtRuleName.

fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude

Visit a node of type AtRulePrelude.

fn fold_atom(&mut self, node: Atom) -> Atom

Visit a node of type swc_atoms :: Atom.

fn fold_attribute_selector( &mut self, node: AttributeSelector, ) -> AttributeSelector

Visit a node of type AttributeSelector.

fn fold_attribute_selector_matcher( &mut self, node: AttributeSelectorMatcher, ) -> AttributeSelectorMatcher

Visit a node of type AttributeSelectorMatcher.

fn fold_attribute_selector_matcher_value( &mut self, node: AttributeSelectorMatcherValue, ) -> AttributeSelectorMatcherValue

Visit a node of type AttributeSelectorMatcherValue.

fn fold_attribute_selector_modifier( &mut self, node: AttributeSelectorModifier, ) -> AttributeSelectorModifier

Visit a node of type AttributeSelectorModifier.

fn fold_attribute_selector_value( &mut self, node: AttributeSelectorValue, ) -> AttributeSelectorValue

Visit a node of type AttributeSelectorValue.

fn fold_bin_op(&mut self, node: BinOp) -> BinOp

Visit a node of type BinOp.

fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator

Visit a node of type CalcOperator.

fn fold_calc_operator_type( &mut self, node: CalcOperatorType, ) -> CalcOperatorType

Visit a node of type CalcOperatorType.

fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct

Visit a node of type CalcProduct.

fn fold_calc_product_or_operator( &mut self, node: CalcProductOrOperator, ) -> CalcProductOrOperator

Visit a node of type CalcProductOrOperator.

fn fold_calc_product_or_operators( &mut self, node: Vec<CalcProductOrOperator>, ) -> Vec<CalcProductOrOperator>

Visit a node of type Vec < CalcProductOrOperator >.

fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum

Visit a node of type CalcSum.

fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue

Visit a node of type CalcValue.

fn fold_calc_value_or_operator( &mut self, node: CalcValueOrOperator, ) -> CalcValueOrOperator

Visit a node of type CalcValueOrOperator.

fn fold_calc_value_or_operators( &mut self, node: Vec<CalcValueOrOperator>, ) -> Vec<CalcValueOrOperator>

Visit a node of type Vec < CalcValueOrOperator >.

fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector

Visit a node of type ClassSelector.

fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent

Visit a node of type CmykComponent.

fn fold_color(&mut self, node: Color) -> Color

Visit a node of type Color.

fn fold_color_profile_name( &mut self, node: ColorProfileName, ) -> ColorProfileName

Visit a node of type ColorProfileName.

fn fold_combinator(&mut self, node: Combinator) -> Combinator

Visit a node of type Combinator.

fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue

Visit a node of type CombinatorValue.

fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector

Visit a node of type ComplexSelector.

fn fold_complex_selector_children( &mut self, node: ComplexSelectorChildren, ) -> ComplexSelectorChildren

Visit a node of type ComplexSelectorChildren.

fn fold_complex_selector_childrens( &mut self, node: Vec<ComplexSelectorChildren>, ) -> Vec<ComplexSelectorChildren>

Visit a node of type Vec < ComplexSelectorChildren >.

fn fold_complex_selectors( &mut self, node: Vec<ComplexSelector>, ) -> Vec<ComplexSelector>

Visit a node of type Vec < ComplexSelector >.

fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue

Visit a node of type ComponentValue.

fn fold_component_values( &mut self, node: Vec<ComponentValue>, ) -> Vec<ComponentValue>

Visit a node of type Vec < ComponentValue >.

fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector

Visit a node of type CompoundSelector.

fn fold_compound_selector_list( &mut self, node: CompoundSelectorList, ) -> CompoundSelectorList

Visit a node of type CompoundSelectorList.

fn fold_compound_selectors( &mut self, node: Vec<CompoundSelector>, ) -> Vec<CompoundSelector>

Visit a node of type Vec < CompoundSelector >.

fn fold_container_condition( &mut self, node: ContainerCondition, ) -> ContainerCondition

Visit a node of type ContainerCondition.

fn fold_container_name(&mut self, node: ContainerName) -> ContainerName

Visit a node of type ContainerName.

fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery

Visit a node of type ContainerQuery.

fn fold_container_query_and( &mut self, node: ContainerQueryAnd, ) -> ContainerQueryAnd

Visit a node of type ContainerQueryAnd.

fn fold_container_query_not( &mut self, node: ContainerQueryNot, ) -> ContainerQueryNot

Visit a node of type ContainerQueryNot.

fn fold_container_query_or( &mut self, node: ContainerQueryOr, ) -> ContainerQueryOr

Visit a node of type ContainerQueryOr.

fn fold_container_query_type( &mut self, node: ContainerQueryType, ) -> ContainerQueryType

Visit a node of type ContainerQueryType.

fn fold_container_query_types( &mut self, node: Vec<ContainerQueryType>, ) -> Vec<ContainerQueryType>

Visit a node of type Vec < ContainerQueryType >.

fn fold_custom_highlight_name( &mut self, node: CustomHighlightName, ) -> CustomHighlightName

Visit a node of type CustomHighlightName.

fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent

Visit a node of type CustomIdent.

fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent>

Visit a node of type Vec < CustomIdent >.

fn fold_custom_media_query( &mut self, node: CustomMediaQuery, ) -> CustomMediaQuery

Visit a node of type CustomMediaQuery.

fn fold_custom_media_query_media_type( &mut self, node: CustomMediaQueryMediaType, ) -> CustomMediaQueryMediaType

Visit a node of type CustomMediaQueryMediaType.

fn fold_custom_property_name( &mut self, node: CustomPropertyName, ) -> CustomPropertyName

Visit a node of type CustomPropertyName.

fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent

Visit a node of type DashedIdent.

fn fold_declaration(&mut self, node: Declaration) -> Declaration

Visit a node of type Declaration.

fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName

Visit a node of type DeclarationName.

fn fold_declaration_or_at_rule( &mut self, node: DeclarationOrAtRule, ) -> DeclarationOrAtRule

Visit a node of type DeclarationOrAtRule.

fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter

Visit a node of type Delimiter.

fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue

Visit a node of type DelimiterValue.

fn fold_dimension(&mut self, node: Dimension) -> Dimension

Visit a node of type Dimension.

fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken

Visit a node of type DimensionToken.

fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude

Visit a node of type DocumentPrelude.

fn fold_document_prelude_matching_function( &mut self, node: DocumentPreludeMatchingFunction, ) -> DocumentPreludeMatchingFunction

Visit a node of type DocumentPreludeMatchingFunction.

fn fold_document_prelude_matching_functions( &mut self, node: Vec<DocumentPreludeMatchingFunction>, ) -> Vec<DocumentPreludeMatchingFunction>

Visit a node of type Vec < DocumentPreludeMatchingFunction >.

fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName

Visit a node of type ExtensionName.

fn fold_family_name(&mut self, node: FamilyName) -> FamilyName

Visit a node of type FamilyName.

fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName>

Visit a node of type Vec < FamilyName >.

fn fold_flex(&mut self, node: Flex) -> Flex

Visit a node of type Flex.

fn fold_font_feature_values_prelude( &mut self, node: FontFeatureValuesPrelude, ) -> FontFeatureValuesPrelude

Visit a node of type FontFeatureValuesPrelude.

fn fold_forgiving_complex_selector( &mut self, node: ForgivingComplexSelector, ) -> ForgivingComplexSelector

Visit a node of type ForgivingComplexSelector.

fn fold_forgiving_complex_selectors( &mut self, node: Vec<ForgivingComplexSelector>, ) -> Vec<ForgivingComplexSelector>

Visit a node of type Vec < ForgivingComplexSelector >.

fn fold_forgiving_relative_selector( &mut self, node: ForgivingRelativeSelector, ) -> ForgivingRelativeSelector

Visit a node of type ForgivingRelativeSelector.

fn fold_forgiving_relative_selector_list( &mut self, node: ForgivingRelativeSelectorList, ) -> ForgivingRelativeSelectorList

Visit a node of type ForgivingRelativeSelectorList.

fn fold_forgiving_relative_selectors( &mut self, node: Vec<ForgivingRelativeSelector>, ) -> Vec<ForgivingRelativeSelector>

Visit a node of type Vec < ForgivingRelativeSelector >.

fn fold_forgiving_selector_list( &mut self, node: ForgivingSelectorList, ) -> ForgivingSelectorList

Visit a node of type ForgivingSelectorList.

fn fold_frequency(&mut self, node: Frequency) -> Frequency

Visit a node of type Frequency.

fn fold_frequency_percentage( &mut self, node: FrequencyPercentage, ) -> FrequencyPercentage

Visit a node of type FrequencyPercentage.

fn fold_function(&mut self, node: Function) -> Function

Visit a node of type Function.

fn fold_function_name(&mut self, node: FunctionName) -> FunctionName

Visit a node of type FunctionName.

fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed

Visit a node of type GeneralEnclosed.

fn fold_hex_color(&mut self, node: HexColor) -> HexColor

Visit a node of type HexColor.

fn fold_hue(&mut self, node: Hue) -> Hue

Visit a node of type Hue.

fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector

Visit a node of type IdSelector.

fn fold_ident(&mut self, node: Ident) -> Ident

Visit a node of type Ident.

fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident>

Visit a node of type Vec < Ident >.

fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions

Visit a node of type ImportConditions.

fn fold_import_href(&mut self, node: ImportHref) -> ImportHref

Visit a node of type ImportHref.

fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName

Visit a node of type ImportLayerName.

fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude

Visit a node of type ImportPrelude.

fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag

Visit a node of type ImportantFlag.

fn fold_integer(&mut self, node: Integer) -> Integer

Visit a node of type Integer.

fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock

Visit a node of type KeyframeBlock.

fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector

Visit a node of type KeyframeSelector.

fn fold_keyframe_selectors( &mut self, node: Vec<KeyframeSelector>, ) -> Vec<KeyframeSelector>

Visit a node of type Vec < KeyframeSelector >.

fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName

Visit a node of type KeyframesName.

fn fold_keyframes_pseudo_function( &mut self, node: KeyframesPseudoFunction, ) -> KeyframesPseudoFunction

Visit a node of type KeyframesPseudoFunction.

fn fold_keyframes_pseudo_prefix( &mut self, node: KeyframesPseudoPrefix, ) -> KeyframesPseudoPrefix

Visit a node of type KeyframesPseudoPrefix.

fn fold_layer_name(&mut self, node: LayerName) -> LayerName

Visit a node of type LayerName.

fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList

Visit a node of type LayerNameList.

fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName>

Visit a node of type Vec < LayerName >.

fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude

Visit a node of type LayerPrelude.

fn fold_length(&mut self, node: Length) -> Length

Visit a node of type Length.

fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage

Visit a node of type LengthPercentage.

fn fold_list_of_component_values( &mut self, node: ListOfComponentValues, ) -> ListOfComponentValues

Visit a node of type ListOfComponentValues.

fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd

Visit a node of type MediaAnd.

fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition

Visit a node of type MediaCondition.

fn fold_media_condition_all_type( &mut self, node: MediaConditionAllType, ) -> MediaConditionAllType

Visit a node of type MediaConditionAllType.

fn fold_media_condition_all_types( &mut self, node: Vec<MediaConditionAllType>, ) -> Vec<MediaConditionAllType>

Visit a node of type Vec < MediaConditionAllType >.

fn fold_media_condition_type( &mut self, node: MediaConditionType, ) -> MediaConditionType

Visit a node of type MediaConditionType.

fn fold_media_condition_without_or( &mut self, node: MediaConditionWithoutOr, ) -> MediaConditionWithoutOr

Visit a node of type MediaConditionWithoutOr.

fn fold_media_condition_without_or_type( &mut self, node: MediaConditionWithoutOrType, ) -> MediaConditionWithoutOrType

Visit a node of type MediaConditionWithoutOrType.

fn fold_media_condition_without_or_types( &mut self, node: Vec<MediaConditionWithoutOrType>, ) -> Vec<MediaConditionWithoutOrType>

Visit a node of type Vec < MediaConditionWithoutOrType >.

fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature

Visit a node of type MediaFeature.

fn fold_media_feature_boolean( &mut self, node: MediaFeatureBoolean, ) -> MediaFeatureBoolean

Visit a node of type MediaFeatureBoolean.

fn fold_media_feature_name( &mut self, node: MediaFeatureName, ) -> MediaFeatureName

Visit a node of type MediaFeatureName.

fn fold_media_feature_plain( &mut self, node: MediaFeaturePlain, ) -> MediaFeaturePlain

Visit a node of type MediaFeaturePlain.

fn fold_media_feature_range( &mut self, node: MediaFeatureRange, ) -> MediaFeatureRange

Visit a node of type MediaFeatureRange.

fn fold_media_feature_range_comparison( &mut self, node: MediaFeatureRangeComparison, ) -> MediaFeatureRangeComparison

Visit a node of type MediaFeatureRangeComparison.

fn fold_media_feature_range_interval( &mut self, node: MediaFeatureRangeInterval, ) -> MediaFeatureRangeInterval

Visit a node of type MediaFeatureRangeInterval.

fn fold_media_feature_value( &mut self, node: MediaFeatureValue, ) -> MediaFeatureValue

Visit a node of type MediaFeatureValue.

fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens

Visit a node of type MediaInParens.

fn fold_media_not(&mut self, node: MediaNot) -> MediaNot

Visit a node of type MediaNot.

fn fold_media_or(&mut self, node: MediaOr) -> MediaOr

Visit a node of type MediaOr.

fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery

Visit a node of type MediaQuery.

fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList

Visit a node of type MediaQueryList.

fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery>

Visit a node of type Vec < MediaQuery >.

fn fold_media_type(&mut self, node: MediaType) -> MediaType

Visit a node of type MediaType.

fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace

Visit a node of type NamedNamespace.

fn fold_namespace(&mut self, node: Namespace) -> Namespace

Visit a node of type Namespace.

fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix

Visit a node of type NamespacePrefix.

fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude

Visit a node of type NamespacePrelude.

fn fold_namespace_prelude_uri( &mut self, node: NamespacePreludeUri, ) -> NamespacePreludeUri

Visit a node of type NamespacePreludeUri.

fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector

Visit a node of type NestingSelector.

fn fold_number(&mut self, node: Number) -> Number

Visit a node of type Number.

fn fold_number_type(&mut self, node: NumberType) -> NumberType

Visit a node of type NumberType.

fn fold_opt_at_rule_prelude( &mut self, node: Option<Box<AtRulePrelude>>, ) -> Option<Box<AtRulePrelude>>

Visit a node of type Option < Box < AtRulePrelude > >.

fn fold_opt_atom(&mut self, node: Option<Atom>) -> Option<Atom>

Visit a node of type Option < swc_atoms :: Atom >.

fn fold_opt_attribute_selector_matcher( &mut self, node: Option<AttributeSelectorMatcher>, ) -> Option<AttributeSelectorMatcher>

Visit a node of type Option < AttributeSelectorMatcher >.

fn fold_opt_attribute_selector_modifier( &mut self, node: Option<AttributeSelectorModifier>, ) -> Option<AttributeSelectorModifier>

Visit a node of type Option < AttributeSelectorModifier >.

fn fold_opt_attribute_selector_value( &mut self, node: Option<AttributeSelectorValue>, ) -> Option<AttributeSelectorValue>

Visit a node of type Option < AttributeSelectorValue >.

fn fold_opt_combinator( &mut self, node: Option<Combinator>, ) -> Option<Combinator>

Visit a node of type Option < Combinator >.

fn fold_opt_container_name( &mut self, node: Option<ContainerName>, ) -> Option<ContainerName>

Visit a node of type Option < ContainerName >.

fn fold_opt_forgiving_selector_list( &mut self, node: Option<ForgivingSelectorList>, ) -> Option<ForgivingSelectorList>

Visit a node of type Option < ForgivingSelectorList >.

fn fold_opt_function( &mut self, node: Option<Box<Function>>, ) -> Option<Box<Function>>

Visit a node of type Option < Box < Function > >.

fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident>

Visit a node of type Option < Ident >.

fn fold_opt_import_conditions( &mut self, node: Option<Box<ImportConditions>>, ) -> Option<Box<ImportConditions>>

Visit a node of type Option < Box < ImportConditions > >.

fn fold_opt_import_layer_name( &mut self, node: Option<Box<ImportLayerName>>, ) -> Option<Box<ImportLayerName>>

Visit a node of type Option < Box < ImportLayerName > >.

fn fold_opt_important_flag( &mut self, node: Option<ImportantFlag>, ) -> Option<ImportantFlag>

Visit a node of type Option < ImportantFlag >.

fn fold_opt_media_condition_type( &mut self, node: Option<Box<MediaConditionType>>, ) -> Option<Box<MediaConditionType>>

Visit a node of type Option < Box < MediaConditionType > >.

fn fold_opt_media_query_list( &mut self, node: Option<Box<MediaQueryList>>, ) -> Option<Box<MediaQueryList>>

Visit a node of type Option < Box < MediaQueryList > >.

fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType>

Visit a node of type Option < MediaType >.

fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace>

Visit a node of type Option < Namespace >.

fn fold_opt_namespace_prefix( &mut self, node: Option<NamespacePrefix>, ) -> Option<NamespacePrefix>

Visit a node of type Option < NamespacePrefix >.

fn fold_opt_nesting_selector( &mut self, node: Option<NestingSelector>, ) -> Option<NestingSelector>

Visit a node of type Option < NestingSelector >.

fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number>

Visit a node of type Option < Number >.

fn fold_opt_page_selector_pseudos( &mut self, node: Option<Vec<PageSelectorPseudo>>, ) -> Option<Vec<PageSelectorPseudo>>

Visit a node of type Option < Vec < PageSelectorPseudo > >.

fn fold_opt_page_selector_type( &mut self, node: Option<PageSelectorType>, ) -> Option<PageSelectorType>

Visit a node of type Option < PageSelectorType >.

fn fold_opt_pseudo_class_selector_childrens( &mut self, node: Option<Vec<PseudoClassSelectorChildren>>, ) -> Option<Vec<PseudoClassSelectorChildren>>

Visit a node of type Option < Vec < PseudoClassSelectorChildren > >.

fn fold_opt_pseudo_element_selector_childrens( &mut self, node: Option<Vec<PseudoElementSelectorChildren>>, ) -> Option<Vec<PseudoElementSelectorChildren>>

Visit a node of type Option < Vec < PseudoElementSelectorChildren > >.

fn fold_opt_simple_block( &mut self, node: Option<SimpleBlock>, ) -> Option<SimpleBlock>

Visit a node of type Option < SimpleBlock >.

fn fold_opt_type_selector( &mut self, node: Option<Box<TypeSelector>>, ) -> Option<Box<TypeSelector>>

Visit a node of type Option < Box < TypeSelector > >.

fn fold_opt_url_modifiers( &mut self, node: Option<Vec<UrlModifier>>, ) -> Option<Vec<UrlModifier>>

Visit a node of type Option < Vec < UrlModifier > >.

fn fold_opt_url_value( &mut self, node: Option<Box<UrlValue>>, ) -> Option<Box<UrlValue>>

Visit a node of type Option < Box < UrlValue > >.

fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector

Visit a node of type PageSelector.

fn fold_page_selector_list( &mut self, node: PageSelectorList, ) -> PageSelectorList

Visit a node of type PageSelectorList.

fn fold_page_selector_pseudo( &mut self, node: PageSelectorPseudo, ) -> PageSelectorPseudo

Visit a node of type PageSelectorPseudo.

fn fold_page_selector_pseudos( &mut self, node: Vec<PageSelectorPseudo>, ) -> Vec<PageSelectorPseudo>

Visit a node of type Vec < PageSelectorPseudo >.

fn fold_page_selector_type( &mut self, node: PageSelectorType, ) -> PageSelectorType

Visit a node of type PageSelectorType.

fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector>

Visit a node of type Vec < PageSelector >.

fn fold_percentage(&mut self, node: Percentage) -> Percentage

Visit a node of type Percentage.

fn fold_pseudo_class_selector( &mut self, node: PseudoClassSelector, ) -> PseudoClassSelector

Visit a node of type PseudoClassSelector.

fn fold_pseudo_class_selector_children( &mut self, node: PseudoClassSelectorChildren, ) -> PseudoClassSelectorChildren

Visit a node of type PseudoClassSelectorChildren.

fn fold_pseudo_class_selector_childrens( &mut self, node: Vec<PseudoClassSelectorChildren>, ) -> Vec<PseudoClassSelectorChildren>

Visit a node of type Vec < PseudoClassSelectorChildren >.

fn fold_pseudo_element_selector( &mut self, node: PseudoElementSelector, ) -> PseudoElementSelector

Visit a node of type PseudoElementSelector.

fn fold_pseudo_element_selector_children( &mut self, node: PseudoElementSelectorChildren, ) -> PseudoElementSelectorChildren

Visit a node of type PseudoElementSelectorChildren.

fn fold_pseudo_element_selector_childrens( &mut self, node: Vec<PseudoElementSelectorChildren>, ) -> Vec<PseudoElementSelectorChildren>

Visit a node of type Vec < PseudoElementSelectorChildren >.

fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule

Visit a node of type QualifiedRule.

fn fold_qualified_rule_prelude( &mut self, node: QualifiedRulePrelude, ) -> QualifiedRulePrelude

Visit a node of type QualifiedRulePrelude.

fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens

Visit a node of type QueryInParens.

fn fold_ratio(&mut self, node: Ratio) -> Ratio

Visit a node of type Ratio.

fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector

Visit a node of type RelativeSelector.

fn fold_relative_selector_list( &mut self, node: RelativeSelectorList, ) -> RelativeSelectorList

Visit a node of type RelativeSelectorList.

fn fold_relative_selectors( &mut self, node: Vec<RelativeSelector>, ) -> Vec<RelativeSelector>

Visit a node of type Vec < RelativeSelector >.

fn fold_resolution(&mut self, node: Resolution) -> Resolution

Visit a node of type Resolution.

fn fold_rule(&mut self, node: Rule) -> Rule

Visit a node of type Rule.

fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule>

Visit a node of type Vec < Rule >.

fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange

Visit a node of type ScopeRange.

fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList

Visit a node of type SelectorList.

fn fold_sequence_of_custom_idents( &mut self, node: SequenceOfCustomIdents, ) -> SequenceOfCustomIdents

Visit a node of type SequenceOfCustomIdents.

fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock

Visit a node of type SimpleBlock.

fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature

Visit a node of type SizeFeature.

fn fold_size_feature_boolean( &mut self, node: SizeFeatureBoolean, ) -> SizeFeatureBoolean

Visit a node of type SizeFeatureBoolean.

fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName

Visit a node of type SizeFeatureName.

fn fold_size_feature_plain( &mut self, node: SizeFeaturePlain, ) -> SizeFeaturePlain

Visit a node of type SizeFeaturePlain.

fn fold_size_feature_range( &mut self, node: SizeFeatureRange, ) -> SizeFeatureRange

Visit a node of type SizeFeatureRange.

fn fold_size_feature_range_comparison( &mut self, node: SizeFeatureRangeComparison, ) -> SizeFeatureRangeComparison

Visit a node of type SizeFeatureRangeComparison.

fn fold_size_feature_range_interval( &mut self, node: SizeFeatureRangeInterval, ) -> SizeFeatureRangeInterval

Visit a node of type SizeFeatureRangeInterval.

fn fold_size_feature_value( &mut self, node: SizeFeatureValue, ) -> SizeFeatureValue

Visit a node of type SizeFeatureValue.

fn fold_span(&mut self, node: Span) -> Span

Visit a node of type swc_common :: Span.

fn fold_str(&mut self, node: Str) -> Str

Visit a node of type Str.

fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock

Visit a node of type StyleBlock.

fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet

Visit a node of type Stylesheet.

fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector

Visit a node of type SubclassSelector.

fn fold_subclass_selectors( &mut self, node: Vec<SubclassSelector>, ) -> Vec<SubclassSelector>

Visit a node of type Vec < SubclassSelector >.

fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd

Visit a node of type SupportsAnd.

fn fold_supports_condition( &mut self, node: SupportsCondition, ) -> SupportsCondition

Visit a node of type SupportsCondition.

fn fold_supports_condition_type( &mut self, node: SupportsConditionType, ) -> SupportsConditionType

Visit a node of type SupportsConditionType.

fn fold_supports_condition_types( &mut self, node: Vec<SupportsConditionType>, ) -> Vec<SupportsConditionType>

Visit a node of type Vec < SupportsConditionType >.

fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature

Visit a node of type SupportsFeature.

fn fold_supports_in_parens( &mut self, node: SupportsInParens, ) -> SupportsInParens

Visit a node of type SupportsInParens.

fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot

Visit a node of type SupportsNot.

fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr

Visit a node of type SupportsOr.

fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector

Visit a node of type TagNameSelector.

fn fold_time(&mut self, node: Time) -> Time

Visit a node of type Time.

fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage

Visit a node of type TimePercentage.

fn fold_token(&mut self, node: Token) -> Token

Visit a node of type Token.

fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan

Visit a node of type TokenAndSpan.

fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector

Visit a node of type TypeSelector.

fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange

Visit a node of type UnicodeRange.

fn fold_universal_selector( &mut self, node: UniversalSelector, ) -> UniversalSelector

Visit a node of type UniversalSelector.

fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension

Visit a node of type UnknownDimension.

fn fold_url(&mut self, node: Url) -> Url

Visit a node of type Url.

fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue

Visit a node of type UrlKeyValue.

fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier

Visit a node of type UrlModifier.

fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier>

Visit a node of type Vec < UrlModifier >.

fn fold_url_value(&mut self, node: UrlValue) -> UrlValue

Visit a node of type UrlValue.

fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw

Visit a node of type UrlValueRaw.

fn fold_wq_name(&mut self, node: WqName) -> WqName

Visit a node of type WqName.

impl<A, B> From<Either<A, B>> for EitherOrBoth<A, B>

fn from(either: Either<A, B>) -> EitherOrBoth<A, B>

Converts to this type from the input type.

impl<L, R> From<Result<R, L>> for Either<L, R>

Convert from Result to Either with Ok => Right and Err => Left.

fn from(r: Result<R, L>) -> Either<L, R>

Converts to this type from the input type.

impl<L, R> Future for Either<L, R>

where L: Future, R: Future<Output = <L as Future>::Output>,

Either<L, R> is a future if both L and R are futures.

type Output = <L as Future>::Output

The type of value produced on completion.

fn poll( self: Pin<&mut Either<L, R>>, cx: &mut Context<'_>, ) -> Poll<<Either<L, R> as Future>::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<L, R> Hash for Either<L, R>

where L: Hash, R: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<L, R> IndexedParallelIterator for Either<L, R>

where L: IndexedParallelIterator, R: IndexedParallelIterator<Item = <L as ParallelIterator>::Item>,

fn drive<C>( self, consumer: C, ) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Result

where C: Consumer<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

fn len(&self) -> usize

Produces an exact count of how many items this iterator will produce, presuming no panic occurs.

fn with_producer<CB>( self, callback: CB, ) -> <CB as ProducerCallback<<Either<L, R> as ParallelIterator>::Item>>::Output

where CB: ProducerCallback<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

fn by_exponential_blocks(self) -> ExponentialBlocks<Self>

Divides an iterator into sequential blocks of exponentially-increasing size.

fn by_uniform_blocks(self, block_size: usize) -> UniformBlocks<Self>

Divides an iterator into sequential blocks of the given size.

fn collect_into_vec(self, target: &mut Vec<Self::Item>)

Collects the results of the iterator into the specified vector. The vector is always cleared before execution begins. If possible, reusing the vector across calls can lead to better performance since it reuses the same backing buffer.

fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)

where Self: IndexedParallelIterator<Item = (A, B)>, A: Send, B: Send,

Unzips the results of the iterator into the specified vectors. The vectors are always cleared before execution begins. If possible, reusing the vectors across calls can lead to better performance since they reuse the same backing buffer.

fn zip<Z>(self, zip_op: Z) -> Zip<Self, <Z as IntoParallelIterator>::Iter>

where Z: IntoParallelIterator, <Z as IntoParallelIterator>::Iter: IndexedParallelIterator,

Iterates over tuples (A, B), where the items A are from this iterator and B are from the iterator given as argument. Like the zip method on ordinary iterators, if the two iterators are of unequal length, you only get the items they have in common.

fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, <Z as IntoParallelIterator>::Iter>

where Z: IntoParallelIterator, <Z as IntoParallelIterator>::Iter: IndexedParallelIterator,

The same as Zip, but requires that both iterators have the same length.

fn interleave<I>( self, other: I, ) -> Interleave<Self, <I as IntoParallelIterator>::Iter>

where I: IntoParallelIterator<Item = Self::Item>, <I as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>,

Interleaves elements of this iterator and the other given iterator. Alternately yields elements from this iterator and the given iterator, until both are exhausted. If one iterator is exhausted before the other, the last elements are provided from the other.

fn interleave_shortest<I>( self, other: I, ) -> InterleaveShortest<Self, <I as IntoParallelIterator>::Iter>

where I: IntoParallelIterator<Item = Self::Item>, <I as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>,

Interleaves elements of this iterator and the other given iterator, until one is exhausted.

fn chunks(self, chunk_size: usize) -> Chunks<Self>

Splits an iterator up into fixed-size chunks.

fn fold_chunks<T, ID, F>( self, chunk_size: usize, identity: ID, fold_op: F, ) -> FoldChunks<Self, ID, F>

where ID: Fn() -> T + Send + Sync, F: Fn(T, Self::Item) -> T + Send + Sync, T: Send,

Splits an iterator into fixed-size chunks, performing a sequential fold() on each chunk.

fn fold_chunks_with<T, F>( self, chunk_size: usize, init: T, fold_op: F, ) -> FoldChunksWith<Self, T, F>

where T: Send + Clone, F: Fn(T, Self::Item) -> T + Send + Sync,

Splits an iterator into fixed-size chunks, performing a sequential fold() on each chunk.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

Lexicographically compares the elements of this ParallelIterator with those of another.

fn eq<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are equal to those of another

fn ne<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are unequal to those of another

fn lt<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are less or equal to those of another.

fn enumerate(self) -> Enumerate<Self>

Yields an index along with each item.

fn step_by(self, step: usize) -> StepBy<Self>

Creates an iterator that steps by the given amount

fn skip(self, n: usize) -> Skip<Self>

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

Creates an iterator that yields the first n elements.

fn position_any<P>(self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for some item in the parallel iterator that matches the given predicate, and returns its index. Like ParallelIterator::find_any, the parallel search will not necessarily find the first match, and once a match is found we’ll attempt to stop processing any more.

fn position_first<P>(self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for the sequentially first item in the parallel iterator that matches the given predicate, and returns its index.

fn position_last<P>(self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for the sequentially last item in the parallel iterator that matches the given predicate, and returns its index.

fn positions<P>(self, predicate: P) -> Positions<Self, P>

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for items in the parallel iterator that match the given predicate, and returns their indices.

fn rev(self) -> Rev<Self>

Produces a new iterator with the elements of this iterator in reverse order.

fn with_min_len(self, min: usize) -> MinLen<Self>

Sets the minimum length of iterators desired to process in each rayon job. Rayon will not split any smaller than this length, but of course an iterator could already be smaller to begin with.

fn with_max_len(self, max: usize) -> MaxLen<Self>

Sets the maximum length of iterators desired to process in each rayon job. Rayon will try to split at least below this length, unless that would put it below the length from with_min_len(). For example, given min=10 and max=15, a length of 16 will not be split any further.

impl<L, R> Into<Result<R, L>> for Either<L, R>

Convert from Either to Result with Right => Ok and Left => Err.

fn into(self) -> Result<R, L>

Converts this type into the (usually inferred) input type.

impl<L, R> Iterator for Either<L, R>

where L: Iterator, R: Iterator<Item = <L as Iterator>::Item>,

Either<L, R> is an iterator if both L and R are iterators.

type Item = <L as Iterator>::Item

The type of the elements being iterated over.

fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn fold<Acc, G>(self, init: Acc, f: G) -> Acc

where G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,

Folds every element into an accumulator by applying an operation, returning the final result.

fn for_each<F>(self, f: F)

where F: FnMut(<Either<L, R> as Iterator>::Item),

Calls a closure on each element of an iterator.

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<<Either<L, R> as Iterator>::Item>

Consumes the iterator, returning the last element.

fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>

Returns the nth element of the iterator.

fn collect<B>(self) -> B

where B: FromIterator<<Either<L, R> as Iterator>::Item>,

Transforms an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where B: Default + Extend<<Either<L, R> as Iterator>::Item>, F: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn all<F>(&mut self, f: F) -> bool

where F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>

where P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where F: FnMut(<Either<L, R> as Iterator>::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where P: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Borrows an iterator, rather than consuming it.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl<L, R> Ord for Either<L, R>

where L: Ord, R: Ord,

fn cmp(&self, other: &Either<L, R>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<L, R, T> ParallelExtend<T> for Either<L, R>

where L: ParallelExtend<T>, R: ParallelExtend<T>, T: Send,

Either<L, R> can be extended if both L and R are parallel extendable.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter.

impl<L, R> ParallelIterator for Either<L, R>

where L: ParallelIterator, R: ParallelIterator<Item = <L as ParallelIterator>::Item>,

Either<L, R> is a parallel iterator if both L and R are parallel iterators.

type Item = <L as ParallelIterator>::Item

The type of item that this parallel iterator produces. For example, if you use the for_each method, this is the type of item that your closure will be invoked with.

fn drive_unindexed<C>( self, consumer: C, ) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Result

where C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

fn opt_len(&self) -> Option<usize>

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

fn for_each<OP>(self, op: OP)

where OP: Fn(Self::Item) + Sync + Send,

Executes OP on each item produced by the iterator, in parallel.

fn for_each_with<OP, T>(self, init: T, op: OP)

where OP: Fn(&mut T, Self::Item) + Sync + Send, T: Send + Clone,

Executes OP on the given init value with each item produced by the iterator, in parallel.

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)

where OP: Fn(&mut T, Self::Item) + Sync + Send, INIT: Fn() -> T + Sync + Send,

Executes OP on a value returned by init with each item produced by the iterator, in parallel.

fn try_for_each<OP, R>(self, op: OP) -> R

where OP: Fn(Self::Item) -> R + Sync + Send, R: Try<Output = ()> + Send,

Executes a fallible OP on each item produced by the iterator, in parallel.

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R

where OP: Fn(&mut T, Self::Item) -> R + Sync + Send, T: Send + Clone, R: Try<Output = ()> + Send,

Executes a fallible OP on the given init value with each item produced by the iterator, in parallel.

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R

where OP: Fn(&mut T, Self::Item) -> R + Sync + Send, INIT: Fn() -> T + Sync + Send, R: Try<Output = ()> + Send,

Executes a fallible OP on a value returned by init with each item produced by the iterator, in parallel.

fn count(self) -> usize

Counts the number of items in this parallel iterator.

fn map<F, R>(self, map_op: F) -> Map<Self, F>

where F: Fn(Self::Item) -> R + Sync + Send, R: Send,

Applies map_op to each item of this iterator, producing a new iterator with the results.

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>

where F: Fn(&mut T, Self::Item) -> R + Sync + Send, T: Send + Clone, R: Send,

Applies map_op to the given init value with each item of this iterator, producing a new iterator with the results.

fn map_init<F, INIT, T, R>( self, init: INIT, map_op: F, ) -> MapInit<Self, INIT, F>

where F: Fn(&mut T, Self::Item) -> R + Sync + Send, INIT: Fn() -> T + Sync + Send, R: Send,

Applies map_op to a value returned by init with each item of this iterator, producing a new iterator with the results.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: 'a + Clone + Send, Self: ParallelIterator<Item = &'a T>,

Creates an iterator which clones all of its elements. This may be useful when you have an iterator over &T, but you need T, and that type implements Clone. See also copied().

fn copied<'a, T>(self) -> Copied<Self>

where T: 'a + Copy + Send, Self: ParallelIterator<Item = &'a T>,

Creates an iterator which copies all of its elements. This may be useful when you have an iterator over &T, but you need T, and that type implements Copy. See also cloned().

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>

where OP: Fn(&Self::Item) + Sync + Send,

Applies inspect_op to a reference to each item of this iterator, producing a new iterator passing through the original items. This is often useful for debugging to see what’s happening in iterator stages.

fn update<F>(self, update_op: F) -> Update<Self, F>

where F: Fn(&mut Self::Item) + Sync + Send,

Mutates each item of this iterator before yielding it.

fn filter<P>(self, filter_op: P) -> Filter<Self, P>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Applies filter_op to each item of this iterator, producing a new iterator with only the items that gave true results.

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>

where P: Fn(Self::Item) -> Option<R> + Sync + Send, R: Send,

Applies filter_op to each item of this iterator to get an Option, producing a new iterator with only the items from Some results.

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>

where F: Fn(Self::Item) -> PI + Sync + Send, PI: IntoParallelIterator,

Applies map_op to each item of this iterator to get nested parallel iterators, producing a new parallel iterator that flattens these back into one.

fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>

where F: Fn(Self::Item) -> SI + Sync + Send, SI: IntoIterator, <SI as IntoIterator>::Item: Send,

Applies map_op to each item of this iterator to get nested serial iterators, producing a new parallel iterator that flattens these back into one.

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item

where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, ID: Fn() -> Self::Item + Sync + Send,

Reduces the items in the iterator into one item using op. The argument identity should be a closure that can produce “identity” value which may be inserted into the sequence as needed to create opportunities for parallel execution. So, for example, if you are doing a summation, then identity() ought to produce something that represents the zero for your type (but consider just calling sum() in that case).

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>

where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,

Reduces the items in the iterator into one item using op. If the iterator is empty, None is returned; otherwise, Some is returned.

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>

where F: Fn(T, Self::Item) -> T + Sync + Send, ID: Fn() -> T + Sync + Send, T: Send,

Parallel fold is similar to sequential fold except that the sequence of items may be subdivided before it is folded. Consider a list of numbers like 22 3 77 89 46. If you used sequential fold to add them (fold(0, |a,b| a+b), you would wind up first adding 0 + 22, then 22 + 3, then 25 + 77, and so forth. The parallel fold works similarly except that it first breaks up your list into sublists, and hence instead of yielding up a single sum at the end, it yields up multiple sums. The number of results is nondeterministic, as is the point where the breaks occur.

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>

where F: Fn(T, Self::Item) -> T + Sync + Send, T: Send + Clone,

Applies fold_op to the given init value with each item of this iterator, finally producing the value for further use.

fn try_fold<T, R, ID, F>( self, identity: ID, fold_op: F, ) -> TryFold<Self, R, ID, F>

where F: Fn(T, Self::Item) -> R + Sync + Send, ID: Fn() -> T + Sync + Send, R: Try<Output = T> + Send,

Performs a fallible parallel fold.

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>

where F: Fn(T, Self::Item) -> R + Sync + Send, R: Try<Output = T> + Send, T: Clone + Send,

Performs a fallible parallel fold with a cloneable init value.

fn sum<S>(self) -> S

where S: Send + Sum<Self::Item> + Sum,

Sums up the items in the iterator.

fn product<P>(self) -> P

where P: Send + Product<Self::Item> + Product,

Multiplies all the items in the iterator.

fn min_by<F>(self, f: F) -> Option<Self::Item>

where F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

Computes the minimum of all the items in the iterator with respect to the given comparison function. If the iterator is empty, None is returned; otherwise, Some(min) is returned.

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>

where K: Ord + Send, F: Sync + Send + Fn(&Self::Item) -> K,

Computes the item that yields the minimum value for the given function. If the iterator is empty, None is returned; otherwise, Some(item) is returned.

fn max_by<F>(self, f: F) -> Option<Self::Item>

where F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

Computes the maximum of all the items in the iterator with respect to the given comparison function. If the iterator is empty, None is returned; otherwise, Some(max) is returned.

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>

where K: Ord + Send, F: Sync + Send + Fn(&Self::Item) -> K,

Computes the item that yields the maximum value for the given function. If the iterator is empty, None is returned; otherwise, Some(item) is returned.

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter>

where C: IntoParallelIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both.

fn find_any<P>(self, predicate: P) -> Option<Self::Item>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for some item in the parallel iterator that matches the given predicate and returns it. This operation is similar to find on sequential iterators but the item returned may not be the first one in the parallel sequence which matches, since we search the entire sequence in parallel.

fn find_first<P>(self, predicate: P) -> Option<Self::Item>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for the sequentially first item in the parallel iterator that matches the given predicate and returns it.

fn find_last<P>(self, predicate: P) -> Option<Self::Item>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for the sequentially last item in the parallel iterator that matches the given predicate and returns it.

fn find_map_any<P, R>(self, predicate: P) -> Option<R>

where P: Fn(Self::Item) -> Option<R> + Sync + Send, R: Send,

Applies the given predicate to the items in the parallel iterator and returns any non-None result of the map operation.

fn find_map_first<P, R>(self, predicate: P) -> Option<R>

where P: Fn(Self::Item) -> Option<R> + Sync + Send, R: Send,

Applies the given predicate to the items in the parallel iterator and returns the sequentially first non-None result of the map operation.

fn find_map_last<P, R>(self, predicate: P) -> Option<R>

where P: Fn(Self::Item) -> Option<R> + Sync + Send, R: Send,

Applies the given predicate to the items in the parallel iterator and returns the sequentially last non-None result of the map operation.

fn any<P>(self, predicate: P) -> bool

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for some item in the parallel iterator that matches the given predicate, and if so returns true. Once a match is found, we’ll attempt to stop process the rest of the items. Proving that there’s no match, returning false, does require visiting every item.

fn all<P>(self, predicate: P) -> bool

where P: Fn(Self::Item) -> bool + Sync + Send,

Tests that every item in the parallel iterator matches the given predicate, and if so returns true. If a counter-example is found, we’ll attempt to stop processing more items, then return false.

fn while_some<T>(self) -> WhileSome<Self>

where Self: ParallelIterator<Item = Option<T>>, T: Send,

Creates an iterator over the Some items of this iterator, halting as soon as any None is found.

fn panic_fuse(self) -> PanicFuse<Self>

Wraps an iterator with a fuse in case of panics, to halt all threads as soon as possible.

fn collect<C>(self) -> C

where C: FromParallelIterator<Self::Item>,

Creates a fresh collection containing all the elements produced by this parallel iterator.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where Self: ParallelIterator<Item = (A, B)>, FromA: Default + Send + ParallelExtend<A>, FromB: Default + Send + ParallelExtend<B>, A: Send, B: Send,

Unzips the items of a parallel iterator into a pair of arbitrary ParallelExtend containers.

fn partition<A, B, P>(self, predicate: P) -> (A, B)

where A: Default + Send + ParallelExtend<Self::Item>, B: Default + Send + ParallelExtend<Self::Item>, P: Fn(&Self::Item) -> bool + Sync + Send,

Partitions the items of a parallel iterator into a pair of arbitrary ParallelExtend containers. Items for which the predicate returns true go into the first container, and the rest go into the second.

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)

where A: Default + Send + ParallelExtend<L>, B: Default + Send + ParallelExtend<R>, P: Fn(Self::Item) -> Either<L, R> + Sync + Send, L: Send, R: Send,

Partitions and maps the items of a parallel iterator into a pair of arbitrary ParallelExtend containers. Either::Left items go into the first container, and Either::Right items go into the second.

fn take_any(self, n: usize) -> TakeAny<Self>

Creates an iterator that yields n elements from anywhere in the original iterator.

fn skip_any(self, n: usize) -> SkipAny<Self>

Creates an iterator that skips n elements from anywhere in the original iterator.

fn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Creates an iterator that takes elements from anywhere in the original iterator until the given predicate returns false.

fn skip_any_while<P>(self, predicate: P) -> SkipAnyWhile<Self, P>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Creates an iterator that skips elements from anywhere in the original iterator until the given predicate returns false.

fn collect_vec_list(self) -> LinkedList<Vec<Self::Item>>

Collects this iterator into a linked list of vectors.

impl<L, R> PartialEq for Either<L, R>

where L: PartialEq, R: PartialEq,

fn eq(&self, other: &Either<L, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<L, R> PartialOrd for Either<L, R>

where L: PartialOrd, R: PartialOrd,

fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<L, R> Pass for Either<L, R>

where L: Pass, R: Pass,

fn process(&mut self, program: &mut Program)

impl<L, R> Read for Either<L, R>

where L: Read, R: Read,

Either<L, R> implements Read if both L and R do.

Requires crate feature "use_std"

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<L, R> Seek for Either<L, R>

where L: Seek, R: Seek,

Either<L, R> implements Seek if both L and R do.

Requires crate feature "use_std"

fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.

impl<A, B> Spanned for Either<A, B>

where A: Spanned, B: Spanned,

fn span(&self) -> Span

Get span of self.

fn span_lo(&self) -> BytePos

fn span_hi(&self) -> BytePos

impl<A, B> Visit for Either<A, B>

where A: Visit, B: Visit,

fn visit_accessibility(&mut self, node: &Accessibility)

Visit a node of type Accessibility.

fn visit_array_lit(&mut self, node: &ArrayLit)

Visit a node of type ArrayLit.

fn visit_array_pat(&mut self, node: &ArrayPat)

Visit a node of type ArrayPat.

fn visit_arrow_expr(&mut self, node: &ArrowExpr)

Visit a node of type ArrowExpr.

fn visit_assign_expr(&mut self, node: &AssignExpr)

Visit a node of type AssignExpr.

fn visit_assign_op(&mut self, node: &AssignOp)

Visit a node of type AssignOp.

fn visit_assign_pat(&mut self, node: &AssignPat)

Visit a node of type AssignPat.

fn visit_assign_pat_prop(&mut self, node: &AssignPatProp)

Visit a node of type AssignPatProp.

fn visit_assign_prop(&mut self, node: &AssignProp)

Visit a node of type AssignProp.

fn visit_assign_target(&mut self, node: &AssignTarget)

Visit a node of type AssignTarget.

fn visit_assign_target_pat(&mut self, node: &AssignTargetPat)

Visit a node of type AssignTargetPat.

fn visit_atom(&mut self, node: &Atom)

Visit a node of type swc_atoms :: Atom.

fn visit_auto_accessor(&mut self, node: &AutoAccessor)

Visit a node of type AutoAccessor.

fn visit_await_expr(&mut self, node: &AwaitExpr)

Visit a node of type AwaitExpr.

fn visit_big_int(&mut self, node: &BigInt)

Visit a node of type BigInt.

fn visit_big_int_value(&mut self, node: &BigInt)

Visit a node of type BigIntValue.

fn visit_bin_expr(&mut self, node: &BinExpr)

Visit a node of type BinExpr.

fn visit_binary_op(&mut self, node: &BinaryOp)

Visit a node of type BinaryOp.

fn visit_binding_ident(&mut self, node: &BindingIdent)

Visit a node of type BindingIdent.

fn visit_block_stmt(&mut self, node: &BlockStmt)

Visit a node of type BlockStmt.

fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr)

Visit a node of type BlockStmtOrExpr.

fn visit_bool(&mut self, node: &Bool)

Visit a node of type Bool.

fn visit_break_stmt(&mut self, node: &BreakStmt)

Visit a node of type BreakStmt.

fn visit_call_expr(&mut self, node: &CallExpr)

Visit a node of type CallExpr.

fn visit_callee(&mut self, node: &Callee)

Visit a node of type Callee.

fn visit_catch_clause(&mut self, node: &CatchClause)

Visit a node of type CatchClause.

fn visit_class(&mut self, node: &Class)

Visit a node of type Class.

fn visit_class_decl(&mut self, node: &ClassDecl)

Visit a node of type ClassDecl.

fn visit_class_expr(&mut self, node: &ClassExpr)

Visit a node of type ClassExpr.

fn visit_class_member(&mut self, node: &ClassMember)

Visit a node of type ClassMember.

fn visit_class_members(&mut self, node: &[ClassMember])

Visit a node of type Vec < ClassMember >.

fn visit_class_method(&mut self, node: &ClassMethod)

Visit a node of type ClassMethod.

fn visit_class_prop(&mut self, node: &ClassProp)

Visit a node of type ClassProp.

fn visit_computed_prop_name(&mut self, node: &ComputedPropName)

Visit a node of type ComputedPropName.

fn visit_cond_expr(&mut self, node: &CondExpr)

Visit a node of type CondExpr.

fn visit_constructor(&mut self, node: &Constructor)

Visit a node of type Constructor.

fn visit_continue_stmt(&mut self, node: &ContinueStmt)

Visit a node of type ContinueStmt.

fn visit_debugger_stmt(&mut self, node: &DebuggerStmt)

Visit a node of type DebuggerStmt.

fn visit_decl(&mut self, node: &Decl)

Visit a node of type Decl.

fn visit_decorator(&mut self, node: &Decorator)

Visit a node of type Decorator.

fn visit_decorators(&mut self, node: &[Decorator])

Visit a node of type Vec < Decorator >.

fn visit_default_decl(&mut self, node: &DefaultDecl)

Visit a node of type DefaultDecl.

fn visit_do_while_stmt(&mut self, node: &DoWhileStmt)

Visit a node of type DoWhileStmt.

fn visit_empty_stmt(&mut self, node: &EmptyStmt)

Visit a node of type EmptyStmt.

fn visit_export_all(&mut self, node: &ExportAll)

Visit a node of type ExportAll.

fn visit_export_decl(&mut self, node: &ExportDecl)

Visit a node of type ExportDecl.

fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl)

Visit a node of type ExportDefaultDecl.

fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr)

Visit a node of type ExportDefaultExpr.

fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier)

Visit a node of type ExportDefaultSpecifier.

fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier)

Visit a node of type ExportNamedSpecifier.

fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier)

Visit a node of type ExportNamespaceSpecifier.

fn visit_export_specifier(&mut self, node: &ExportSpecifier)

Visit a node of type ExportSpecifier.

fn visit_export_specifiers(&mut self, node: &[ExportSpecifier])

Visit a node of type Vec < ExportSpecifier >.

fn visit_expr(&mut self, node: &Expr)

Visit a node of type Expr.

fn visit_expr_or_spread(&mut self, node: &ExprOrSpread)

Visit a node of type ExprOrSpread.

fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread])

Visit a node of type Vec < ExprOrSpread >.

fn visit_expr_stmt(&mut self, node: &ExprStmt)

Visit a node of type ExprStmt.

fn visit_exprs(&mut self, node: &[Box<Expr>])

Visit a node of type Vec < Box < Expr > >.

fn visit_fn_decl(&mut self, node: &FnDecl)

Visit a node of type FnDecl.

fn visit_fn_expr(&mut self, node: &FnExpr)

Visit a node of type FnExpr.

fn visit_for_head(&mut self, node: &ForHead)

Visit a node of type ForHead.

fn visit_for_in_stmt(&mut self, node: &ForInStmt)

Visit a node of type ForInStmt.

fn visit_for_of_stmt(&mut self, node: &ForOfStmt)

Visit a node of type ForOfStmt.

fn visit_for_stmt(&mut self, node: &ForStmt)

Visit a node of type ForStmt.

fn visit_function(&mut self, node: &Function)

Visit a node of type Function.

fn visit_getter_prop(&mut self, node: &GetterProp)

Visit a node of type GetterProp.

fn visit_ident(&mut self, node: &Ident)

Visit a node of type Ident.

fn visit_ident_name(&mut self, node: &IdentName)

Visit a node of type IdentName.

fn visit_if_stmt(&mut self, node: &IfStmt)

Visit a node of type IfStmt.

fn visit_import(&mut self, node: &Import)

Visit a node of type Import.

fn visit_import_decl(&mut self, node: &ImportDecl)

Visit a node of type ImportDecl.

fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier)

Visit a node of type ImportDefaultSpecifier.

fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier)

Visit a node of type ImportNamedSpecifier.

fn visit_import_phase(&mut self, node: &ImportPhase)

Visit a node of type ImportPhase.

fn visit_import_specifier(&mut self, node: &ImportSpecifier)

Visit a node of type ImportSpecifier.

fn visit_import_specifiers(&mut self, node: &[ImportSpecifier])

Visit a node of type Vec < ImportSpecifier >.

fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier)

Visit a node of type ImportStarAsSpecifier.

fn visit_import_with(&mut self, node: &ImportWith)

Visit a node of type ImportWith.

fn visit_import_with_item(&mut self, node: &ImportWithItem)

Visit a node of type ImportWithItem.

fn visit_import_with_items(&mut self, node: &[ImportWithItem])

Visit a node of type Vec < ImportWithItem >.

fn visit_invalid(&mut self, node: &Invalid)

Visit a node of type Invalid.

fn visit_jsx_attr(&mut self, node: &JSXAttr)

Visit a node of type JSXAttr.

fn visit_jsx_attr_name(&mut self, node: &JSXAttrName)

Visit a node of type JSXAttrName.

fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread)

Visit a node of type JSXAttrOrSpread.

fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread])

Visit a node of type Vec < JSXAttrOrSpread >.

fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue)

Visit a node of type JSXAttrValue.

fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement)

Visit a node of type JSXClosingElement.

fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment)

Visit a node of type JSXClosingFragment.

fn visit_jsx_element(&mut self, node: &JSXElement)

Visit a node of type JSXElement.

fn visit_jsx_element_child(&mut self, node: &JSXElementChild)

Visit a node of type JSXElementChild.

fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild])

Visit a node of type Vec < JSXElementChild >.

fn visit_jsx_element_name(&mut self, node: &JSXElementName)

Visit a node of type JSXElementName.

fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr)

Visit a node of type JSXEmptyExpr.

fn visit_jsx_expr(&mut self, node: &JSXExpr)

Visit a node of type JSXExpr.

fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer)

Visit a node of type JSXExprContainer.

fn visit_jsx_fragment(&mut self, node: &JSXFragment)

Visit a node of type JSXFragment.

fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr)

Visit a node of type JSXMemberExpr.

fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName)

Visit a node of type JSXNamespacedName.

fn visit_jsx_object(&mut self, node: &JSXObject)

Visit a node of type JSXObject.

fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement)

Visit a node of type JSXOpeningElement.

fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment)

Visit a node of type JSXOpeningFragment.

fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild)

Visit a node of type JSXSpreadChild.

fn visit_jsx_text(&mut self, node: &JSXText)

Visit a node of type JSXText.

fn visit_key(&mut self, node: &Key)

Visit a node of type Key.

fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp)

Visit a node of type KeyValuePatProp.

fn visit_key_value_prop(&mut self, node: &KeyValueProp)

Visit a node of type KeyValueProp.

fn visit_labeled_stmt(&mut self, node: &LabeledStmt)

Visit a node of type LabeledStmt.

fn visit_lit(&mut self, node: &Lit)

Visit a node of type Lit.

fn visit_member_expr(&mut self, node: &MemberExpr)

Visit a node of type MemberExpr.

fn visit_member_prop(&mut self, node: &MemberProp)

Visit a node of type MemberProp.

fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr)

Visit a node of type MetaPropExpr.

fn visit_meta_prop_kind(&mut self, node: &MetaPropKind)

Visit a node of type MetaPropKind.

fn visit_method_kind(&mut self, node: &MethodKind)

Visit a node of type MethodKind.

fn visit_method_prop(&mut self, node: &MethodProp)

Visit a node of type MethodProp.

fn visit_module(&mut self, node: &Module)

Visit a node of type Module.

fn visit_module_decl(&mut self, node: &ModuleDecl)

Visit a node of type ModuleDecl.

fn visit_module_export_name(&mut self, node: &ModuleExportName)

Visit a node of type ModuleExportName.

fn visit_module_item(&mut self, node: &ModuleItem)

Visit a node of type ModuleItem.

fn visit_module_items(&mut self, node: &[ModuleItem])

Visit a node of type Vec < ModuleItem >.

fn visit_named_export(&mut self, node: &NamedExport)

Visit a node of type NamedExport.

fn visit_new_expr(&mut self, node: &NewExpr)

Visit a node of type NewExpr.

fn visit_null(&mut self, node: &Null)

Visit a node of type Null.

fn visit_number(&mut self, node: &Number)

Visit a node of type Number.

fn visit_object_lit(&mut self, node: &ObjectLit)

Visit a node of type ObjectLit.

fn visit_object_pat(&mut self, node: &ObjectPat)

Visit a node of type ObjectPat.

fn visit_object_pat_prop(&mut self, node: &ObjectPatProp)

Visit a node of type ObjectPatProp.

fn visit_object_pat_props(&mut self, node: &[ObjectPatProp])

Visit a node of type Vec < ObjectPatProp >.

fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>)

Visit a node of type Option < Accessibility >.

fn visit_opt_atom(&mut self, node: &Option<Atom>)

Visit a node of type Option < swc_atoms :: Atom >.

fn visit_opt_block_stmt(&mut self, node: &Option<BlockStmt>)

Visit a node of type Option < BlockStmt >.

fn visit_opt_call(&mut self, node: &OptCall)

Visit a node of type OptCall.

fn visit_opt_catch_clause(&mut self, node: &Option<CatchClause>)

Visit a node of type Option < CatchClause >.

fn visit_opt_chain_base(&mut self, node: &OptChainBase)

Visit a node of type OptChainBase.

fn visit_opt_chain_expr(&mut self, node: &OptChainExpr)

Visit a node of type OptChainExpr.

fn visit_opt_expr(&mut self, node: &Option<Box<Expr>>)

Visit a node of type Option < Box < Expr > >.

fn visit_opt_expr_or_spread(&mut self, node: &Option<ExprOrSpread>)

Visit a node of type Option < ExprOrSpread >.

fn visit_opt_expr_or_spreads(&mut self, node: &Option<Vec<ExprOrSpread>>)

Visit a node of type Option < Vec < ExprOrSpread > >.

fn visit_opt_ident(&mut self, node: &Option<Ident>)

Visit a node of type Option < Ident >.

fn visit_opt_jsx_attr_value(&mut self, node: &Option<JSXAttrValue>)

Visit a node of type Option < JSXAttrValue >.

fn visit_opt_jsx_closing_element(&mut self, node: &Option<JSXClosingElement>)

Visit a node of type Option < JSXClosingElement >.

fn visit_opt_module_export_name(&mut self, node: &Option<ModuleExportName>)

Visit a node of type Option < ModuleExportName >.

fn visit_opt_object_lit(&mut self, node: &Option<Box<ObjectLit>>)

Visit a node of type Option < Box < ObjectLit > >.

fn visit_opt_pat(&mut self, node: &Option<Pat>)

Visit a node of type Option < Pat >.

fn visit_opt_span(&mut self, node: &Option<Span>)

Visit a node of type Option < swc_common :: Span >.

fn visit_opt_stmt(&mut self, node: &Option<Box<Stmt>>)

Visit a node of type Option < Box < Stmt > >.

fn visit_opt_str(&mut self, node: &Option<Box<Str>>)

Visit a node of type Option < Box < Str > >.

fn visit_opt_true_plus_minus(&mut self, node: &Option<TruePlusMinus>)

Visit a node of type Option < TruePlusMinus >.

fn visit_opt_ts_entity_name(&mut self, node: &Option<TsEntityName>)

Visit a node of type Option < TsEntityName >.

fn visit_opt_ts_namespace_body(&mut self, node: &Option<TsNamespaceBody>)

Visit a node of type Option < TsNamespaceBody >.

fn visit_opt_ts_type(&mut self, node: &Option<Box<TsType>>)

Visit a node of type Option < Box < TsType > >.

fn visit_opt_ts_type_ann(&mut self, node: &Option<Box<TsTypeAnn>>)

Visit a node of type Option < Box < TsTypeAnn > >.

fn visit_opt_ts_type_param_decl(&mut self, node: &Option<Box<TsTypeParamDecl>>)

Visit a node of type Option < Box < TsTypeParamDecl > >.

fn visit_opt_ts_type_param_instantiation( &mut self, node: &Option<Box<TsTypeParamInstantiation>>, )

Visit a node of type Option < Box < TsTypeParamInstantiation > >.

fn visit_opt_var_decl_or_expr(&mut self, node: &Option<VarDeclOrExpr>)

Visit a node of type Option < VarDeclOrExpr >.

fn visit_opt_vec_expr_or_spreads(&mut self, node: &[Option<ExprOrSpread>])

Visit a node of type Vec < Option < ExprOrSpread > >.

fn visit_opt_vec_pats(&mut self, node: &[Option<Pat>])

Visit a node of type Vec < Option < Pat > >.

fn visit_param(&mut self, node: &Param)

Visit a node of type Param.

fn visit_param_or_ts_param_prop(&mut self, node: &ParamOrTsParamProp)

Visit a node of type ParamOrTsParamProp.

fn visit_param_or_ts_param_props(&mut self, node: &[ParamOrTsParamProp])

Visit a node of type Vec < ParamOrTsParamProp >.

fn visit_params(&mut self, node: &[Param])

Visit a node of type Vec < Param >.

fn visit_paren_expr(&mut self, node: &ParenExpr)

Visit a node of type ParenExpr.

fn visit_pat(&mut self, node: &Pat)

Visit a node of type Pat.

fn visit_pats(&mut self, node: &[Pat])

Visit a node of type Vec < Pat >.

fn visit_private_method(&mut self, node: &PrivateMethod)

Visit a node of type PrivateMethod.

fn visit_private_name(&mut self, node: &PrivateName)

Visit a node of type PrivateName.

fn visit_private_prop(&mut self, node: &PrivateProp)

Visit a node of type PrivateProp.

fn visit_program(&mut self, node: &Program)

Visit a node of type Program.

fn visit_prop(&mut self, node: &Prop)

Visit a node of type Prop.

fn visit_prop_name(&mut self, node: &PropName)

Visit a node of type PropName.

fn visit_prop_or_spread(&mut self, node: &PropOrSpread)

Visit a node of type PropOrSpread.

fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread])

Visit a node of type Vec < PropOrSpread >.

fn visit_regex(&mut self, node: &Regex)

Visit a node of type Regex.

fn visit_rest_pat(&mut self, node: &RestPat)

Visit a node of type RestPat.

fn visit_return_stmt(&mut self, node: &ReturnStmt)

Visit a node of type ReturnStmt.

fn visit_script(&mut self, node: &Script)

Visit a node of type Script.

fn visit_seq_expr(&mut self, node: &SeqExpr)

Visit a node of type SeqExpr.

fn visit_setter_prop(&mut self, node: &SetterProp)

Visit a node of type SetterProp.

fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget)

Visit a node of type SimpleAssignTarget.

fn visit_span(&mut self, node: &Span)

Visit a node of type swc_common :: Span.

fn visit_spread_element(&mut self, node: &SpreadElement)

Visit a node of type SpreadElement.

fn visit_static_block(&mut self, node: &StaticBlock)

Visit a node of type StaticBlock.

fn visit_stmt(&mut self, node: &Stmt)

Visit a node of type Stmt.

fn visit_stmts(&mut self, node: &[Stmt])

Visit a node of type Vec < Stmt >.

fn visit_str(&mut self, node: &Str)

Visit a node of type Str.

fn visit_super(&mut self, node: &Super)

Visit a node of type Super.

fn visit_super_prop(&mut self, node: &SuperProp)

Visit a node of type SuperProp.

fn visit_super_prop_expr(&mut self, node: &SuperPropExpr)

Visit a node of type SuperPropExpr.

fn visit_switch_case(&mut self, node: &SwitchCase)

Visit a node of type SwitchCase.

fn visit_switch_cases(&mut self, node: &[SwitchCase])

Visit a node of type Vec < SwitchCase >.

fn visit_switch_stmt(&mut self, node: &SwitchStmt)

Visit a node of type SwitchStmt.

fn visit_syntax_context(&mut self, node: &SyntaxContext)

Visit a node of type swc_common :: SyntaxContext.

fn visit_tagged_tpl(&mut self, node: &TaggedTpl)

Visit a node of type TaggedTpl.

fn visit_this_expr(&mut self, node: &ThisExpr)

Visit a node of type ThisExpr.

fn visit_throw_stmt(&mut self, node: &ThrowStmt)

Visit a node of type ThrowStmt.

fn visit_tpl(&mut self, node: &Tpl)

Visit a node of type Tpl.

fn visit_tpl_element(&mut self, node: &TplElement)

Visit a node of type TplElement.

fn visit_tpl_elements(&mut self, node: &[TplElement])

Visit a node of type Vec < TplElement >.

fn visit_true_plus_minus(&mut self, node: &TruePlusMinus)

Visit a node of type TruePlusMinus.

fn visit_try_stmt(&mut self, node: &TryStmt)

Visit a node of type TryStmt.

fn visit_ts_array_type(&mut self, node: &TsArrayType)

Visit a node of type TsArrayType.

fn visit_ts_as_expr(&mut self, node: &TsAsExpr)

Visit a node of type TsAsExpr.

fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl)

Visit a node of type TsCallSignatureDecl.

fn visit_ts_conditional_type(&mut self, node: &TsConditionalType)

Visit a node of type TsConditionalType.

fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion)

Visit a node of type TsConstAssertion.

fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl)

Visit a node of type TsConstructSignatureDecl.

fn visit_ts_constructor_type(&mut self, node: &TsConstructorType)

Visit a node of type TsConstructorType.

fn visit_ts_entity_name(&mut self, node: &TsEntityName)

Visit a node of type TsEntityName.

fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl)

Visit a node of type TsEnumDecl.

fn visit_ts_enum_member(&mut self, node: &TsEnumMember)

Visit a node of type TsEnumMember.

fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId)

Visit a node of type TsEnumMemberId.

fn visit_ts_enum_members(&mut self, node: &[TsEnumMember])

Visit a node of type Vec < TsEnumMember >.

fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment)

Visit a node of type TsExportAssignment.

fn visit_ts_expr_with_type_args(&mut self, node: &TsExprWithTypeArgs)

Visit a node of type TsExprWithTypeArgs.

fn visit_ts_expr_with_type_argss(&mut self, node: &[TsExprWithTypeArgs])

Visit a node of type Vec < TsExprWithTypeArgs >.

fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef)

Visit a node of type TsExternalModuleRef.

fn visit_ts_fn_or_constructor_type(&mut self, node: &TsFnOrConstructorType)

Visit a node of type TsFnOrConstructorType.

fn visit_ts_fn_param(&mut self, node: &TsFnParam)

Visit a node of type TsFnParam.

fn visit_ts_fn_params(&mut self, node: &[TsFnParam])

Visit a node of type Vec < TsFnParam >.

fn visit_ts_fn_type(&mut self, node: &TsFnType)

Visit a node of type TsFnType.

fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature)

Visit a node of type TsGetterSignature.

fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl)

Visit a node of type TsImportEqualsDecl.

fn visit_ts_import_type(&mut self, node: &TsImportType)

Visit a node of type TsImportType.

fn visit_ts_index_signature(&mut self, node: &TsIndexSignature)

Visit a node of type TsIndexSignature.

fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType)

Visit a node of type TsIndexedAccessType.

fn visit_ts_infer_type(&mut self, node: &TsInferType)

Visit a node of type TsInferType.

fn visit_ts_instantiation(&mut self, node: &TsInstantiation)

Visit a node of type TsInstantiation.

fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody)

Visit a node of type TsInterfaceBody.

fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl)

Visit a node of type TsInterfaceDecl.

fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType)

Visit a node of type TsIntersectionType.

fn visit_ts_keyword_type(&mut self, node: &TsKeywordType)

Visit a node of type TsKeywordType.

fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind)

Visit a node of type TsKeywordTypeKind.

fn visit_ts_lit(&mut self, node: &TsLit)

Visit a node of type TsLit.

fn visit_ts_lit_type(&mut self, node: &TsLitType)

Visit a node of type TsLitType.

fn visit_ts_mapped_type(&mut self, node: &TsMappedType)

Visit a node of type TsMappedType.

fn visit_ts_method_signature(&mut self, node: &TsMethodSignature)

Visit a node of type TsMethodSignature.

fn visit_ts_module_block(&mut self, node: &TsModuleBlock)

Visit a node of type TsModuleBlock.

fn visit_ts_module_decl(&mut self, node: &TsModuleDecl)

Visit a node of type TsModuleDecl.

fn visit_ts_module_name(&mut self, node: &TsModuleName)

Visit a node of type TsModuleName.

fn visit_ts_module_ref(&mut self, node: &TsModuleRef)

Visit a node of type TsModuleRef.

fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody)

Visit a node of type TsNamespaceBody.

fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl)

Visit a node of type TsNamespaceDecl.

fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl)

Visit a node of type TsNamespaceExportDecl.

fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr)

Visit a node of type TsNonNullExpr.

fn visit_ts_optional_type(&mut self, node: &TsOptionalType)

Visit a node of type TsOptionalType.

fn visit_ts_param_prop(&mut self, node: &TsParamProp)

Visit a node of type TsParamProp.

fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam)

Visit a node of type TsParamPropParam.

fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType)

Visit a node of type TsParenthesizedType.

fn visit_ts_property_signature(&mut self, node: &TsPropertySignature)

Visit a node of type TsPropertySignature.

fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName)

Visit a node of type TsQualifiedName.

fn visit_ts_rest_type(&mut self, node: &TsRestType)

Visit a node of type TsRestType.

fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr)

Visit a node of type TsSatisfiesExpr.

fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature)

Visit a node of type TsSetterSignature.

fn visit_ts_this_type(&mut self, node: &TsThisType)

Visit a node of type TsThisType.

fn visit_ts_this_type_or_ident(&mut self, node: &TsThisTypeOrIdent)

Visit a node of type TsThisTypeOrIdent.

fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType)

Visit a node of type TsTplLitType.

fn visit_ts_tuple_element(&mut self, node: &TsTupleElement)

Visit a node of type TsTupleElement.

fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement])

Visit a node of type Vec < TsTupleElement >.

fn visit_ts_tuple_type(&mut self, node: &TsTupleType)

Visit a node of type TsTupleType.

fn visit_ts_type(&mut self, node: &TsType)

Visit a node of type TsType.

fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl)

Visit a node of type TsTypeAliasDecl.

fn visit_ts_type_ann(&mut self, node: &TsTypeAnn)

Visit a node of type TsTypeAnn.

fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion)

Visit a node of type TsTypeAssertion.

fn visit_ts_type_element(&mut self, node: &TsTypeElement)

Visit a node of type TsTypeElement.

fn visit_ts_type_elements(&mut self, node: &[TsTypeElement])

Visit a node of type Vec < TsTypeElement >.

fn visit_ts_type_lit(&mut self, node: &TsTypeLit)

Visit a node of type TsTypeLit.

fn visit_ts_type_operator(&mut self, node: &TsTypeOperator)

Visit a node of type TsTypeOperator.

fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp)

Visit a node of type TsTypeOperatorOp.

fn visit_ts_type_param(&mut self, node: &TsTypeParam)

Visit a node of type TsTypeParam.

fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl)

Visit a node of type TsTypeParamDecl.

fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation)

Visit a node of type TsTypeParamInstantiation.

fn visit_ts_type_params(&mut self, node: &[TsTypeParam])

Visit a node of type Vec < TsTypeParam >.

fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate)

Visit a node of type TsTypePredicate.

fn visit_ts_type_query(&mut self, node: &TsTypeQuery)

Visit a node of type TsTypeQuery.

fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr)

Visit a node of type TsTypeQueryExpr.

fn visit_ts_type_ref(&mut self, node: &TsTypeRef)

Visit a node of type TsTypeRef.

fn visit_ts_types(&mut self, node: &[Box<TsType>])

Visit a node of type Vec < Box < TsType > >.

fn visit_ts_union_or_intersection_type( &mut self, node: &TsUnionOrIntersectionType, )

Visit a node of type TsUnionOrIntersectionType.

fn visit_ts_union_type(&mut self, node: &TsUnionType)

Visit a node of type TsUnionType.

fn visit_unary_expr(&mut self, node: &UnaryExpr)

Visit a node of type UnaryExpr.

fn visit_unary_op(&mut self, node: &UnaryOp)

Visit a node of type UnaryOp.

fn visit_update_expr(&mut self, node: &UpdateExpr)

Visit a node of type UpdateExpr.

fn visit_update_op(&mut self, node: &UpdateOp)

Visit a node of type UpdateOp.

fn visit_using_decl(&mut self, node: &UsingDecl)

Visit a node of type UsingDecl.

fn visit_var_decl(&mut self, node: &VarDecl)

Visit a node of type VarDecl.

fn visit_var_decl_kind(&mut self, node: &VarDeclKind)

Visit a node of type VarDeclKind.

fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr)

Visit a node of type VarDeclOrExpr.

fn visit_var_declarator(&mut self, node: &VarDeclarator)

Visit a node of type VarDeclarator.

fn visit_var_declarators(&mut self, node: &[VarDeclarator])

Visit a node of type Vec < VarDeclarator >.

fn visit_while_stmt(&mut self, node: &WhileStmt)

Visit a node of type WhileStmt.

fn visit_with_stmt(&mut self, node: &WithStmt)

Visit a node of type WithStmt.

fn visit_yield_expr(&mut self, node: &YieldExpr)

Visit a node of type YieldExpr.

impl<A, B> Visit for Either<A, B>

where A: Visit, B: Visit,

fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase)

Visit a node of type AbsoluteColorBase.

fn visit_alpha_value(&mut self, node: &AlphaValue)

Visit a node of type AlphaValue.

fn visit_an_plus_b(&mut self, node: &AnPlusB)

Visit a node of type AnPlusB.

fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation)

Visit a node of type AnPlusBNotation.

fn visit_angle(&mut self, node: &Angle)

Visit a node of type Angle.

fn visit_angle_percentage(&mut self, node: &AnglePercentage)

Visit a node of type AnglePercentage.

fn visit_any_namespace(&mut self, node: &AnyNamespace)

Visit a node of type AnyNamespace.

fn visit_at_rule(&mut self, node: &AtRule)

Visit a node of type AtRule.

fn visit_at_rule_name(&mut self, node: &AtRuleName)

Visit a node of type AtRuleName.

fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude)

Visit a node of type AtRulePrelude.

fn visit_atom(&mut self, node: &Atom)

Visit a node of type swc_atoms :: Atom.

fn visit_attribute_selector(&mut self, node: &AttributeSelector)

Visit a node of type AttributeSelector.

fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher)

Visit a node of type AttributeSelectorMatcher.

fn visit_attribute_selector_matcher_value( &mut self, node: &AttributeSelectorMatcherValue, )

Visit a node of type AttributeSelectorMatcherValue.

fn visit_attribute_selector_modifier( &mut self, node: &AttributeSelectorModifier, )

Visit a node of type AttributeSelectorModifier.

fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue)

Visit a node of type AttributeSelectorValue.

fn visit_bin_op(&mut self, node: &BinOp)

Visit a node of type BinOp.

fn visit_calc_operator(&mut self, node: &CalcOperator)

Visit a node of type CalcOperator.

fn visit_calc_operator_type(&mut self, node: &CalcOperatorType)

Visit a node of type CalcOperatorType.

fn visit_calc_product(&mut self, node: &CalcProduct)

Visit a node of type CalcProduct.

fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator)

Visit a node of type CalcProductOrOperator.

fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator])

Visit a node of type Vec < CalcProductOrOperator >.

fn visit_calc_sum(&mut self, node: &CalcSum)

Visit a node of type CalcSum.

fn visit_calc_value(&mut self, node: &CalcValue)

Visit a node of type CalcValue.

fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator)

Visit a node of type CalcValueOrOperator.

fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator])

Visit a node of type Vec < CalcValueOrOperator >.

fn visit_class_selector(&mut self, node: &ClassSelector)

Visit a node of type ClassSelector.

fn visit_cmyk_component(&mut self, node: &CmykComponent)

Visit a node of type CmykComponent.

fn visit_color(&mut self, node: &Color)

Visit a node of type Color.

fn visit_color_profile_name(&mut self, node: &ColorProfileName)

Visit a node of type ColorProfileName.

fn visit_combinator(&mut self, node: &Combinator)

Visit a node of type Combinator.

fn visit_combinator_value(&mut self, node: &CombinatorValue)

Visit a node of type CombinatorValue.

fn visit_complex_selector(&mut self, node: &ComplexSelector)

Visit a node of type ComplexSelector.

fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren)

Visit a node of type ComplexSelectorChildren.

fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren])

Visit a node of type Vec < ComplexSelectorChildren >.

fn visit_complex_selectors(&mut self, node: &[ComplexSelector])

Visit a node of type Vec < ComplexSelector >.

fn visit_component_value(&mut self, node: &ComponentValue)

Visit a node of type ComponentValue.

fn visit_component_values(&mut self, node: &[ComponentValue])

Visit a node of type Vec < ComponentValue >.

fn visit_compound_selector(&mut self, node: &CompoundSelector)

Visit a node of type CompoundSelector.

fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList)

Visit a node of type CompoundSelectorList.

fn visit_compound_selectors(&mut self, node: &[CompoundSelector])

Visit a node of type Vec < CompoundSelector >.

fn visit_container_condition(&mut self, node: &ContainerCondition)

Visit a node of type ContainerCondition.

fn visit_container_name(&mut self, node: &ContainerName)

Visit a node of type ContainerName.

fn visit_container_query(&mut self, node: &ContainerQuery)

Visit a node of type ContainerQuery.

fn visit_container_query_and(&mut self, node: &ContainerQueryAnd)

Visit a node of type ContainerQueryAnd.

fn visit_container_query_not(&mut self, node: &ContainerQueryNot)

Visit a node of type ContainerQueryNot.

fn visit_container_query_or(&mut self, node: &ContainerQueryOr)

Visit a node of type ContainerQueryOr.

fn visit_container_query_type(&mut self, node: &ContainerQueryType)

Visit a node of type ContainerQueryType.

fn visit_container_query_types(&mut self, node: &[ContainerQueryType])

Visit a node of type Vec < ContainerQueryType >.

fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName)

Visit a node of type CustomHighlightName.

fn visit_custom_ident(&mut self, node: &CustomIdent)

Visit a node of type CustomIdent.

fn visit_custom_idents(&mut self, node: &[CustomIdent])

Visit a node of type Vec < CustomIdent >.

fn visit_custom_media_query(&mut self, node: &CustomMediaQuery)

Visit a node of type CustomMediaQuery.

fn visit_custom_media_query_media_type( &mut self, node: &CustomMediaQueryMediaType, )

Visit a node of type CustomMediaQueryMediaType.

fn visit_custom_property_name(&mut self, node: &CustomPropertyName)

Visit a node of type CustomPropertyName.

fn visit_dashed_ident(&mut self, node: &DashedIdent)

Visit a node of type DashedIdent.

fn visit_declaration(&mut self, node: &Declaration)

Visit a node of type Declaration.

fn visit_declaration_name(&mut self, node: &DeclarationName)

Visit a node of type DeclarationName.

fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule)

Visit a node of type DeclarationOrAtRule.

fn visit_delimiter(&mut self, node: &Delimiter)

Visit a node of type Delimiter.

fn visit_delimiter_value(&mut self, node: &DelimiterValue)

Visit a node of type DelimiterValue.

fn visit_dimension(&mut self, node: &Dimension)

Visit a node of type Dimension.

fn visit_dimension_token(&mut self, node: &DimensionToken)

Visit a node of type DimensionToken.

fn visit_document_prelude(&mut self, node: &DocumentPrelude)

Visit a node of type DocumentPrelude.

fn visit_document_prelude_matching_function( &mut self, node: &DocumentPreludeMatchingFunction, )

Visit a node of type DocumentPreludeMatchingFunction.

fn visit_document_prelude_matching_functions( &mut self, node: &[DocumentPreludeMatchingFunction], )

Visit a node of type Vec < DocumentPreludeMatchingFunction >.

fn visit_extension_name(&mut self, node: &ExtensionName)

Visit a node of type ExtensionName.

fn visit_family_name(&mut self, node: &FamilyName)

Visit a node of type FamilyName.

fn visit_family_names(&mut self, node: &[FamilyName])

Visit a node of type Vec < FamilyName >.

fn visit_flex(&mut self, node: &Flex)

Visit a node of type Flex.

fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude)

Visit a node of type FontFeatureValuesPrelude.

fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector)

Visit a node of type ForgivingComplexSelector.

fn visit_forgiving_complex_selectors( &mut self, node: &[ForgivingComplexSelector], )

Visit a node of type Vec < ForgivingComplexSelector >.

fn visit_forgiving_relative_selector( &mut self, node: &ForgivingRelativeSelector, )

Visit a node of type ForgivingRelativeSelector.

fn visit_forgiving_relative_selector_list( &mut self, node: &ForgivingRelativeSelectorList, )

Visit a node of type ForgivingRelativeSelectorList.

fn visit_forgiving_relative_selectors( &mut self, node: &[ForgivingRelativeSelector], )

Visit a node of type Vec < ForgivingRelativeSelector >.

fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList)

Visit a node of type ForgivingSelectorList.

fn visit_frequency(&mut self, node: &Frequency)

Visit a node of type Frequency.

fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage)

Visit a node of type FrequencyPercentage.

fn visit_function(&mut self, node: &Function)

Visit a node of type Function.

fn visit_function_name(&mut self, node: &FunctionName)

Visit a node of type FunctionName.

fn visit_general_enclosed(&mut self, node: &GeneralEnclosed)

Visit a node of type GeneralEnclosed.

fn visit_hex_color(&mut self, node: &HexColor)

Visit a node of type HexColor.

fn visit_hue(&mut self, node: &Hue)

Visit a node of type Hue.

fn visit_id_selector(&mut self, node: &IdSelector)

Visit a node of type IdSelector.

fn visit_ident(&mut self, node: &Ident)

Visit a node of type Ident.

fn visit_idents(&mut self, node: &[Ident])

Visit a node of type Vec < Ident >.

fn visit_import_conditions(&mut self, node: &ImportConditions)

Visit a node of type ImportConditions.

fn visit_import_href(&mut self, node: &ImportHref)

Visit a node of type ImportHref.

fn visit_import_layer_name(&mut self, node: &ImportLayerName)

Visit a node of type ImportLayerName.

fn visit_import_prelude(&mut self, node: &ImportPrelude)

Visit a node of type ImportPrelude.

fn visit_important_flag(&mut self, node: &ImportantFlag)

Visit a node of type ImportantFlag.

fn visit_integer(&mut self, node: &Integer)

Visit a node of type Integer.

fn visit_keyframe_block(&mut self, node: &KeyframeBlock)

Visit a node of type KeyframeBlock.

fn visit_keyframe_selector(&mut self, node: &KeyframeSelector)

Visit a node of type KeyframeSelector.

fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector])

Visit a node of type Vec < KeyframeSelector >.

fn visit_keyframes_name(&mut self, node: &KeyframesName)

Visit a node of type KeyframesName.

fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction)

Visit a node of type KeyframesPseudoFunction.

fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix)

Visit a node of type KeyframesPseudoPrefix.

fn visit_layer_name(&mut self, node: &LayerName)

Visit a node of type LayerName.

fn visit_layer_name_list(&mut self, node: &LayerNameList)

Visit a node of type LayerNameList.

fn visit_layer_names(&mut self, node: &[LayerName])

Visit a node of type Vec < LayerName >.

fn visit_layer_prelude(&mut self, node: &LayerPrelude)

Visit a node of type LayerPrelude.

fn visit_length(&mut self, node: &Length)

Visit a node of type Length.

fn visit_length_percentage(&mut self, node: &LengthPercentage)

Visit a node of type LengthPercentage.

fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues)

Visit a node of type ListOfComponentValues.

fn visit_media_and(&mut self, node: &MediaAnd)

Visit a node of type MediaAnd.

fn visit_media_condition(&mut self, node: &MediaCondition)

Visit a node of type MediaCondition.

fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType)

Visit a node of type MediaConditionAllType.

fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType])

Visit a node of type Vec < MediaConditionAllType >.

fn visit_media_condition_type(&mut self, node: &MediaConditionType)

Visit a node of type MediaConditionType.

fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr)

Visit a node of type MediaConditionWithoutOr.

fn visit_media_condition_without_or_type( &mut self, node: &MediaConditionWithoutOrType, )

Visit a node of type MediaConditionWithoutOrType.

fn visit_media_condition_without_or_types( &mut self, node: &[MediaConditionWithoutOrType], )

Visit a node of type Vec < MediaConditionWithoutOrType >.

fn visit_media_feature(&mut self, node: &MediaFeature)

Visit a node of type MediaFeature.

fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean)

Visit a node of type MediaFeatureBoolean.

fn visit_media_feature_name(&mut self, node: &MediaFeatureName)

Visit a node of type MediaFeatureName.

fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain)

Visit a node of type MediaFeaturePlain.

fn visit_media_feature_range(&mut self, node: &MediaFeatureRange)

Visit a node of type MediaFeatureRange.

fn visit_media_feature_range_comparison( &mut self, node: &MediaFeatureRangeComparison, )

Visit a node of type MediaFeatureRangeComparison.

fn visit_media_feature_range_interval( &mut self, node: &MediaFeatureRangeInterval, )

Visit a node of type MediaFeatureRangeInterval.

fn visit_media_feature_value(&mut self, node: &MediaFeatureValue)

Visit a node of type MediaFeatureValue.

fn visit_media_in_parens(&mut self, node: &MediaInParens)

Visit a node of type MediaInParens.

fn visit_media_not(&mut self, node: &MediaNot)

Visit a node of type MediaNot.

fn visit_media_or(&mut self, node: &MediaOr)

Visit a node of type MediaOr.

fn visit_media_query(&mut self, node: &MediaQuery)

Visit a node of type MediaQuery.

fn visit_media_query_list(&mut self, node: &MediaQueryList)

Visit a node of type MediaQueryList.

fn visit_media_querys(&mut self, node: &[MediaQuery])

Visit a node of type Vec < MediaQuery >.

fn visit_media_type(&mut self, node: &MediaType)

Visit a node of type MediaType.

fn visit_named_namespace(&mut self, node: &NamedNamespace)

Visit a node of type NamedNamespace.

fn visit_namespace(&mut self, node: &Namespace)

Visit a node of type Namespace.

fn visit_namespace_prefix(&mut self, node: &NamespacePrefix)

Visit a node of type NamespacePrefix.

fn visit_namespace_prelude(&mut self, node: &NamespacePrelude)

Visit a node of type NamespacePrelude.

fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri)

Visit a node of type NamespacePreludeUri.

fn visit_nesting_selector(&mut self, node: &NestingSelector)

Visit a node of type NestingSelector.

fn visit_number(&mut self, node: &Number)

Visit a node of type Number.

fn visit_number_type(&mut self, node: &NumberType)

Visit a node of type NumberType.

fn visit_opt_at_rule_prelude(&mut self, node: &Option<Box<AtRulePrelude>>)

Visit a node of type Option < Box < AtRulePrelude > >.

fn visit_opt_atom(&mut self, node: &Option<Atom>)

Visit a node of type Option < swc_atoms :: Atom >.

fn visit_opt_attribute_selector_matcher( &mut self, node: &Option<AttributeSelectorMatcher>, )

Visit a node of type Option < AttributeSelectorMatcher >.

fn visit_opt_attribute_selector_modifier( &mut self, node: &Option<AttributeSelectorModifier>, )

Visit a node of type Option < AttributeSelectorModifier >.

fn visit_opt_attribute_selector_value( &mut self, node: &Option<AttributeSelectorValue>, )

Visit a node of type Option < AttributeSelectorValue >.

fn visit_opt_combinator(&mut self, node: &Option<Combinator>)

Visit a node of type Option < Combinator >.

fn visit_opt_container_name(&mut self, node: &Option<ContainerName>)

Visit a node of type Option < ContainerName >.

fn visit_opt_forgiving_selector_list( &mut self, node: &Option<ForgivingSelectorList>, )

Visit a node of type Option < ForgivingSelectorList >.

fn visit_opt_function(&mut self, node: &Option<Box<Function>>)

Visit a node of type Option < Box < Function > >.

fn visit_opt_ident(&mut self, node: &Option<Ident>)

Visit a node of type Option < Ident >.

fn visit_opt_import_conditions(&mut self, node: &Option<Box<ImportConditions>>)

Visit a node of type Option < Box < ImportConditions > >.

fn visit_opt_import_layer_name(&mut self, node: &Option<Box<ImportLayerName>>)

Visit a node of type Option < Box < ImportLayerName > >.

fn visit_opt_important_flag(&mut self, node: &Option<ImportantFlag>)

Visit a node of type Option < ImportantFlag >.

fn visit_opt_media_condition_type( &mut self, node: &Option<Box<MediaConditionType>>, )

Visit a node of type Option < Box < MediaConditionType > >.

fn visit_opt_media_query_list(&mut self, node: &Option<Box<MediaQueryList>>)

Visit a node of type Option < Box < MediaQueryList > >.

fn visit_opt_media_type(&mut self, node: &Option<MediaType>)

Visit a node of type Option < MediaType >.

fn visit_opt_namespace(&mut self, node: &Option<Namespace>)

Visit a node of type Option < Namespace >.

fn visit_opt_namespace_prefix(&mut self, node: &Option<NamespacePrefix>)

Visit a node of type Option < NamespacePrefix >.

fn visit_opt_nesting_selector(&mut self, node: &Option<NestingSelector>)

Visit a node of type Option < NestingSelector >.

fn visit_opt_number(&mut self, node: &Option<Number>)

Visit a node of type Option < Number >.

fn visit_opt_page_selector_pseudos( &mut self, node: &Option<Vec<PageSelectorPseudo>>, )

Visit a node of type Option < Vec < PageSelectorPseudo > >.

fn visit_opt_page_selector_type(&mut self, node: &Option<PageSelectorType>)

Visit a node of type Option < PageSelectorType >.

fn visit_opt_pseudo_class_selector_childrens( &mut self, node: &Option<Vec<PseudoClassSelectorChildren>>, )

Visit a node of type Option < Vec < PseudoClassSelectorChildren > >.

fn visit_opt_pseudo_element_selector_childrens( &mut self, node: &Option<Vec<PseudoElementSelectorChildren>>, )

Visit a node of type Option < Vec < PseudoElementSelectorChildren > >.

fn visit_opt_simple_block(&mut self, node: &Option<SimpleBlock>)

Visit a node of type Option < SimpleBlock >.

fn visit_opt_type_selector(&mut self, node: &Option<Box<TypeSelector>>)

Visit a node of type Option < Box < TypeSelector > >.

fn visit_opt_url_modifiers(&mut self, node: &Option<Vec<UrlModifier>>)

Visit a node of type Option < Vec < UrlModifier > >.

fn visit_opt_url_value(&mut self, node: &Option<Box<UrlValue>>)

Visit a node of type Option < Box < UrlValue > >.

fn visit_page_selector(&mut self, node: &PageSelector)

Visit a node of type PageSelector.

fn visit_page_selector_list(&mut self, node: &PageSelectorList)

Visit a node of type PageSelectorList.

fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo)

Visit a node of type PageSelectorPseudo.

fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo])

Visit a node of type Vec < PageSelectorPseudo >.

fn visit_page_selector_type(&mut self, node: &PageSelectorType)

Visit a node of type PageSelectorType.

fn visit_page_selectors(&mut self, node: &[PageSelector])

Visit a node of type Vec < PageSelector >.

fn visit_percentage(&mut self, node: &Percentage)

Visit a node of type Percentage.

fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector)

Visit a node of type PseudoClassSelector.

fn visit_pseudo_class_selector_children( &mut self, node: &PseudoClassSelectorChildren, )

Visit a node of type PseudoClassSelectorChildren.

fn visit_pseudo_class_selector_childrens( &mut self, node: &[PseudoClassSelectorChildren], )

Visit a node of type Vec < PseudoClassSelectorChildren >.

fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector)

Visit a node of type PseudoElementSelector.

fn visit_pseudo_element_selector_children( &mut self, node: &PseudoElementSelectorChildren, )

Visit a node of type PseudoElementSelectorChildren.

fn visit_pseudo_element_selector_childrens( &mut self, node: &[PseudoElementSelectorChildren], )

Visit a node of type Vec < PseudoElementSelectorChildren >.

fn visit_qualified_rule(&mut self, node: &QualifiedRule)

Visit a node of type QualifiedRule.

fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude)

Visit a node of type QualifiedRulePrelude.

fn visit_query_in_parens(&mut self, node: &QueryInParens)

Visit a node of type QueryInParens.

fn visit_ratio(&mut self, node: &Ratio)

Visit a node of type Ratio.

fn visit_relative_selector(&mut self, node: &RelativeSelector)

Visit a node of type RelativeSelector.

fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList)

Visit a node of type RelativeSelectorList.

fn visit_relative_selectors(&mut self, node: &[RelativeSelector])

Visit a node of type Vec < RelativeSelector >.

fn visit_resolution(&mut self, node: &Resolution)

Visit a node of type Resolution.

fn visit_rule(&mut self, node: &Rule)

Visit a node of type Rule.

fn visit_rules(&mut self, node: &[Rule])

Visit a node of type Vec < Rule >.

fn visit_scope_range(&mut self, node: &ScopeRange)

Visit a node of type ScopeRange.

fn visit_selector_list(&mut self, node: &SelectorList)

Visit a node of type SelectorList.

fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents)

Visit a node of type SequenceOfCustomIdents.

fn visit_simple_block(&mut self, node: &SimpleBlock)

Visit a node of type SimpleBlock.

fn visit_size_feature(&mut self, node: &SizeFeature)

Visit a node of type SizeFeature.

fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean)

Visit a node of type SizeFeatureBoolean.

fn visit_size_feature_name(&mut self, node: &SizeFeatureName)

Visit a node of type SizeFeatureName.

fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain)

Visit a node of type SizeFeaturePlain.

fn visit_size_feature_range(&mut self, node: &SizeFeatureRange)

Visit a node of type SizeFeatureRange.

fn visit_size_feature_range_comparison( &mut self, node: &SizeFeatureRangeComparison, )

Visit a node of type SizeFeatureRangeComparison.

fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval)

Visit a node of type SizeFeatureRangeInterval.

fn visit_size_feature_value(&mut self, node: &SizeFeatureValue)

Visit a node of type SizeFeatureValue.

fn visit_span(&mut self, node: &Span)

Visit a node of type swc_common :: Span.

fn visit_str(&mut self, node: &Str)

Visit a node of type Str.

fn visit_style_block(&mut self, node: &StyleBlock)

Visit a node of type StyleBlock.

fn visit_stylesheet(&mut self, node: &Stylesheet)

Visit a node of type Stylesheet.

fn visit_subclass_selector(&mut self, node: &SubclassSelector)

Visit a node of type SubclassSelector.

fn visit_subclass_selectors(&mut self, node: &[SubclassSelector])

Visit a node of type Vec < SubclassSelector >.

fn visit_supports_and(&mut self, node: &SupportsAnd)

Visit a node of type SupportsAnd.

fn visit_supports_condition(&mut self, node: &SupportsCondition)

Visit a node of type SupportsCondition.

fn visit_supports_condition_type(&mut self, node: &SupportsConditionType)

Visit a node of type SupportsConditionType.

fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType])

Visit a node of type Vec < SupportsConditionType >.

fn visit_supports_feature(&mut self, node: &SupportsFeature)

Visit a node of type SupportsFeature.

fn visit_supports_in_parens(&mut self, node: &SupportsInParens)

Visit a node of type SupportsInParens.

fn visit_supports_not(&mut self, node: &SupportsNot)

Visit a node of type SupportsNot.

fn visit_supports_or(&mut self, node: &SupportsOr)

Visit a node of type SupportsOr.

fn visit_tag_name_selector(&mut self, node: &TagNameSelector)

Visit a node of type TagNameSelector.

fn visit_time(&mut self, node: &Time)

Visit a node of type Time.

fn visit_time_percentage(&mut self, node: &TimePercentage)

Visit a node of type TimePercentage.

fn visit_token(&mut self, node: &Token)

Visit a node of type Token.

fn visit_token_and_span(&mut self, node: &TokenAndSpan)

Visit a node of type TokenAndSpan.

fn visit_type_selector(&mut self, node: &TypeSelector)

Visit a node of type TypeSelector.

fn visit_unicode_range(&mut self, node: &UnicodeRange)

Visit a node of type UnicodeRange.

fn visit_universal_selector(&mut self, node: &UniversalSelector)

Visit a node of type UniversalSelector.

fn visit_unknown_dimension(&mut self, node: &UnknownDimension)

Visit a node of type UnknownDimension.

fn visit_url(&mut self, node: &Url)

Visit a node of type Url.

fn visit_url_key_value(&mut self, node: &UrlKeyValue)

Visit a node of type UrlKeyValue.

fn visit_url_modifier(&mut self, node: &UrlModifier)

Visit a node of type UrlModifier.

fn visit_url_modifiers(&mut self, node: &[UrlModifier])

Visit a node of type Vec < UrlModifier >.

fn visit_url_value(&mut self, node: &UrlValue)

Visit a node of type UrlValue.

fn visit_url_value_raw(&mut self, node: &UrlValueRaw)

Visit a node of type UrlValueRaw.

fn visit_wq_name(&mut self, node: &WqName)

Visit a node of type WqName.

impl<A, B> VisitMut for Either<A, B>

where A: VisitMut, B: VisitMut,

fn visit_mut_accessibility(&mut self, node: &mut Accessibility)

Visit a node of type Accessibility.

fn visit_mut_array_lit(&mut self, node: &mut ArrayLit)

Visit a node of type ArrayLit.

fn visit_mut_array_pat(&mut self, node: &mut ArrayPat)

Visit a node of type ArrayPat.

fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr)

Visit a node of type ArrowExpr.

fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr)

Visit a node of type AssignExpr.

fn visit_mut_assign_op(&mut self, node: &mut AssignOp)

Visit a node of type AssignOp.

fn visit_mut_assign_pat(&mut self, node: &mut AssignPat)

Visit a node of type AssignPat.

fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp)

Visit a node of type AssignPatProp.

fn visit_mut_assign_prop(&mut self, node: &mut AssignProp)

Visit a node of type AssignProp.

fn visit_mut_assign_target(&mut self, node: &mut AssignTarget)

Visit a node of type AssignTarget.

fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat)

Visit a node of type AssignTargetPat.

fn visit_mut_atom(&mut self, node: &mut Atom)

Visit a node of type swc_atoms :: Atom.

fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor)

Visit a node of type AutoAccessor.

fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr)

Visit a node of type AwaitExpr.

fn visit_mut_big_int(&mut self, node: &mut BigInt)

Visit a node of type BigInt.

fn visit_mut_big_int_value(&mut self, node: &mut BigInt)

Visit a node of type BigIntValue.

fn visit_mut_bin_expr(&mut self, node: &mut BinExpr)

Visit a node of type BinExpr.

fn visit_mut_binary_op(&mut self, node: &mut BinaryOp)

Visit a node of type BinaryOp.

fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent)

Visit a node of type BindingIdent.

fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt)

Visit a node of type BlockStmt.

fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr)

Visit a node of type BlockStmtOrExpr.

fn visit_mut_bool(&mut self, node: &mut Bool)

Visit a node of type Bool.

fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt)

Visit a node of type BreakStmt.

fn visit_mut_call_expr(&mut self, node: &mut CallExpr)

Visit a node of type CallExpr.

fn visit_mut_callee(&mut self, node: &mut Callee)

Visit a node of type Callee.

fn visit_mut_catch_clause(&mut self, node: &mut CatchClause)

Visit a node of type CatchClause.

fn visit_mut_class(&mut self, node: &mut Class)

Visit a node of type Class.

fn visit_mut_class_decl(&mut self, node: &mut ClassDecl)

Visit a node of type ClassDecl.

fn visit_mut_class_expr(&mut self, node: &mut ClassExpr)

Visit a node of type ClassExpr.

fn visit_mut_class_member(&mut self, node: &mut ClassMember)

Visit a node of type ClassMember.

fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>)

Visit a node of type Vec < ClassMember >.

fn visit_mut_class_method(&mut self, node: &mut ClassMethod)

Visit a node of type ClassMethod.

fn visit_mut_class_prop(&mut self, node: &mut ClassProp)

Visit a node of type ClassProp.

fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName)

Visit a node of type ComputedPropName.

fn visit_mut_cond_expr(&mut self, node: &mut CondExpr)

Visit a node of type CondExpr.

fn visit_mut_constructor(&mut self, node: &mut Constructor)

Visit a node of type Constructor.

fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt)

Visit a node of type ContinueStmt.

fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt)

Visit a node of type DebuggerStmt.

fn visit_mut_decl(&mut self, node: &mut Decl)

Visit a node of type Decl.

fn visit_mut_decorator(&mut self, node: &mut Decorator)

Visit a node of type Decorator.

fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>)

Visit a node of type Vec < Decorator >.

fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl)

Visit a node of type DefaultDecl.

fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt)

Visit a node of type DoWhileStmt.

fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt)

Visit a node of type EmptyStmt.

fn visit_mut_export_all(&mut self, node: &mut ExportAll)

Visit a node of type ExportAll.

fn visit_mut_export_decl(&mut self, node: &mut ExportDecl)

Visit a node of type ExportDecl.

fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl)

Visit a node of type ExportDefaultDecl.

fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr)

Visit a node of type ExportDefaultExpr.

fn visit_mut_export_default_specifier( &mut self, node: &mut ExportDefaultSpecifier, )

Visit a node of type ExportDefaultSpecifier.

fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier)

Visit a node of type ExportNamedSpecifier.

fn visit_mut_export_namespace_specifier( &mut self, node: &mut ExportNamespaceSpecifier, )

Visit a node of type ExportNamespaceSpecifier.

fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier)

Visit a node of type ExportSpecifier.

fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>)

Visit a node of type Vec < ExportSpecifier >.

fn visit_mut_expr(&mut self, node: &mut Expr)

Visit a node of type Expr.

fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread)

Visit a node of type ExprOrSpread.

fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>)

Visit a node of type Vec < ExprOrSpread >.

fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt)

Visit a node of type ExprStmt.

fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>)

Visit a node of type Vec < Box < Expr > >.

fn visit_mut_fn_decl(&mut self, node: &mut FnDecl)

Visit a node of type FnDecl.

fn visit_mut_fn_expr(&mut self, node: &mut FnExpr)

Visit a node of type FnExpr.

fn visit_mut_for_head(&mut self, node: &mut ForHead)

Visit a node of type ForHead.

fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt)

Visit a node of type ForInStmt.

fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt)

Visit a node of type ForOfStmt.

fn visit_mut_for_stmt(&mut self, node: &mut ForStmt)

Visit a node of type ForStmt.

fn visit_mut_function(&mut self, node: &mut Function)

Visit a node of type Function.

fn visit_mut_getter_prop(&mut self, node: &mut GetterProp)

Visit a node of type GetterProp.

fn visit_mut_ident(&mut self, node: &mut Ident)

Visit a node of type Ident.

fn visit_mut_ident_name(&mut self, node: &mut IdentName)

Visit a node of type IdentName.

fn visit_mut_if_stmt(&mut self, node: &mut IfStmt)

Visit a node of type IfStmt.

fn visit_mut_import(&mut self, node: &mut Import)

Visit a node of type Import.

fn visit_mut_import_decl(&mut self, node: &mut ImportDecl)

Visit a node of type ImportDecl.

fn visit_mut_import_default_specifier( &mut self, node: &mut ImportDefaultSpecifier, )

Visit a node of type ImportDefaultSpecifier.

fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier)

Visit a node of type ImportNamedSpecifier.

fn visit_mut_import_phase(&mut self, node: &mut ImportPhase)

Visit a node of type ImportPhase.

fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier)

Visit a node of type ImportSpecifier.

fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>)

Visit a node of type Vec < ImportSpecifier >.

fn visit_mut_import_star_as_specifier( &mut self, node: &mut ImportStarAsSpecifier, )

Visit a node of type ImportStarAsSpecifier.

fn visit_mut_import_with(&mut self, node: &mut ImportWith)

Visit a node of type ImportWith.

fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem)

Visit a node of type ImportWithItem.

fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>)

Visit a node of type Vec < ImportWithItem >.

fn visit_mut_invalid(&mut self, node: &mut Invalid)

Visit a node of type Invalid.

fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr)

Visit a node of type JSXAttr.

fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName)

Visit a node of type JSXAttrName.

fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread)

Visit a node of type JSXAttrOrSpread.

fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>)

Visit a node of type Vec < JSXAttrOrSpread >.

fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue)

Visit a node of type JSXAttrValue.

fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement)

Visit a node of type JSXClosingElement.

fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment)

Visit a node of type JSXClosingFragment.

fn visit_mut_jsx_element(&mut self, node: &mut JSXElement)

Visit a node of type JSXElement.

fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild)

Visit a node of type JSXElementChild.

fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>)

Visit a node of type Vec < JSXElementChild >.

fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName)

Visit a node of type JSXElementName.

fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr)

Visit a node of type JSXEmptyExpr.

fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr)

Visit a node of type JSXExpr.

fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer)

Visit a node of type JSXExprContainer.

fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment)

Visit a node of type JSXFragment.

fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr)

Visit a node of type JSXMemberExpr.

fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName)

Visit a node of type JSXNamespacedName.

fn visit_mut_jsx_object(&mut self, node: &mut JSXObject)

Visit a node of type JSXObject.

fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement)

Visit a node of type JSXOpeningElement.

fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment)

Visit a node of type JSXOpeningFragment.

fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild)

Visit a node of type JSXSpreadChild.

fn visit_mut_jsx_text(&mut self, node: &mut JSXText)

Visit a node of type JSXText.

fn visit_mut_key(&mut self, node: &mut Key)

Visit a node of type Key.

fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp)

Visit a node of type KeyValuePatProp.

fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp)

Visit a node of type KeyValueProp.

fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt)

Visit a node of type LabeledStmt.

fn visit_mut_lit(&mut self, node: &mut Lit)

Visit a node of type Lit.

fn visit_mut_member_expr(&mut self, node: &mut MemberExpr)

Visit a node of type MemberExpr.

fn visit_mut_member_prop(&mut self, node: &mut MemberProp)

Visit a node of type MemberProp.

fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr)

Visit a node of type MetaPropExpr.

fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind)

Visit a node of type MetaPropKind.

fn visit_mut_method_kind(&mut self, node: &mut MethodKind)

Visit a node of type MethodKind.

fn visit_mut_method_prop(&mut self, node: &mut MethodProp)

Visit a node of type MethodProp.

fn visit_mut_module(&mut self, node: &mut Module)

Visit a node of type Module.

fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl)

Visit a node of type ModuleDecl.

fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName)

Visit a node of type ModuleExportName.

fn visit_mut_module_item(&mut self, node: &mut ModuleItem)

Visit a node of type ModuleItem.

fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>)

Visit a node of type Vec < ModuleItem >.

fn visit_mut_named_export(&mut self, node: &mut NamedExport)

Visit a node of type NamedExport.

fn visit_mut_new_expr(&mut self, node: &mut NewExpr)

Visit a node of type NewExpr.

fn visit_mut_null(&mut self, node: &mut Null)

Visit a node of type Null.

fn visit_mut_number(&mut self, node: &mut Number)

Visit a node of type Number.

fn visit_mut_object_lit(&mut self, node: &mut ObjectLit)

Visit a node of type ObjectLit.

fn visit_mut_object_pat(&mut self, node: &mut ObjectPat)

Visit a node of type ObjectPat.

fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp)

Visit a node of type ObjectPatProp.

fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>)

Visit a node of type Vec < ObjectPatProp >.

fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>)

Visit a node of type Option < Accessibility >.

fn visit_mut_opt_atom(&mut self, node: &mut Option<Atom>)

Visit a node of type Option < swc_atoms :: Atom >.

fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>)

Visit a node of type Option < BlockStmt >.

fn visit_mut_opt_call(&mut self, node: &mut OptCall)

Visit a node of type OptCall.

fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>)

Visit a node of type Option < CatchClause >.

fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase)

Visit a node of type OptChainBase.

fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr)

Visit a node of type OptChainExpr.

fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>)

Visit a node of type Option < Box < Expr > >.

fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>)

Visit a node of type Option < ExprOrSpread >.

fn visit_mut_opt_expr_or_spreads( &mut self, node: &mut Option<Vec<ExprOrSpread>>, )

Visit a node of type Option < Vec < ExprOrSpread > >.

fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>)

Visit a node of type Option < Ident >.

fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>)

Visit a node of type Option < JSXAttrValue >.

fn visit_mut_opt_jsx_closing_element( &mut self, node: &mut Option<JSXClosingElement>, )

Visit a node of type Option < JSXClosingElement >.

fn visit_mut_opt_module_export_name( &mut self, node: &mut Option<ModuleExportName>, )

Visit a node of type Option < ModuleExportName >.

fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>)

Visit a node of type Option < Box < ObjectLit > >.

fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>)

Visit a node of type Option < Pat >.

fn visit_mut_opt_span(&mut self, node: &mut Option<Span>)

Visit a node of type Option < swc_common :: Span >.

fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>)

Visit a node of type Option < Box < Stmt > >.

fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>)

Visit a node of type Option < Box < Str > >.

fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>)

Visit a node of type Option < TruePlusMinus >.

fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>)

Visit a node of type Option < TsEntityName >.

fn visit_mut_opt_ts_namespace_body( &mut self, node: &mut Option<TsNamespaceBody>, )

Visit a node of type Option < TsNamespaceBody >.

fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>)

Visit a node of type Option < Box < TsType > >.

fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>)

Visit a node of type Option < Box < TsTypeAnn > >.

fn visit_mut_opt_ts_type_param_decl( &mut self, node: &mut Option<Box<TsTypeParamDecl>>, )

Visit a node of type Option < Box < TsTypeParamDecl > >.

fn visit_mut_opt_ts_type_param_instantiation( &mut self, node: &mut Option<Box<TsTypeParamInstantiation>>, )

Visit a node of type Option < Box < TsTypeParamInstantiation > >.

fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>)

Visit a node of type Option < VarDeclOrExpr >.

fn visit_mut_opt_vec_expr_or_spreads( &mut self, node: &mut Vec<Option<ExprOrSpread>>, )

Visit a node of type Vec < Option < ExprOrSpread > >.

fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>)

Visit a node of type Vec < Option < Pat > >.

fn visit_mut_param(&mut self, node: &mut Param)

Visit a node of type Param.

fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp)

Visit a node of type ParamOrTsParamProp.

fn visit_mut_param_or_ts_param_props( &mut self, node: &mut Vec<ParamOrTsParamProp>, )

Visit a node of type Vec < ParamOrTsParamProp >.

fn visit_mut_params(&mut self, node: &mut Vec<Param>)

Visit a node of type Vec < Param >.

fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr)

Visit a node of type ParenExpr.

fn visit_mut_pat(&mut self, node: &mut Pat)

Visit a node of type Pat.

fn visit_mut_pats(&mut self, node: &mut Vec<Pat>)

Visit a node of type Vec < Pat >.

fn visit_mut_private_method(&mut self, node: &mut PrivateMethod)

Visit a node of type PrivateMethod.

fn visit_mut_private_name(&mut self, node: &mut PrivateName)

Visit a node of type PrivateName.

fn visit_mut_private_prop(&mut self, node: &mut PrivateProp)

Visit a node of type PrivateProp.

fn visit_mut_program(&mut self, node: &mut Program)

Visit a node of type Program.

fn visit_mut_prop(&mut self, node: &mut Prop)

Visit a node of type Prop.

fn visit_mut_prop_name(&mut self, node: &mut PropName)

Visit a node of type PropName.

fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread)

Visit a node of type PropOrSpread.

fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>)

Visit a node of type Vec < PropOrSpread >.

fn visit_mut_regex(&mut self, node: &mut Regex)

Visit a node of type Regex.

fn visit_mut_rest_pat(&mut self, node: &mut RestPat)

Visit a node of type RestPat.

fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt)

Visit a node of type ReturnStmt.

fn visit_mut_script(&mut self, node: &mut Script)

Visit a node of type Script.

fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr)

Visit a node of type SeqExpr.

fn visit_mut_setter_prop(&mut self, node: &mut SetterProp)

Visit a node of type SetterProp.

fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget)

Visit a node of type SimpleAssignTarget.

fn visit_mut_span(&mut self, node: &mut Span)

Visit a node of type swc_common :: Span.

fn visit_mut_spread_element(&mut self, node: &mut SpreadElement)

Visit a node of type SpreadElement.

fn visit_mut_static_block(&mut self, node: &mut StaticBlock)

Visit a node of type StaticBlock.

fn visit_mut_stmt(&mut self, node: &mut Stmt)

Visit a node of type Stmt.

fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>)

Visit a node of type Vec < Stmt >.

fn visit_mut_str(&mut self, node: &mut Str)

Visit a node of type Str.

fn visit_mut_super(&mut self, node: &mut Super)

Visit a node of type Super.

fn visit_mut_super_prop(&mut self, node: &mut SuperProp)

Visit a node of type SuperProp.

fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr)

Visit a node of type SuperPropExpr.

fn visit_mut_switch_case(&mut self, node: &mut SwitchCase)

Visit a node of type SwitchCase.

fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>)

Visit a node of type Vec < SwitchCase >.

fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt)

Visit a node of type SwitchStmt.

fn visit_mut_syntax_context(&mut self, node: &mut SyntaxContext)

Visit a node of type swc_common :: SyntaxContext.

fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl)

Visit a node of type TaggedTpl.

fn visit_mut_this_expr(&mut self, node: &mut ThisExpr)

Visit a node of type ThisExpr.

fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt)

Visit a node of type ThrowStmt.

fn visit_mut_tpl(&mut self, node: &mut Tpl)

Visit a node of type Tpl.

fn visit_mut_tpl_element(&mut self, node: &mut TplElement)

Visit a node of type TplElement.

fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>)

Visit a node of type Vec < TplElement >.

fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus)

Visit a node of type TruePlusMinus.

fn visit_mut_try_stmt(&mut self, node: &mut TryStmt)

Visit a node of type TryStmt.

fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType)

Visit a node of type TsArrayType.

fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr)

Visit a node of type TsAsExpr.

fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl)

Visit a node of type TsCallSignatureDecl.

fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType)

Visit a node of type TsConditionalType.

fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion)

Visit a node of type TsConstAssertion.

fn visit_mut_ts_construct_signature_decl( &mut self, node: &mut TsConstructSignatureDecl, )

Visit a node of type TsConstructSignatureDecl.

fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType)

Visit a node of type TsConstructorType.

fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName)

Visit a node of type TsEntityName.

fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl)

Visit a node of type TsEnumDecl.

fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember)

Visit a node of type TsEnumMember.

fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId)

Visit a node of type TsEnumMemberId.

fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>)

Visit a node of type Vec < TsEnumMember >.

fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment)

Visit a node of type TsExportAssignment.

fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs)

Visit a node of type TsExprWithTypeArgs.

fn visit_mut_ts_expr_with_type_argss( &mut self, node: &mut Vec<TsExprWithTypeArgs>, )

Visit a node of type Vec < TsExprWithTypeArgs >.

fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef)

Visit a node of type TsExternalModuleRef.

fn visit_mut_ts_fn_or_constructor_type( &mut self, node: &mut TsFnOrConstructorType, )

Visit a node of type TsFnOrConstructorType.

fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam)

Visit a node of type TsFnParam.

fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>)

Visit a node of type Vec < TsFnParam >.

fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType)

Visit a node of type TsFnType.

fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature)

Visit a node of type TsGetterSignature.

fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl)

Visit a node of type TsImportEqualsDecl.

fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType)

Visit a node of type TsImportType.

fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature)

Visit a node of type TsIndexSignature.

fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType)

Visit a node of type TsIndexedAccessType.

fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType)

Visit a node of type TsInferType.

fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation)

Visit a node of type TsInstantiation.

fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody)

Visit a node of type TsInterfaceBody.

fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl)

Visit a node of type TsInterfaceDecl.

fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType)

Visit a node of type TsIntersectionType.

fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType)

Visit a node of type TsKeywordType.

fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind)

Visit a node of type TsKeywordTypeKind.

fn visit_mut_ts_lit(&mut self, node: &mut TsLit)

Visit a node of type TsLit.

fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType)

Visit a node of type TsLitType.

fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType)

Visit a node of type TsMappedType.

fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature)

Visit a node of type TsMethodSignature.

fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock)

Visit a node of type TsModuleBlock.

fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl)

Visit a node of type TsModuleDecl.

fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName)

Visit a node of type TsModuleName.

fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef)

Visit a node of type TsModuleRef.

fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody)

Visit a node of type TsNamespaceBody.

fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl)

Visit a node of type TsNamespaceDecl.

fn visit_mut_ts_namespace_export_decl( &mut self, node: &mut TsNamespaceExportDecl, )

Visit a node of type TsNamespaceExportDecl.

fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr)

Visit a node of type TsNonNullExpr.

fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType)

Visit a node of type TsOptionalType.

fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp)

Visit a node of type TsParamProp.

fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam)

Visit a node of type TsParamPropParam.

fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType)

Visit a node of type TsParenthesizedType.

fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature)

Visit a node of type TsPropertySignature.

fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName)

Visit a node of type TsQualifiedName.

fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType)

Visit a node of type TsRestType.

fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr)

Visit a node of type TsSatisfiesExpr.

fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature)

Visit a node of type TsSetterSignature.

fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType)

Visit a node of type TsThisType.

fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent)

Visit a node of type TsThisTypeOrIdent.

fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType)

Visit a node of type TsTplLitType.

fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement)

Visit a node of type TsTupleElement.

fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>)

Visit a node of type Vec < TsTupleElement >.

fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType)

Visit a node of type TsTupleType.

fn visit_mut_ts_type(&mut self, node: &mut TsType)

Visit a node of type TsType.

fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl)

Visit a node of type TsTypeAliasDecl.

fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn)

Visit a node of type TsTypeAnn.

fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion)

Visit a node of type TsTypeAssertion.

fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement)

Visit a node of type TsTypeElement.

fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>)

Visit a node of type Vec < TsTypeElement >.

fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit)

Visit a node of type TsTypeLit.

fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator)

Visit a node of type TsTypeOperator.

fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp)

Visit a node of type TsTypeOperatorOp.

fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam)

Visit a node of type TsTypeParam.

fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl)

Visit a node of type TsTypeParamDecl.

fn visit_mut_ts_type_param_instantiation( &mut self, node: &mut TsTypeParamInstantiation, )

Visit a node of type TsTypeParamInstantiation.

fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>)

Visit a node of type Vec < TsTypeParam >.

fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate)

Visit a node of type TsTypePredicate.

fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery)

Visit a node of type TsTypeQuery.

fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr)

Visit a node of type TsTypeQueryExpr.

fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef)

Visit a node of type TsTypeRef.

fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>)

Visit a node of type Vec < Box < TsType > >.

fn visit_mut_ts_union_or_intersection_type( &mut self, node: &mut TsUnionOrIntersectionType, )

Visit a node of type TsUnionOrIntersectionType.

fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType)

Visit a node of type TsUnionType.

fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr)

Visit a node of type UnaryExpr.

fn visit_mut_unary_op(&mut self, node: &mut UnaryOp)

Visit a node of type UnaryOp.

fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr)

Visit a node of type UpdateExpr.

fn visit_mut_update_op(&mut self, node: &mut UpdateOp)

Visit a node of type UpdateOp.

fn visit_mut_using_decl(&mut self, node: &mut UsingDecl)

Visit a node of type UsingDecl.

fn visit_mut_var_decl(&mut self, node: &mut VarDecl)

Visit a node of type VarDecl.

fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind)

Visit a node of type VarDeclKind.

fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr)

Visit a node of type VarDeclOrExpr.

fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator)

Visit a node of type VarDeclarator.

fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>)

Visit a node of type Vec < VarDeclarator >.

fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt)

Visit a node of type WhileStmt.

fn visit_mut_with_stmt(&mut self, node: &mut WithStmt)

Visit a node of type WithStmt.

fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr)

Visit a node of type YieldExpr.

impl<A, B> VisitMut for Either<A, B>

where A: VisitMut, B: VisitMut,

fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase)

Visit a node of type AbsoluteColorBase.

fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue)

Visit a node of type AlphaValue.

fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB)

Visit a node of type AnPlusB.

fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation)

Visit a node of type AnPlusBNotation.

fn visit_mut_angle(&mut self, node: &mut Angle)

Visit a node of type Angle.

fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage)

Visit a node of type AnglePercentage.

fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace)

Visit a node of type AnyNamespace.

fn visit_mut_at_rule(&mut self, node: &mut AtRule)

Visit a node of type AtRule.

fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName)

Visit a node of type AtRuleName.

fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude)

Visit a node of type AtRulePrelude.

fn visit_mut_atom(&mut self, node: &mut Atom)

Visit a node of type swc_atoms :: Atom.

fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector)

Visit a node of type AttributeSelector.

fn visit_mut_attribute_selector_matcher( &mut self, node: &mut AttributeSelectorMatcher, )

Visit a node of type AttributeSelectorMatcher.

fn visit_mut_attribute_selector_matcher_value( &mut self, node: &mut AttributeSelectorMatcherValue, )

Visit a node of type AttributeSelectorMatcherValue.

fn visit_mut_attribute_selector_modifier( &mut self, node: &mut AttributeSelectorModifier, )

Visit a node of type AttributeSelectorModifier.

fn visit_mut_attribute_selector_value( &mut self, node: &mut AttributeSelectorValue, )

Visit a node of type AttributeSelectorValue.

fn visit_mut_bin_op(&mut self, node: &mut BinOp)

Visit a node of type BinOp.

fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator)

Visit a node of type CalcOperator.

fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType)

Visit a node of type CalcOperatorType.

fn visit_mut_calc_product(&mut self, node: &mut CalcProduct)

Visit a node of type CalcProduct.

fn visit_mut_calc_product_or_operator( &mut self, node: &mut CalcProductOrOperator, )

Visit a node of type CalcProductOrOperator.

fn visit_mut_calc_product_or_operators( &mut self, node: &mut Vec<CalcProductOrOperator>, )

Visit a node of type Vec < CalcProductOrOperator >.

fn visit_mut_calc_sum(&mut self, node: &mut CalcSum)

Visit a node of type CalcSum.

fn visit_mut_calc_value(&mut self, node: &mut CalcValue)

Visit a node of type CalcValue.

fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator)

Visit a node of type CalcValueOrOperator.

fn visit_mut_calc_value_or_operators( &mut self, node: &mut Vec<CalcValueOrOperator>, )

Visit a node of type Vec < CalcValueOrOperator >.

fn visit_mut_class_selector(&mut self, node: &mut ClassSelector)

Visit a node of type ClassSelector.

fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent)

Visit a node of type CmykComponent.

fn visit_mut_color(&mut self, node: &mut Color)

Visit a node of type Color.

fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName)

Visit a node of type ColorProfileName.

fn visit_mut_combinator(&mut self, node: &mut Combinator)

Visit a node of type Combinator.

fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue)

Visit a node of type CombinatorValue.

fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector)

Visit a node of type ComplexSelector.

fn visit_mut_complex_selector_children( &mut self, node: &mut ComplexSelectorChildren, )

Visit a node of type ComplexSelectorChildren.

fn visit_mut_complex_selector_childrens( &mut self, node: &mut Vec<ComplexSelectorChildren>, )

Visit a node of type Vec < ComplexSelectorChildren >.

fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>)

Visit a node of type Vec < ComplexSelector >.

fn visit_mut_component_value(&mut self, node: &mut ComponentValue)

Visit a node of type ComponentValue.

fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>)

Visit a node of type Vec < ComponentValue >.

fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector)

Visit a node of type CompoundSelector.

fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList)

Visit a node of type CompoundSelectorList.

fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>)

Visit a node of type Vec < CompoundSelector >.

fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition)

Visit a node of type ContainerCondition.

fn visit_mut_container_name(&mut self, node: &mut ContainerName)

Visit a node of type ContainerName.

fn visit_mut_container_query(&mut self, node: &mut ContainerQuery)

Visit a node of type ContainerQuery.

fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd)

Visit a node of type ContainerQueryAnd.

fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot)

Visit a node of type ContainerQueryNot.

fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr)

Visit a node of type ContainerQueryOr.

fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType)

Visit a node of type ContainerQueryType.

fn visit_mut_container_query_types( &mut self, node: &mut Vec<ContainerQueryType>, )

Visit a node of type Vec < ContainerQueryType >.

fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName)

Visit a node of type CustomHighlightName.

fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent)

Visit a node of type CustomIdent.

fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>)

Visit a node of type Vec < CustomIdent >.

fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery)

Visit a node of type CustomMediaQuery.

fn visit_mut_custom_media_query_media_type( &mut self, node: &mut CustomMediaQueryMediaType, )

Visit a node of type CustomMediaQueryMediaType.

fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName)

Visit a node of type CustomPropertyName.

fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent)

Visit a node of type DashedIdent.

fn visit_mut_declaration(&mut self, node: &mut Declaration)

Visit a node of type Declaration.

fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName)

Visit a node of type DeclarationName.

fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule)

Visit a node of type DeclarationOrAtRule.

fn visit_mut_delimiter(&mut self, node: &mut Delimiter)

Visit a node of type Delimiter.

fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue)

Visit a node of type DelimiterValue.

fn visit_mut_dimension(&mut self, node: &mut Dimension)

Visit a node of type Dimension.

fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken)

Visit a node of type DimensionToken.

fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude)

Visit a node of type DocumentPrelude.

fn visit_mut_document_prelude_matching_function( &mut self, node: &mut DocumentPreludeMatchingFunction, )

Visit a node of type DocumentPreludeMatchingFunction.

fn visit_mut_document_prelude_matching_functions( &mut self, node: &mut Vec<DocumentPreludeMatchingFunction>, )

Visit a node of type Vec < DocumentPreludeMatchingFunction >.

fn visit_mut_extension_name(&mut self, node: &mut ExtensionName)

Visit a node of type ExtensionName.

fn visit_mut_family_name(&mut self, node: &mut FamilyName)

Visit a node of type FamilyName.

fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>)

Visit a node of type Vec < FamilyName >.

fn visit_mut_flex(&mut self, node: &mut Flex)

Visit a node of type Flex.

fn visit_mut_font_feature_values_prelude( &mut self, node: &mut FontFeatureValuesPrelude, )

Visit a node of type FontFeatureValuesPrelude.

fn visit_mut_forgiving_complex_selector( &mut self, node: &mut ForgivingComplexSelector, )

Visit a node of type ForgivingComplexSelector.

fn visit_mut_forgiving_complex_selectors( &mut self, node: &mut Vec<ForgivingComplexSelector>, )

Visit a node of type Vec < ForgivingComplexSelector >.

fn visit_mut_forgiving_relative_selector( &mut self, node: &mut ForgivingRelativeSelector, )

Visit a node of type ForgivingRelativeSelector.

fn visit_mut_forgiving_relative_selector_list( &mut self, node: &mut ForgivingRelativeSelectorList, )

Visit a node of type ForgivingRelativeSelectorList.

fn visit_mut_forgiving_relative_selectors( &mut self, node: &mut Vec<ForgivingRelativeSelector>, )

Visit a node of type Vec < ForgivingRelativeSelector >.

fn visit_mut_forgiving_selector_list( &mut self, node: &mut ForgivingSelectorList, )

Visit a node of type ForgivingSelectorList.

fn visit_mut_frequency(&mut self, node: &mut Frequency)

Visit a node of type Frequency.

fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage)

Visit a node of type FrequencyPercentage.

fn visit_mut_function(&mut self, node: &mut Function)

Visit a node of type Function.

fn visit_mut_function_name(&mut self, node: &mut FunctionName)

Visit a node of type FunctionName.

fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed)

Visit a node of type GeneralEnclosed.

fn visit_mut_hex_color(&mut self, node: &mut HexColor)

Visit a node of type HexColor.

fn visit_mut_hue(&mut self, node: &mut Hue)

Visit a node of type Hue.

fn visit_mut_id_selector(&mut self, node: &mut IdSelector)

Visit a node of type IdSelector.

fn visit_mut_ident(&mut self, node: &mut Ident)

Visit a node of type Ident.

fn visit_mut_idents(&mut self, node: &mut Vec<Ident>)

Visit a node of type Vec < Ident >.

fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions)

Visit a node of type ImportConditions.

fn visit_mut_import_href(&mut self, node: &mut ImportHref)

Visit a node of type ImportHref.

fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName)

Visit a node of type ImportLayerName.

fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude)

Visit a node of type ImportPrelude.

fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag)

Visit a node of type ImportantFlag.

fn visit_mut_integer(&mut self, node: &mut Integer)

Visit a node of type Integer.

fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock)

Visit a node of type KeyframeBlock.

fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector)

Visit a node of type KeyframeSelector.

fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>)

Visit a node of type Vec < KeyframeSelector >.

fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName)

Visit a node of type KeyframesName.

fn visit_mut_keyframes_pseudo_function( &mut self, node: &mut KeyframesPseudoFunction, )

Visit a node of type KeyframesPseudoFunction.

fn visit_mut_keyframes_pseudo_prefix( &mut self, node: &mut KeyframesPseudoPrefix, )

Visit a node of type KeyframesPseudoPrefix.

fn visit_mut_layer_name(&mut self, node: &mut LayerName)

Visit a node of type LayerName.

fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList)

Visit a node of type LayerNameList.

fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>)

Visit a node of type Vec < LayerName >.

fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude)

Visit a node of type LayerPrelude.

fn visit_mut_length(&mut self, node: &mut Length)

Visit a node of type Length.

fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage)

Visit a node of type LengthPercentage.

fn visit_mut_list_of_component_values( &mut self, node: &mut ListOfComponentValues, )

Visit a node of type ListOfComponentValues.

fn visit_mut_media_and(&mut self, node: &mut MediaAnd)

Visit a node of type MediaAnd.

fn visit_mut_media_condition(&mut self, node: &mut MediaCondition)

Visit a node of type MediaCondition.

fn visit_mut_media_condition_all_type( &mut self, node: &mut MediaConditionAllType, )

Visit a node of type MediaConditionAllType.

fn visit_mut_media_condition_all_types( &mut self, node: &mut Vec<MediaConditionAllType>, )

Visit a node of type Vec < MediaConditionAllType >.

fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType)

Visit a node of type MediaConditionType.

fn visit_mut_media_condition_without_or( &mut self, node: &mut MediaConditionWithoutOr, )

Visit a node of type MediaConditionWithoutOr.

fn visit_mut_media_condition_without_or_type( &mut self, node: &mut MediaConditionWithoutOrType, )

Visit a node of type MediaConditionWithoutOrType.

fn visit_mut_media_condition_without_or_types( &mut self, node: &mut Vec<MediaConditionWithoutOrType>, )

Visit a node of type Vec < MediaConditionWithoutOrType >.

fn visit_mut_media_feature(&mut self, node: &mut MediaFeature)

Visit a node of type MediaFeature.

fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean)

Visit a node of type MediaFeatureBoolean.

fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName)

Visit a node of type MediaFeatureName.

fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain)

Visit a node of type MediaFeaturePlain.

fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange)

Visit a node of type MediaFeatureRange.

fn visit_mut_media_feature_range_comparison( &mut self, node: &mut MediaFeatureRangeComparison, )

Visit a node of type MediaFeatureRangeComparison.

fn visit_mut_media_feature_range_interval( &mut self, node: &mut MediaFeatureRangeInterval, )

Visit a node of type MediaFeatureRangeInterval.

fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue)

Visit a node of type MediaFeatureValue.

fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens)

Visit a node of type MediaInParens.

fn visit_mut_media_not(&mut self, node: &mut MediaNot)

Visit a node of type MediaNot.

fn visit_mut_media_or(&mut self, node: &mut MediaOr)

Visit a node of type MediaOr.

fn visit_mut_media_query(&mut self, node: &mut MediaQuery)

Visit a node of type MediaQuery.

fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList)

Visit a node of type MediaQueryList.

fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>)

Visit a node of type Vec < MediaQuery >.

fn visit_mut_media_type(&mut self, node: &mut MediaType)

Visit a node of type MediaType.

fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace)

Visit a node of type NamedNamespace.

fn visit_mut_namespace(&mut self, node: &mut Namespace)

Visit a node of type Namespace.

fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix)

Visit a node of type NamespacePrefix.

fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude)

Visit a node of type NamespacePrelude.

fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri)

Visit a node of type NamespacePreludeUri.

fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector)

Visit a node of type NestingSelector.

fn visit_mut_number(&mut self, node: &mut Number)

Visit a node of type Number.

fn visit_mut_number_type(&mut self, node: &mut NumberType)

Visit a node of type NumberType.

fn visit_mut_opt_at_rule_prelude( &mut self, node: &mut Option<Box<AtRulePrelude>>, )

Visit a node of type Option < Box < AtRulePrelude > >.

fn visit_mut_opt_atom(&mut self, node: &mut Option<Atom>)

Visit a node of type Option < swc_atoms :: Atom >.

fn visit_mut_opt_attribute_selector_matcher( &mut self, node: &mut Option<AttributeSelectorMatcher>, )

Visit a node of type Option < AttributeSelectorMatcher >.

fn visit_mut_opt_attribute_selector_modifier( &mut self, node: &mut Option<AttributeSelectorModifier>, )

Visit a node of type Option < AttributeSelectorModifier >.

fn visit_mut_opt_attribute_selector_value( &mut self, node: &mut Option<AttributeSelectorValue>, )

Visit a node of type Option < AttributeSelectorValue >.

fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>)

Visit a node of type Option < Combinator >.

fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>)

Visit a node of type Option < ContainerName >.

fn visit_mut_opt_forgiving_selector_list( &mut self, node: &mut Option<ForgivingSelectorList>, )

Visit a node of type Option < ForgivingSelectorList >.

fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>)

Visit a node of type Option < Box < Function > >.

fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>)

Visit a node of type Option < Ident >.

fn visit_mut_opt_import_conditions( &mut self, node: &mut Option<Box<ImportConditions>>, )

Visit a node of type Option < Box < ImportConditions > >.

fn visit_mut_opt_import_layer_name( &mut self, node: &mut Option<Box<ImportLayerName>>, )

Visit a node of type Option < Box < ImportLayerName > >.

fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>)

Visit a node of type Option < ImportantFlag >.

fn visit_mut_opt_media_condition_type( &mut self, node: &mut Option<Box<MediaConditionType>>, )

Visit a node of type Option < Box < MediaConditionType > >.

fn visit_mut_opt_media_query_list( &mut self, node: &mut Option<Box<MediaQueryList>>, )

Visit a node of type Option < Box < MediaQueryList > >.

fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>)

Visit a node of type Option < MediaType >.

fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>)

Visit a node of type Option < Namespace >.

fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>)

Visit a node of type Option < NamespacePrefix >.

fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>)

Visit a node of type Option < NestingSelector >.

fn visit_mut_opt_number(&mut self, node: &mut Option<Number>)

Visit a node of type Option < Number >.

fn visit_mut_opt_page_selector_pseudos( &mut self, node: &mut Option<Vec<PageSelectorPseudo>>, )

Visit a node of type Option < Vec < PageSelectorPseudo > >.

fn visit_mut_opt_page_selector_type( &mut self, node: &mut Option<PageSelectorType>, )

Visit a node of type Option < PageSelectorType >.

fn visit_mut_opt_pseudo_class_selector_childrens( &mut self, node: &mut Option<Vec<PseudoClassSelectorChildren>>, )

Visit a node of type Option < Vec < PseudoClassSelectorChildren > >.

fn visit_mut_opt_pseudo_element_selector_childrens( &mut self, node: &mut Option<Vec<PseudoElementSelectorChildren>>, )

Visit a node of type Option < Vec < PseudoElementSelectorChildren > >.

fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>)

Visit a node of type Option < SimpleBlock >.

fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>)

Visit a node of type Option < Box < TypeSelector > >.

fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>)

Visit a node of type Option < Vec < UrlModifier > >.

fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>)

Visit a node of type Option < Box < UrlValue > >.

fn visit_mut_page_selector(&mut self, node: &mut PageSelector)

Visit a node of type PageSelector.

fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList)

Visit a node of type PageSelectorList.

fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo)

Visit a node of type PageSelectorPseudo.

fn visit_mut_page_selector_pseudos( &mut self, node: &mut Vec<PageSelectorPseudo>, )

Visit a node of type Vec < PageSelectorPseudo >.

fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType)

Visit a node of type PageSelectorType.

fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>)

Visit a node of type Vec < PageSelector >.

fn visit_mut_percentage(&mut self, node: &mut Percentage)

Visit a node of type Percentage.

fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector)

Visit a node of type PseudoClassSelector.

fn visit_mut_pseudo_class_selector_children( &mut self, node: &mut PseudoClassSelectorChildren, )

Visit a node of type PseudoClassSelectorChildren.

fn visit_mut_pseudo_class_selector_childrens( &mut self, node: &mut Vec<PseudoClassSelectorChildren>, )

Visit a node of type Vec < PseudoClassSelectorChildren >.

fn visit_mut_pseudo_element_selector( &mut self, node: &mut PseudoElementSelector, )

Visit a node of type PseudoElementSelector.

fn visit_mut_pseudo_element_selector_children( &mut self, node: &mut PseudoElementSelectorChildren, )

Visit a node of type PseudoElementSelectorChildren.

fn visit_mut_pseudo_element_selector_childrens( &mut self, node: &mut Vec<PseudoElementSelectorChildren>, )

Visit a node of type Vec < PseudoElementSelectorChildren >.

fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule)

Visit a node of type QualifiedRule.

fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude)

Visit a node of type QualifiedRulePrelude.

fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens)

Visit a node of type QueryInParens.

fn visit_mut_ratio(&mut self, node: &mut Ratio)

Visit a node of type Ratio.

fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector)

Visit a node of type RelativeSelector.

fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList)

Visit a node of type RelativeSelectorList.

fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>)

Visit a node of type Vec < RelativeSelector >.

fn visit_mut_resolution(&mut self, node: &mut Resolution)

Visit a node of type Resolution.

fn visit_mut_rule(&mut self, node: &mut Rule)

Visit a node of type Rule.

fn visit_mut_rules(&mut self, node: &mut Vec<Rule>)

Visit a node of type Vec < Rule >.

fn visit_mut_scope_range(&mut self, node: &mut ScopeRange)

Visit a node of type ScopeRange.

fn visit_mut_selector_list(&mut self, node: &mut SelectorList)

Visit a node of type SelectorList.

fn visit_mut_sequence_of_custom_idents( &mut self, node: &mut SequenceOfCustomIdents, )

Visit a node of type SequenceOfCustomIdents.

fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock)

Visit a node of type SimpleBlock.

fn visit_mut_size_feature(&mut self, node: &mut SizeFeature)

Visit a node of type SizeFeature.

fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean)

Visit a node of type SizeFeatureBoolean.

fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName)

Visit a node of type SizeFeatureName.

fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain)

Visit a node of type SizeFeaturePlain.

fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange)

Visit a node of type SizeFeatureRange.

fn visit_mut_size_feature_range_comparison( &mut self, node: &mut SizeFeatureRangeComparison, )

Visit a node of type SizeFeatureRangeComparison.

fn visit_mut_size_feature_range_interval( &mut self, node: &mut SizeFeatureRangeInterval, )

Visit a node of type SizeFeatureRangeInterval.

fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue)

Visit a node of type SizeFeatureValue.

fn visit_mut_span(&mut self, node: &mut Span)

Visit a node of type swc_common :: Span.

fn visit_mut_str(&mut self, node: &mut Str)

Visit a node of type Str.

fn visit_mut_style_block(&mut self, node: &mut StyleBlock)

Visit a node of type StyleBlock.

fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet)

Visit a node of type Stylesheet.

fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector)

Visit a node of type SubclassSelector.

fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>)

Visit a node of type Vec < SubclassSelector >.

fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd)

Visit a node of type SupportsAnd.

fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition)

Visit a node of type SupportsCondition.

fn visit_mut_supports_condition_type( &mut self, node: &mut SupportsConditionType, )

Visit a node of type SupportsConditionType.

fn visit_mut_supports_condition_types( &mut self, node: &mut Vec<SupportsConditionType>, )

Visit a node of type Vec < SupportsConditionType >.

fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature)

Visit a node of type SupportsFeature.

fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens)

Visit a node of type SupportsInParens.

fn visit_mut_supports_not(&mut self, node: &mut SupportsNot)

Visit a node of type SupportsNot.

fn visit_mut_supports_or(&mut self, node: &mut SupportsOr)

Visit a node of type SupportsOr.

fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector)

Visit a node of type TagNameSelector.

fn visit_mut_time(&mut self, node: &mut Time)

Visit a node of type Time.

fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage)

Visit a node of type TimePercentage.

fn visit_mut_token(&mut self, node: &mut Token)

Visit a node of type Token.

fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan)

Visit a node of type TokenAndSpan.

fn visit_mut_type_selector(&mut self, node: &mut TypeSelector)

Visit a node of type TypeSelector.

fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange)

Visit a node of type UnicodeRange.

fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector)

Visit a node of type UniversalSelector.

fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension)

Visit a node of type UnknownDimension.

fn visit_mut_url(&mut self, node: &mut Url)

Visit a node of type Url.

fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue)

Visit a node of type UrlKeyValue.

fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier)

Visit a node of type UrlModifier.

fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>)

Visit a node of type Vec < UrlModifier >.

fn visit_mut_url_value(&mut self, node: &mut UrlValue)

Visit a node of type UrlValue.

fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw)

Visit a node of type UrlValueRaw.

fn visit_mut_wq_name(&mut self, node: &mut WqName)

Visit a node of type WqName.

impl<L, R> Write for Either<L, R>

where L: Write, R: Write,

Either<L, R> implements Write if both L and R do.

Requires crate feature "use_std"

fn write(&mut self, buf: &[u8]) -> Result<usize, Error>

Writes a buffer into this writer, returning how many bytes were written.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn flush(&mut self) -> Result<(), Error>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl<L, R> Copy for Either<L, R>

where L: Copy, R: Copy,

impl<L, R> Eq for Either<L, R>

where L: Eq, R: Eq,

impl<L, R> FusedIterator for Either<L, R>

where L: FusedIterator, R: FusedIterator<Item = <L as Iterator>::Item>,

impl<L, R> StructuralPartialEq for Either<L, R>