Make expr_simplifier handle expressions when indexing strings, arrays and objects

crates/swc/tests/tsc-references/destructuringArrayBindingPatternAndAssignment2.2.minified.js

@@ -1,7 +1,7 @@
 //// [destructuringArrayBindingPatternAndAssignment2.ts]
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
-var _ref_1 = (_sliced_to_array([][0], 1)[0], _sliced_to_array([][1], 1));
+var _ref_1 = (_sliced_to_array(void 0, 1)[0], _sliced_to_array(void 0, 1));
 _sliced_to_array(_ref_1[0], 1)[0];
 var _undefined = _sliced_to_array(void 0, 2), _undefined_1 = (_sliced_to_array(_undefined[0], 1)[0], _sliced_to_array(_undefined[1], 1));
 _sliced_to_array(_undefined_1[0], 1)[0];

crates/swc/tests/tsc-references/destructuringControlFlow.2.minified.js

@@ -1,5 +1,3 @@
 //// [destructuringControlFlow.ts]
 import "@swc/helpers/_/_sliced_to_array";
-[
-    "foo"
-][1].toUpperCase();
+(void 0).toUpperCase();

crates/swc/tests/tsc-references/destructuringEvaluationOrder(target=es5).2.minified.js

@@ -6,7 +6,7 @@ import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_property_key } from "@swc/helpers/_/_to_property_key";
 var trace = [], order = function(n) {
     return trace.push(n);
-}, tmp = [][0];
+}, tmp = void 0;
 (void 0 === tmp ? order(0) : tmp)[order(1)];
 var tmp1 = {};
 (void 0 === tmp1 ? order(0) : tmp1)[order(1)];

crates/swc/tests/tsc-references/parserForStatement9.2.minified.js

@@ -1,3 +1,3 @@
 //// [parserForStatement9.ts]
-for(var tmp = [][0], x = void 0 === tmp ? ("a" in {}) : tmp; !x; x = !x)console.log(x);
+for(var tmp = void 0, x = void 0 === tmp ? ("a" in {}) : tmp; !x; x = !x)console.log(x);
 for(var _ref_x = {}.x, x1 = void 0 === _ref_x ? ("a" in {}) : _ref_x; !x1; x1 = !x1)console.log(x1);

crates/swc/tests/tsc-references/templateStringInIndexExpressionES6.2.minified.js

@@ -1,2 +1 @@
 //// [templateStringInIndexExpressionES6.ts]
-"abc0abc"["0"];

crates/swc_ecma_transforms_optimization/src/simplify/expr/mod.rs

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, iter, iter::once};
 
