fix(es/compat): Handle sparse arrays correctly in generator transforms

Author: 0xe

crates/swc_ecma_compat_es2015/src/generator.rs

@@ -1112,7 +1112,7 @@ impl Generator {
             );
         }
 
-        let expressions = elements
+        let mut expressions = elements
             .iter_mut()
             .skip(num_initial_elements)
             .map(|v| v.take())
@@ -1128,7 +1128,17 @@ impl Generator {
                     spread: None,
                     expr: Box::new(Expr::Array(ArrayLit {
                         span: DUMMY_SP,
-                        elems: expressions,
+                        elems: expressions
+                            .take()
+                            .into_iter()
+                            .map(|expr| match expr {
+                                Some(expr_or_spread) => match &*expr_or_spread.expr {
+                                    Expr::Invalid(_) => None,
+                                    _ => Some(expr_or_spread),
+                                },
+                                None => None,
+                            })
+                            .collect(),
                     })),
                 }],
                 ..Default::default()
@@ -1141,7 +1151,13 @@ impl Generator {
                     .take()
                     .into_iter()
                     .map(Some)
-                    .chain(expressions)
+                    .chain(expressions.take().into_iter().map(|expr| match expr {
+                        Some(expr_or_spread) => match &*expr_or_spread.expr {
+                            Expr::Invalid(_) => None,
+                            _ => Some(expr_or_spread),
+                        },
+                        None => None,
+                    }))
                     .collect(),
             }
             .into()
@@ -1173,7 +1189,17 @@ impl Generator {
                             .as_callee(),
                         args: vec![Box::new(Expr::Array(ArrayLit {
                             span: DUMMY_SP,
-                            elems: expressions.take(),
+                            elems: expressions
+                                .take()
+                                .into_iter()
+                                .map(|expr| match expr {
+                                    Some(expr_or_spread) => match &*expr_or_spread.expr {
+                                        Expr::Invalid(_) => None,
+                                        _ => Some(expr_or_spread),
+                                    },
+                                    None => None,
+                                })
+                                .collect(),
                         }))
                         .as_arg()],
                         ..Default::default()
@@ -1187,7 +1213,13 @@ impl Generator {
                                 .take()
                                 .into_iter()
                                 .map(Some)
-                                .chain(expressions.take())
+                                .chain(expressions.take().into_iter().map(|expr| match expr {
+                                    Some(expr_or_spread) => match &*expr_or_spread.expr {
+                                        Expr::Invalid(_) => None,
+                                        _ => Some(expr_or_spread),
+                                    },
+                                    None => None,
+                                }))
                                 .collect(),
                         }
                         .into(),
@@ -1199,9 +1231,7 @@ impl Generator {
         }
 
         element.visit_mut_with(self);
-        if element.is_some() {
-            expressions.push(element);
-        }
+        expressions.push(element);
         expressions
     }
 

crates/swc_ecma_transforms_compat/tests/__swc_snapshots__/tests/es2015_generator_sparse_array.rs/sparse_array_leading_hole.js

@@ -0,0 +1,19 @@
+function gen() {
+    return _ts_generator(this, function (_state) {
+        switch (_state.label) {
+            case 0:
+                return [
+                    4,
+                    [
+                        ,
+                        'hello'
+                    ]
+                ];
+            case 1:
+                _state.sent();
+                return [
+                    2
+                ];
+        }
+    });
+}

crates/swc_ecma_transforms_compat/tests/__swc_snapshots__/tests/es2015_generator_sparse_array.rs/sparse_array_middle_hole.js

@@ -0,0 +1,20 @@
+function gen() {
+    return _ts_generator(this, function (_state) {
+        switch (_state.label) {
+            case 0:
+                return [
+                    4,
+                    [
+                        'start',
+                        ,
+                        'end'
+                    ]
+                ];
+            case 1:
+                _state.sent();
+                return [
+                    2
+                ];
+        }
+    });
+}

crates/swc_ecma_transforms_compat/tests/es2015_generator_sparse_array.rs

@@ -0,0 +1,50 @@
+#![allow(clippy::unit_arg)]
+
+use swc_common::{
+    chain,
+    comments::{NoopComments, SingleThreadedComments},
+    Mark,
+};
+use swc_ecma_parser::Syntax;
+use swc_ecma_transforms_base::resolver;
+use swc_ecma_transforms_compat::{
+    es2015, es2015::generator::generator, es2016, es2017, es2017::async_to_generator, es2018,
+    es2021, es2022,
+};
+use swc_ecma_transforms_testing::{test, test_exec};
+use swc_ecma_visit::Fold;
+
+fn syntax() -> Syntax {
+    Syntax::default()
+}
+
+fn tr(_: ()) -> impl Fold {
+    let unresolved_mark = Mark::new();
+    let top_level_mark = Mark::new();
+    chain!(
+        resolver(unresolved_mark, top_level_mark, false),
+        generator(unresolved_mark, NoopComments)
+    )
+}
+
+test!(
+    syntax(),
+    |_| tr(Default::default()),
+    sparse_array_leading_hole,
+    r#"
+function* gen() {
+    yield [, 'hello'];
+}
+"#
+);
+
+test!(
+    syntax(),
+    |_| tr(Default::default()),
+    sparse_array_middle_hole,
+    r#"
+function* gen() {
+    yield ['start', , 'end'];
+}
+"#
+);

crates/swc_plugin_backend_wasmer/src/lib.rs

@@ -25,7 +25,7 @@ static ENGINE: Lazy<Mutex<wasmer::Engine>> = Lazy::new(|| {
     // Use empty enumset to disable simd.
     use enumset::EnumSet;
     use wasmer::sys::{BaseTunables, CompilerConfig, EngineBuilder, Target, Triple};
-    let mut set = EnumSet::new();
+    let set = EnumSet::new();
 
     // [TODO]: Should we use is_x86_feature_detected! macro instead?
     #[cfg(target_arch = "x86_64")]