fix: to_number and array deps

Author: kermanx

crates/jsshaker/src/analyzer/operations.rs

@@ -129,8 +129,7 @@ impl<'a> Analyzer<'a> {
           let rhs = rhs.to_number();
           match (lhs, rhs) {
             (None, _) | (_, None) => None,
-            (Some(None), _) | (_, Some(None)) => Some(false),
-            (Some(Some(l)), Some(Some(r))) => Some(if eq { l.0 <= r.0 } else { l.0 < r.0 }),
+            (Some(l), Some(r)) => Some(if eq { l.0 <= r.0 } else { l.0 < r.0 }),
           }
         }
       }
@@ -215,15 +214,10 @@ impl<'a> Analyzer<'a> {
     if maybe_number {
       // Possibly number
       match (lhs_lit.and_then(|v| v.to_number()), rhs_lit.and_then(|v| v.to_number())) {
-        (Some(l), Some(r)) => match (l, r) {
-          (Some(l), Some(r)) => {
-            let val = l.0 + r.0;
-            values.push(self.factory.number(val));
-          }
-          _ => {
-            values.push(self.factory.nan);
-          }
-        },
+        (Some(l), Some(r)) => {
+          let val = l.0 + r.0;
+          values.push(self.factory.number(val));
+        }
         _ => {
           values.push(self.factory.unknown_number);
         }
@@ -279,21 +273,12 @@ impl<'a> Analyzer<'a> {
   }
 
   pub fn op_update(&self, input: Entity<'a>, operator: UpdateOperator) -> Entity<'a> {
-    let apply_update = |v: f64| {
-      self.factory.number(match operator {
-        UpdateOperator::Increment => v + 1.0,
-        UpdateOperator::Decrement => v - 1.0,
-      })
-    };
-
     if let Some(num) = input.get_literal(self).and_then(|lit| lit.to_number()) {
-      return self.factory.computed(
-        match num {
-          Some(num) => apply_update(num.0),
-          None => self.factory.nan,
-        },
-        input,
-      );
+      let updated = self.factory.number(match operator {
+        UpdateOperator::Increment => num.0 + 1.0,
+        UpdateOperator::Decrement => num.0 - 1.0,
+      });
+      return self.factory.computed(updated, input);
     }
 
     let input_t = input.test_typeof();

crates/jsshaker/src/nodes/expr/unary_expression.rs

@@ -49,12 +49,7 @@ impl<'a> Analyzer<'a> {
       UnaryOperator::UnaryNegation => {
         self.factory.computed(
           if let Some(num) = argument.get_literal(self).and_then(|lit| lit.to_number()) {
-            if let Some(num) = num {
-              let num = -num.0;
-              self.factory.number(num)
-            } else {
-              self.factory.nan
-            }
+            self.factory.number(-num.0)
           } else {
             // Maybe number or bigint
             self.factory.unknown_primitive

crates/jsshaker/src/value/array.rs

@@ -20,6 +20,7 @@ use crate::{
 #[derive(Debug)]
 pub struct ArrayValue<'a> {
   pub included: Cell<bool>,
+  pub trackable: Cell<bool>,
   pub deps: RefCell<DepCollector<'a>>,
   pub cf_scope: CfScopeId,
   pub elements: RefCell<allocator::Vec<'a, Entity<'a>>>,
@@ -34,6 +35,7 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
   fn include(&'a self, analyzer: &mut Analyzer<'a>) {
     use_included_flag!(self);
 
+    self.trackable.set(false);
     self.deps.borrow().include_all(analyzer);
     self.elements.borrow().include(analyzer);
     self.rest.borrow().include(analyzer);
@@ -55,6 +57,7 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
       return escaped::unknown_mutate(analyzer, dep);
     }
 
+    self.trackable.set(false);
     self.deps.borrow_mut().push(analyzer.dep((exec_deps, dep)));
   }
 
@@ -70,11 +73,11 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
 
     analyzer.track_read(self.cf_scope, ReadWriteTarget::Array(self.array_id()), None);
 
-    if !self.deps.borrow().is_empty() {
+    if !self.trackable.get() {
       return analyzer.factory.computed_unknown((self, dep, key));
     }
 
-    let dep = analyzer.dep((dep, key));
+    let dep = analyzer.dep((dep, key, self.deps(analyzer)));
     if let Some(key_literals) = key.get_literals(analyzer) {
       let mut result = analyzer.factory.vec();
       let mut rest_added = false;
@@ -132,9 +135,9 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
       return escaped::set_property(analyzer, dep, key, value);
     }
 
-    let mut has_effect = false;
+    let deps = analyzer.dep((exec_deps, key));
     'known: {
-      if !self.deps.borrow().is_empty() {
+      if !self.trackable.get() {
         break 'known;
       }
 
@@ -143,44 +146,47 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
       };
 
       let definite = !non_det && key_literals.len() == 1;
+      let mut has_effect = false;
       let mut rest_added = false;
       for &key_literal in &key_literals {
         match key_literal {
           LiteralValue::String(key_str, _) => {
             if let Ok(index) = key_str.parse::<usize>() {
-              has_effect = true;
+              let value = analyzer.factory.computed(value, deps);
               if let Some(element) = self.elements.borrow_mut().get_mut(index) {
                 *element = if definite { value } else { analyzer.factory.union((*element, value)) };
               } else if !rest_added {
                 rest_added = true;
                 self.rest.borrow_mut().push(value);
               }
             } else if key_str == "length" {
-              if let Some(length) = value.get_literal(analyzer).and_then(|lit| lit.to_number()) {
-                if let Some(length) = length.map(|l| l.0.trunc()) {
-                  let length = length as usize;
-                  if length > 1024 {
-                    break 'known;
-                  }
+              if let Some(literal) = value.get_literal(analyzer)
+                && let Some(length) = literal.to_number()
+              {
+                if length.0.is_nan() || length.0 < 0.0 {
+                  break 'known;
+                }
+                let length = length.0.trunc() as usize;
+                if length > 1024 {
+                  break 'known;
+                }
 
-                  let mut elements = self.elements.borrow_mut();
-                  let mut rest = self.rest.borrow_mut();
-                  if elements.len() > length {
-                    has_effect = true;
-                    elements.truncate(length);
-                    rest.clear();
-                  } else if !rest.is_empty() {
-                    has_effect = true;
-                    rest.push(analyzer.factory.undefined);
-                  } else if elements.len() < length {
-                    has_effect = true;
-                    for _ in elements.len()..length {
-                      elements.push(analyzer.factory.undefined);
-                    }
+                self.deps.borrow_mut().push(analyzer.dep(value));
+
+                let mut elements = self.elements.borrow_mut();
+                let mut rest = self.rest.borrow_mut();
+                if elements.len() > length {
+                  has_effect = true;
+                  elements.truncate(length);
+                  rest.clear();
+                } else if !rest.is_empty() {
+                  has_effect = true;
+                  rest.push(analyzer.factory.undefined);
+                } else if elements.len() < length {
+                  has_effect = true;
+                  for _ in elements.len()..length {
+                    elements.push(analyzer.factory.undefined);
                   }
-                } else {
-                  analyzer.throw_builtin_error("Invalid array length");
-                  has_effect = analyzer.config.preserve_exceptions;
                 }
               } else {
                 has_effect = true;
@@ -194,15 +200,14 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
         }
       }
       if has_effect {
-        let mut deps = self.deps.borrow_mut();
-        deps.push(analyzer.dep((exec_deps, key)));
+        self.deps.borrow_mut().push(deps);
       }
       return;
     }
 
     // Unknown
-    let mut deps = self.deps.borrow_mut();
-    deps.push(analyzer.dep((exec_deps, key, value)));
+    self.deps.borrow_mut().push(analyzer.dep((deps, value)));
+    self.trackable.set(false);
   }
 
   fn enumerate_properties(
@@ -216,7 +221,7 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
 
     analyzer.track_read(self.cf_scope, ReadWriteTarget::Array(self.array_id()), None);
 
-    if !self.deps.borrow().is_empty() {
+    if !self.trackable.get() {
       return EnumeratedProperties {
         known: Default::default(),
         unknown: Some(analyzer.factory.unknown),
@@ -237,11 +242,7 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
       analyzer.factory.union(allocator::Vec::from_iter_in(rest.iter().copied(), analyzer.allocator))
     });
 
-    EnumeratedProperties {
-      known,
-      unknown,
-      dep: analyzer.dep((self.deps.borrow_mut().collect(analyzer.factory), dep)),
-    }
+    EnumeratedProperties { known, unknown, dep: analyzer.dep((self.deps(analyzer), dep)) }
   }
 
   fn delete_property(&'a self, analyzer: &mut Analyzer<'a>, dep: Dep<'a>, key: Entity<'a>) {
@@ -258,6 +259,7 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
 
     let mut deps = self.deps.borrow_mut();
     deps.push(analyzer.dep((exec_deps, key)));
+    self.trackable.set(false);
   }
 
   fn call(
@@ -297,7 +299,7 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
 
     analyzer.track_read(self.cf_scope, ReadWriteTarget::Array(self.array_id()), None);
 
-    if !self.deps.borrow().is_empty() {
+    if !self.trackable.get() {
       return (vec![], Some(analyzer.factory.unknown), analyzer.dep((self, dep)));
     }
 
@@ -307,7 +309,7 @@ impl<'a> ValueTrait<'a> for ArrayValue<'a> {
         self.rest.borrow().iter().copied(),
         analyzer.allocator,
       )),
-      dep,
+      analyzer.dep((self.deps(analyzer), dep)),
     )
   }
 
@@ -398,13 +400,18 @@ impl<'a> ArrayValue<'a> {
 
     (is_exhaustive, non_det, exec_deps)
   }
+
+  fn deps(&self, analyzer: &Analyzer<'a>) -> Option<Dep<'a>> {
+    self.deps.borrow_mut().collect(analyzer.factory)
+  }
 }
 
 impl<'a> Analyzer<'a> {
   pub fn new_empty_array(&mut self) -> &'a mut ArrayValue<'a> {
     let cf_scope = self.scoping.cf.current_id();
     self.factory.alloc(ArrayValue {
       included: Cell::new(false),
+      trackable: Cell::new(true),
       deps: RefCell::new(DepCollector::new(self.factory.vec())),
       cf_scope,
       elements: RefCell::new(self.factory.vec()),

crates/jsshaker/src/value/literal/mod.rs

@@ -367,25 +367,25 @@ impl<'a> LiteralValue<'a> {
     }
   }
 
-  // `None` for unresolvable, `Some(None)` for NaN, `Some(Some(value))` for number
-  pub fn to_number(self) -> Option<Option<F64WithEq>> {
+  // `None` for unresolvable
+  pub fn to_number(self) -> Option<F64WithEq> {
     match self {
-      LiteralValue::Number(value) => Some(Some(value)),
+      LiteralValue::Number(value) => Some(value),
       LiteralValue::BigInt(_value) => {
         // TODO: warn: TypeError: Cannot convert a BigInt value to a number
         None
       }
-      LiteralValue::Boolean(value) => Some(Some(if value { 1.0 } else { 0.0 }.into())),
+      LiteralValue::Boolean(value) => Some(if value { 1.0 } else { 0.0 }.into()),
       LiteralValue::String(value, _) => {
         let val = value.trim().string_to_number();
-        Some(if val.is_nan() { None } else { Some(val.into()) })
+        Some(val.into())
       }
-      LiteralValue::Null => Some(Some(0.0.into())),
+      LiteralValue::Null => Some(0.0.into()),
       LiteralValue::Symbol(_, _) => {
         // TODO: warn: TypeError: Cannot convert a Symbol value to a number
         None
       }
-      LiteralValue::Undefined => Some(None),
+      LiteralValue::Undefined => Some(f64::NAN.into()),
     }
   }
 

tasks/test262/ignored2.txt

@@ -1023,3 +1023,7 @@ built-ins/Array/prototype/map/create-proto-from-ctor-realm-array.js	|	修改了
 built-ins/Array/prototype/splice/create-proto-from-ctor-realm-array.js	|	修改了内置对象
 built-ins/Array/prototype/filter/create-proto-from-ctor-realm-array.js	|	修改了内置对象
 staging/sm/RegExp/split-trace.js	|	修改了内置对象
+built-ins/Array/prototype/toLocaleString/S15.4.4.3_A3_T1.js	|	修改了内置对象
+built-ins/Array/prototype/concat/S15.4.4.4_A3_T2.js	|	修改了内置对象
+built-ins/Array/prototype/concat/S15.4.4.4_A3_T3.js	|	修改了内置对象
+built-ins/Array/S15.4.5.1_A1.2_T2.js	|	修改了内置对象