-use swc_atoms::JsWord;
+use swc_atoms::{Atom, JsWord};
 use swc_common::{
     pass::{CompilerPass, Repeated},
     util::take::Take,
@@ -107,12 +107,21 @@ impl SimplifyExpr {
             return;
         }
 
-        #[derive(Clone, PartialEq, Eq)]
+        #[derive(Clone, PartialEq)]
         enum KnownOp {
             /// [a, b].length
             Len,
 
-            Index(i64),
+            // [a, b][0]
+            //
+            // ({0.5: 'test'})[0.5]
+            /// Note: callers need to check `v.fract() == 0.0` in some cases.
+            /// ie non-integer indexes for arrays always result in `undefined`
+            /// but not for objects (because indexing an object
+            /// returns the value of the key, ie `0.5` will not
+            /// return `undefined` if a key `0.5` exists
+            /// and its value is not `undefined`).
+            Index(f64),
 
             /// ({}).foo
             IndexStr(JsWord),
@@ -127,16 +136,16 @@ impl SimplifyExpr {
                 }
             }
             MemberProp::Computed(ComputedPropName { expr, .. }) => {
-                if !self.in_callee {
-                    if let Expr::Lit(Lit::Num(Number { value, .. })) = &**expr {
-                        if value.fract() == 0.0 {
-                            KnownOp::Index(*value as _)
-                        } else {
-                            return;
-                        }
-                    } else {
-                        return;
-                    }
+                if self.in_callee {
+                    return;
+                }
+
+                if let Expr::Lit(Lit::Num(Number { value, .. })) = &**expr {
+                    // x[5]
+                    KnownOp::Index(*value)
+                } else if let Known(s) = expr.as_pure_string(&self.expr_ctx) {
+                    // x[''] or x[...] where ... is an expression like [], ie x[[]]
+                    KnownOp::IndexStr(JsWord::from(s))
                 } else {
                     return;
                 }
@@ -158,10 +167,10 @@ impl SimplifyExpr {
                 }
 
                 // 'foo'[1]
-                KnownOp::Index(idx) if (idx as usize) < value.len() => {
+                KnownOp::Index(idx) => {
                     self.changed = true;
 
-                    if idx < 0 {
+                    if idx.fract() != 0.0 || idx < 0.0 || idx as usize >= value.len() {
                         *expr = *undefined(*span)
                     } else {
                         let value = nth_char(value, idx as _);
@@ -173,10 +182,19 @@ impl SimplifyExpr {
                         }))
                     };
                 }
-                _ => {}
+
+                // 'foo'['']
+                KnownOp::IndexStr(_) => {
+                    self.changed = true;
+                    *expr = *undefined(*span);
+                }
             },
 
             // [1, 2, 3].length
+            //
+            // [1, 2, 3][0]
+            //
+            // [1, 2, 3]['']
             Expr::Array(ArrayLit { elems, span }) => {
                 // do nothing if spread exists
                 let has_spread = elems.iter().any(|elem| {
@@ -207,17 +225,25 @@ impl SimplifyExpr {
                         _ => unreachable!(),
                     };
 
-                    if elems.len() > idx as _ && idx >= 0 {
-                        let after_has_side_effect =
-                            elems.iter().skip((idx + 1) as _).any(|elem| match elem {
-                                Some(elem) => elem.expr.may_have_side_effects(&self.expr_ctx),
-                                None => false,
-                            });
+                    // If the fraction part is non-zero, or if the index is out of bounds,
+                    // then the result is always undefined.
+                    if idx.fract() != 0.0 || idx < 0.0 || idx as usize >= elems.len() {
+                        self.changed = true;
+                        *expr = *undefined(*span);
+                        return;
+                    }
+                    // idx is treated as an integer from this point.
+                    //
+                    // We also know for certain the index is not out of bounds.
+                    let idx = idx as i64;
 
-                        if after_has_side_effect {
-                            return;
-                        }
-                    } else {
+                    let after_has_side_effect =
+                        elems.iter().skip((idx + 1) as _).any(|elem| match elem {
+                            Some(elem) => elem.expr.may_have_side_effects(&self.expr_ctx),
+                            None => false,
+                        });
+
+                    if after_has_side_effect {
                         return;
                     }
 
@@ -265,63 +291,72 @@ impl SimplifyExpr {
                     exprs.push(val);
 
                     *expr = Expr::Seq(SeqExpr { span: *span, exprs });
+                } else if matches!(op, KnownOp::IndexStr(..)) {
+                    self.changed = true;
+                    *expr = *undefined(*span);
+                    return;
                 }
             }
 
             // { foo: true }['foo']
-            Expr::Object(ObjectLit { props, span }) => match op {
-                KnownOp::IndexStr(key) if is_literal(props) && key != *"yield" => {
-                    // do nothing if spread exists
-                    let has_spread = props
-                        .iter()
-                        .any(|prop| matches!(prop, PropOrSpread::Spread(..)));
+            //
+            // { 0.5: true }[0.5]
+            Expr::Object(ObjectLit { props, span }) => {
+                // get key
+                let key = match op {
+                    KnownOp::Index(i) => Atom::from(i.to_string()),
+                    KnownOp::IndexStr(key) if key != *"yield" && is_literal(props) => key,
+                    _ => return,
+                };
 
-                    if has_spread {
-                        return;
-                    }
+                // do nothing if spread exists
+                let has_spread = props
+                    .iter()
+                    .any(|prop| matches!(prop, PropOrSpread::Spread(..)));
 
-                    let idx = props.iter().rev().position(|p| match p {
-                        PropOrSpread::Prop(p) => match &**p {
-                            Prop::Shorthand(i) => i.sym == key,
-                            Prop::KeyValue(k) => prop_name_eq(&k.key, &key),
-                            Prop::Assign(p) => p.key.sym == key,
-                            Prop::Getter(..) => false,
-                            Prop::Setter(..) => false,
-                            // TODO
-                            Prop::Method(..) => false,
-                        },
-                        _ => unreachable!(),
-                    });
-                    let idx = idx.map(|idx| props.len() - 1 - idx);
-                    //
+                if has_spread {
+                    return;
+                }
 
-                    if let Some(i) = idx {
-                        let v = props.remove(i);
-                        self.changed = true;
+                let idx = props.iter().rev().position(|p| match p {
+                    PropOrSpread::Prop(p) => match &**p {
+                        Prop::Shorthand(i) => i.sym == key,
+                        Prop::KeyValue(k) => prop_name_eq(&k.key, &key),
+                        Prop::Assign(p) => p.key.sym == key,
+                        Prop::Getter(..) => false,
+                        Prop::Setter(..) => false,
+                        // TODO
+                        Prop::Method(..) => false,
+                    },
+                    _ => unreachable!(),
+                });
+                let idx = idx.map(|idx| props.len() - 1 - idx);
 
-                        *expr = self.expr_ctx.preserve_effects(
-                            *span,
-                            match v {
-                                PropOrSpread::Prop(p) => match *p {
-                                    Prop::Shorthand(i) => Expr::Ident(i),
-                                    Prop::KeyValue(p) => *p.value,
-                                    Prop::Assign(p) => *p.value,
-                                    Prop::Getter(..) => unreachable!(),
-                                    Prop::Setter(..) => unreachable!(),
-                                    // TODO
-                                    Prop::Method(..) => unreachable!(),
-                                },
-                                _ => unreachable!(),
+                if let Some(i) = idx {
+                    let v = props.remove(i);
+                    self.changed = true;
+
+                    *expr = self.expr_ctx.preserve_effects(
+                        *span,
+                        match v {
+                            PropOrSpread::Prop(p) => match *p {
+                                Prop::Shorthand(i) => Expr::Ident(i),
+                                Prop::KeyValue(p) => *p.value,
+                                Prop::Assign(p) => *p.value,
+                                Prop::Getter(..) => unreachable!(),
+                                Prop::Setter(..) => unreachable!(),
+                                // TODO
+                                Prop::Method(..) => unreachable!(),
                             },
-                            once(Box::new(Expr::Object(ObjectLit {
-                                props: props.take(),
-                                span: *span,
-                            }))),
-                        );
-                    }
+                            _ => unreachable!(),
+                        },
+                        once(Box::new(Expr::Object(ObjectLit {
+                            props: props.take(),
+                            span: *span,
+                        }))),
+                    );
                 }
-                _ => {}
-            },
+            }
 
             _ => {}
         }

crates/swc_ecma_transforms_optimization/src/simplify/expr/tests.rs

@@ -1579,3 +1579,25 @@ fn test_export_default_paren_expr() {
     fold_same("import fn from './b'; export default (function fn1 () {});");
     fold("export default ((foo));", "export default foo;");
 }
+
+#[test]
+fn test_issue8747() {
+    // Indexing a string with an out-of-bounds index returns undefined.
+    fold("''[0]", "void 0");
+    // Indexing a string with a non-integer index returns undefined.
+    fold("'a'[0.5]", "void 0");
+    // Index with an expression.
+    fold("''[[]]", "void 0");
+    fold("'a'[[]]", "void 0");
+
+    // Indexing an array has the same logic as indexing a string.
+    fold("[][0]", "void 0");
+    fold("[1][0.5]", "void 0");
+    fold("[][[]]", "void 0");
+    fold("[1][[]]", "void 0");
+
+    // Indexing objects
+    fold("({0.5: 'a'})[0.5]", "'a';");
+    fold("({'0.5': 'a'})[0.5]", "'a';");
+    fold("({0.5: 'a'})['0.5']", "'a';");
+}

crates/swc_ecma_utils/src/lib.rs

@@ -1879,13 +1879,9 @@ impl Visit for LiteralVisitor {
         match node {
             PropName::Str(ref s) => self.cost += 2 + s.value.len(),
             PropName::Ident(ref id) => self.cost += 2 + id.sym.len(),
-            PropName::Num(n) => {
-                if n.value.fract() < 1e-10 {
-                    // TODO: Count digits
-                    self.cost += 5;
-                } else {
-                    self.is_lit = false
-                }
+            PropName::Num(..) => {
+                // TODO: Count digits
+                self.cost += 5;
             }
             PropName::BigInt(_) => self.is_lit = false,
             PropName::Computed(..) => self.is_lit = false,
@@ -2673,7 +2669,7 @@ pub fn prop_name_eq(p: &PropName, key: &str) -> bool {
     match p {
         PropName::Ident(i) => i.sym == *key,
         PropName::Str(s) => s.value == *key,
-        PropName::Num(_) => false,
+        PropName::Num(n) => n.value.to_string() == *key,
         PropName::BigInt(_) => false,
         PropName::Computed(e) => match &*e.expr {
             Expr::Lit(Lit::Str(Str { value, .. })) => *value == *key,