fmt

Author: kdy1

crates/swc_ecma_compiler/src/common/arrow_function_converter.rs

@@ -11,11 +11,13 @@ use crate::{
 impl<'a> TransformCtx<'a> {
     /// Check if temp var is required for `key`.
     ///
-    /// `this` does not have side effects, but in this context, it needs a temp var anyway, because `this`
-    /// in computed key and `this` within class constructor resolve to different `this` bindings.
-    /// So we need to create a temp var outside of the class to get the correct `this`.
+    /// `this` does not have side effects, but in this context, it needs a temp
+    /// var anyway, because `this` in computed key and `this` within class
+    /// constructor resolve to different `this` bindings. So we need to
+    /// create a temp var outside of the class to get the correct `this`.
     /// `class C { [this] = 1; }`
-    /// -> `let _this; _this = this; class C { constructor() { this[_this] = 1; } }`
+    /// -> `let _this; _this = this; class C { constructor() { this[_this] = 1;
+    /// } }`
     //
     // TODO(improve-on-babel): Can avoid the temp var if key is for a static prop/method,
     // as in that case the usage of `this` stays outside the class.
@@ -31,23 +33,28 @@ impl<'a> TransformCtx<'a> {
             | Expression::RegExpLiteral(_)
             | Expression::StringLiteral(_) => false,
             // Template literal cannot have side effects if it has no expressions.
-            // If it *does* have expressions, but they're all literals, then also cannot have side effects,
-            // but don't bother checking for that as it shouldn't occur in real world code.
-            // Why would you write "`x${9}z`" when you can just write "`x9z`"?
-            // Note: "`x${foo}`" *can* have side effects if `foo` is an object with a `toString` method.
+            // If it *does* have expressions, but they're all literals, then also cannot have side
+            // effects, but don't bother checking for that as it shouldn't occur in real
+            // world code. Why would you write "`x${9}z`" when you can just write
+            // "`x9z`"? Note: "`x${foo}`" *can* have side effects if `foo` is an object
+            // with a `toString` method.
             Expression::TemplateLiteral(lit) => !lit.expressions.is_empty(),
             // `IdentifierReference`s can have side effects if is unbound.
             //
             // If var is mutated, it also needs a temp var, because of cases like
             // `let x = 1; class { [x] = 1; [++x] = 2; }`
-            // `++x` is hoisted to before class in output, so `x` in 1st key would get the wrong value
-            // unless it's hoisted out too.
+            // `++x` is hoisted to before class in output, so `x` in 1st key would get the wrong
+            // value unless it's hoisted out too.
             //
             // TODO: Add an exec test for this odd case.
             // TODO(improve-on-babel): That case is rare.
             // Test for it in first pass over class elements, and avoid temp vars where possible.
             Expression::Identifier(ident) => {
-                match ctx.scoping().get_reference(ident.reference_id()).symbol_id() {
+                match ctx
+                    .scoping()
+                    .get_reference(ident.reference_id())
+                    .symbol_id()
+                {
                     Some(symbol_id) => ctx.scoping().symbol_is_mutated(symbol_id),
                     None => true,
                 }
@@ -60,12 +67,16 @@ impl<'a> TransformCtx<'a> {
     }
 
     /// Create `let _x;` statement and insert it.
-    /// Return `_x = x()` assignment, and `_x` identifier referencing same temp var.
+    /// Return `_x = x()` assignment, and `_x` identifier referencing same temp
+    /// var.
     pub fn create_computed_key_temp_var(
         &self,
         key: Expression<'a>,
         ctx: &mut TraverseCtx<'a>,
-    ) -> (/* assignment */ Expression<'a>, /* identifier */ Expression<'a>) {
+    ) -> (
+        /* assignment */ Expression<'a>,
+        /* identifier */ Expression<'a>,
+    ) {
         let outer_scope_id = ctx.current_block_scope_id();
         // TODO: Handle if is a class expression defined in a function's params.
         let binding =

crates/swc_ecma_compiler/src/common/computed_key.rs

@@ -16,15 +16,17 @@ use crate::context::{TransformCtx, TraverseCtx};
 impl<'a> TransformCtx<'a> {
     /// Duplicate expression to be used twice.
     ///
-    /// If `expr` may have side effects, create a temp var `_expr` and assign to it.
+    /// If `expr` may have side effects, create a temp var `_expr` and assign to
+    /// it.
     ///
     /// * `this` -> `this`, `this`
     /// * Bound identifier `foo` -> `foo`, `foo`
     /// * Unbound identifier `foo` -> `_foo = foo`, `_foo`
     /// * Anything else `foo()` -> `_foo = foo()`, `_foo`
     ///
-    /// If `mutated_symbol_needs_temp_var` is `true`, temp var will be created for a bound identifier,
-    /// if it's mutated (assigned to) anywhere in AST.
+    /// If `mutated_symbol_needs_temp_var` is `true`, temp var will be created
+    /// for a bound identifier, if it's mutated (assigned to) anywhere in
+    /// AST.
     ///
     /// Returns 2 `Expression`s. The first may be an `AssignmentExpression`,
     /// and must be inserted into output first.
@@ -42,15 +44,17 @@ impl<'a> TransformCtx<'a> {
 
     /// Duplicate expression to be used 3 times.
     ///
-    /// If `expr` may have side effects, create a temp var `_expr` and assign to it.
+    /// If `expr` may have side effects, create a temp var `_expr` and assign to
+    /// it.
     ///
     /// * `this` -> `this`, `this`, `this`
     /// * Bound identifier `foo` -> `foo`, `foo`, `foo`
     /// * Unbound identifier `foo` -> `_foo = foo`, `_foo`, `_foo`
     /// * Anything else `foo()` -> `_foo = foo()`, `_foo`, `_foo`
     ///
-    /// If `mutated_symbol_needs_temp_var` is `true`, temp var will be created for a bound identifier,
-    /// if it's mutated (assigned to) anywhere in AST.
+    /// If `mutated_symbol_needs_temp_var` is `true`, temp var will be created
+    /// for a bound identifier, if it's mutated (assigned to) anywhere in
+    /// AST.
     ///
     /// Returns 3 `Expression`s. The first may be an `AssignmentExpression`,
     /// and must be inserted into output first.
@@ -68,18 +72,20 @@ impl<'a> TransformCtx<'a> {
 
     /// Duplicate expression `N + 1` times.
     ///
-    /// If `expr` may have side effects, create a temp var `_expr` and assign to it.
+    /// If `expr` may have side effects, create a temp var `_expr` and assign to
+    /// it.
     ///
     /// * `this` -> `this`, [`this`; N]
     /// * Bound identifier `foo` -> `foo`, [`foo`; N]
     /// * Unbound identifier `foo` -> `_foo = foo`, [`_foo`; N]
     /// * Anything else `foo()` -> `_foo = foo()`, [`_foo`; N]
     ///
-    /// If `mutated_symbol_needs_temp_var` is `true`, temp var will be created for a bound identifier,
-    /// if it's mutated (assigned to) anywhere in AST.
+    /// If `mutated_symbol_needs_temp_var` is `true`, temp var will be created
+    /// for a bound identifier, if it's mutated (assigned to) anywhere in
+    /// AST.
     ///
-    /// Returns `N + 1` x `Expression`s. The first may be an `AssignmentExpression`,
-    /// and must be inserted into output first.
+    /// Returns `N + 1` x `Expression`s. The first may be an
+    /// `AssignmentExpression`, and must be inserted into output first.
     pub(crate) fn duplicate_expression_multiple<const N: usize>(
         &self,
         expr: Expression<'a>,
@@ -102,7 +108,8 @@ impl<'a> TransformCtx<'a> {
                     return (expr, references);
                 }
 
-                // Previously `x += 1` (`x` read + write), but moving to `_x = x` (`x` read only)
+                // Previously `x += 1` (`x` read + write), but moving to `_x = x` (`x` read
+                // only)
                 let reference = ctx.scoping_mut().get_reference_mut(reference_id);
                 *reference.flags_mut() = ReferenceFlags::Read;
 
@@ -121,10 +128,11 @@ impl<'a> TransformCtx<'a> {
                 return (expr, references);
             }
             // Template literal cannot have side effects if it has no expressions.
-            // If it *does* have expressions, but they're all literals, then also cannot have side effects,
-            // but don't bother checking for that as it shouldn't occur in real world code.
-            // Why would you write "`x${9}z`" when you can just write "`x9z`"?
-            // Note: "`x${foo}`" *can* have side effects if `foo` is an object with a `toString` method.
+            // If it *does* have expressions, but they're all literals, then also cannot have side
+            // effects, but don't bother checking for that as it shouldn't occur in real
+            // world code. Why would you write "`x${9}z`" when you can just write
+            // "`x9z`"? Note: "`x${foo}`" *can* have side effects if `foo` is an object
+            // with a `toString` method.
             Expression::TemplateLiteral(lit) if lit.expressions.is_empty() => {
                 let references = create_array(|| {
                     ctx.ast.expression_template_literal(
@@ -136,7 +144,9 @@ impl<'a> TransformCtx<'a> {
                 return (expr, references);
             }
             // Anything else requires temp var
-            _ => self.var_declarations.create_uid_var_based_on_node(&expr, ctx),
+            _ => self
+                .var_declarations
+                .create_uid_var_based_on_node(&expr, ctx),
         };
 
         let assignment = ctx.ast.expression_assignment(
@@ -152,21 +162,24 @@ impl<'a> TransformCtx<'a> {
     }
 }
 
-/// Create array of length `N`, with each item initialized with provided function `init`.
+/// Create array of length `N`, with each item initialized with provided
+/// function `init`.
 ///
 /// Implementation based on:
 /// * <https://github.com/rust-lang/rust/issues/62875#issuecomment-513834029>
 /// * <https://github.com/rust-lang/rust/issues/61956>
 //
-// `#[inline]` so compiler can inline `init()`, and it may unroll the loop if `init` is simple enough.
+// `#[inline]` so compiler can inline `init()`, and it may unroll the loop if `init` is simple
+// enough.
 #[inline]
 fn create_array<const N: usize, T, I: FnMut() -> T>(mut init: I) -> [T; N] {
     let mut array: [MaybeUninit<T>; N] = [const { MaybeUninit::uninit() }; N];
     for elem in &mut array {
         elem.write(init());
     }
-    // Wrapping in `ManuallyDrop` should not be necessary because `MaybeUninit` does not impl `Drop`,
-    // but do it anyway just to make sure, as it's mentioned in issues above.
+    // Wrapping in `ManuallyDrop` should not be necessary because `MaybeUninit` does
+    // not impl `Drop`, but do it anyway just to make sure, as it's mentioned in
+    // issues above.
     let mut array = ManuallyDrop::new(array);
     // SAFETY: All elements of array are initialized.
     // `[MaybeUninit<T>; N]` and `[T; N]` have same layout.