Vendor things

third-party/vendor/swc_ecma_ast/src/macros.rs

@@ -0,0 +1,237 @@
+/// Creates a corresponding operator. This macro is used to make code more
+/// readable.
+///
+/// This can used to represent [UnaryOp](crate::UnaryOp),
+/// [BinaryOp](crate::BinaryOp), or [AssignOp](crate::AssignOp).
+///
+/// Actual type is determined by the input.
+///
+/// # Note about `+` and `-`
+///
+/// As this macro is intended to be used in anywhere, including pattern
+/// bindings, this macro cannot use trick to determine type for `+` and `-`.
+///
+/// So we have to use some special syntax for `+` and `-`:
+///
+///  - If you need [UnaryOp](crate::UnaryOp), use `op!(unary, "+")` and
+///    `op!(unary, "-")`.
+///
+///  - If you need [BinaryOp](crate::BinaryOp), use `op!(bin, "+")` and
+///    `op!(bin, "-")`.
+#[macro_export]
+macro_rules! op {
+    (unary,"-") => {
+        $crate::UnaryOp::Minus
+    };
+    (unary,"+") => {
+        $crate::UnaryOp::Plus
+    };
+    ("!") => {
+        $crate::UnaryOp::Bang
+    };
+    ("~") => {
+        $crate::UnaryOp::Tilde
+    };
+    ("typeof") => {
+        $crate::UnaryOp::TypeOf
+    };
+    ("void") => {
+        $crate::UnaryOp::Void
+    };
+    ("delete") => {
+        $crate::UnaryOp::Delete
+    };
+
+    ("++") => {
+        $crate::UpdateOp::PlusPlus
+    };
+    ("--") => {
+        $crate::UpdateOp::MinusMinus
+    };
+
+    ("==") => {
+        $crate::BinaryOp::EqEq
+    };
+    ("!=") => {
+        $crate::BinaryOp::NotEq
+    };
+    ("===") => {
+        $crate::BinaryOp::EqEqEq
+    };
+    ("!==") => {
+        $crate::BinaryOp::NotEqEq
+    };
+    ("<") => {
+        $crate::BinaryOp::Lt
+    };
+    ("<=") => {
+        $crate::BinaryOp::LtEq
+    };
+    (">") => {
+        $crate::BinaryOp::Gt
+    };
+    (">=") => {
+        $crate::BinaryOp::GtEq
+    };
+    ("<<") => {
+        $crate::BinaryOp::LShift
+    };
+    (">>") => {
+        $crate::BinaryOp::RShift
+    };
+    (">>>") => {
+        $crate::BinaryOp::ZeroFillRShift
+    };
+    (bin,"+") => {
+        $crate::BinaryOp::Add
+    };
+    (bin,"-") => {
+        $crate::BinaryOp::Sub
+    };
+    ("*") => {
+        $crate::BinaryOp::Mul
+    };
+    ("/") => {
+        $crate::BinaryOp::Div
+    };
+    ("%") => {
+        $crate::BinaryOp::Mod
+    };
+    ("|") => {
+        $crate::BinaryOp::BitOr
+    };
+    ("^") => {
+        $crate::BinaryOp::BitXor
+    };
+    ("&") => {
+        $crate::BinaryOp::BitAnd
+    };
+    ("||") => {
+        $crate::BinaryOp::LogicalOr
+    };
+    ("&&") => {
+        $crate::BinaryOp::LogicalAnd
+    };
+    ("in") => {
+        $crate::BinaryOp::In
+    };
+    ("instanceof") => {
+        $crate::BinaryOp::InstanceOf
+    };
+    ("**") => {
+        $crate::BinaryOp::Exp
+    };
+    ("??") => {
+        $crate::BinaryOp::NullishCoalescing
+    };
+
+    ("=") => {
+        $crate::AssignOp::Assign
+    };
+    ("+=") => {
+        $crate::AssignOp::AddAssign
+    };
+    ("-=") => {
+        $crate::AssignOp::SubAssign
+    };
+    ("*=") => {
+        $crate::AssignOp::MulAssign
+    };
+    ("/=") => {
+        $crate::AssignOp::DivAssign
+    };
+    ("%=") => {
+        $crate::AssignOp::ModAssign
+    };
+    ("<<=") => {
+        $crate::AssignOp::LShiftAssign
+    };
+    (">>=") => {
+        $crate::AssignOp::RShiftAssign
+    };
+    (">>>=") => {
+        $crate::AssignOp::ZeroFillRShiftAssign
+    };
+    ("|=") => {
+        $crate::AssignOp::BitOrAssign
+    };
+    ("^=") => {
+        $crate::AssignOp::BitXorAssign
+    };
+    ("&=") => {
+        $crate::AssignOp::BitAndAssign
+    };
+    ("**=") => {
+        $crate::AssignOp::ExpAssign
+    };
+    ("&&=") => {
+        $crate::AssignOp::AndAssign
+    };
+    ("||=") => {
+        $crate::AssignOp::OrAssign
+    };
+    ("??=") => {
+        $crate::AssignOp::NullishAssign
+    };
+}
+
+macro_rules! test_de {
+    ($name:ident, $T:path, $s:literal) => {
+        #[test]
+        #[cfg(feature = "serde-impl")]
+        fn $name() {
+            let _var: $T = ::serde_json::from_str(&$s).expect("failed to parse json");
+        }
+    };
+}
+
+/// Implement `From<$src>` for `$dst`, by using implementation of `From<$src>`
+/// for `$bridge`.
+///
+/// - `$dst` must implement `From<$bridge>`.
+/// - `$bridge` must implement `From<$src>`.
+///
+///
+/// e.g. For `&str` -> `Box<Expr>`, we convert it by `&str` -> `JsWord` -> `Str`
+/// -> `Lit` -> `Expr` -> `Box<Expr>`.
+macro_rules! bridge_from {
+    ($dst:ty, $bridge:ty, $src:ty) => {
+        impl From<$src> for $dst {
+            #[cfg_attr(not(debug_assertions), inline(always))]
+            fn from(src: $src) -> $dst {
+                let src: $bridge = src.into();
+                src.into()
+            }
+        }
+    };
+}
+
+macro_rules! bridge_expr_from {
+    ($bridge:ty, $src:ty) => {
+        bridge_from!(crate::Expr, $bridge, $src);
+        bridge_from!(Box<crate::Expr>, crate::Expr, $src);
+    };
+}
+
+macro_rules! bridge_pat_from {
+    ($bridge:ty, $src:ty) => {
+        bridge_from!(crate::Pat, $bridge, $src);
+        bridge_from!(crate::Param, crate::Pat, $src);
+        bridge_from!(Box<crate::Pat>, crate::Pat, $src);
+    };
+}
+
+macro_rules! bridge_stmt_from {
+    ($bridge:ty, $src:ty) => {
+        bridge_from!(crate::Stmt, $bridge, $src);
+        bridge_from!(crate::ModuleItem, crate::Stmt, $src);
+    };
+}
+
+macro_rules! bridge_decl_from {
+    ($bridge:ty, $src:ty) => {
+        bridge_from!(crate::Decl, $bridge, $src);
+        bridge_from!(crate::Stmt, crate::Decl, $src);
+        bridge_from!(crate::ModuleItem, crate::Stmt, $src);
+    };
+}