fix(ecmascript): to_number for shadowed undefined

Author: sapphi-red

crates/oxc_ecmascript/src/constant_evaluation/mod.rs

@@ -188,7 +188,7 @@ pub trait ConstantEvaluation<'a>: DetermineValueType {
             }
             expr => {
                 use crate::ToNumber;
-                expr.to_number()
+                expr.to_number(self)
             }
         }
     }
@@ -256,8 +256,8 @@ pub trait ConstantEvaluation<'a>: DetermineValueType {
                 if left_type.is_number() || right_type.is_number() {
                     let lval = self.eval_expression(left)?;
                     let rval = self.eval_expression(right)?;
-                    let lnum = lval.to_number()?;
-                    let rnum = rval.to_number()?;
+                    let lnum = lval.to_number(self)?;
+                    let rnum = rval.to_number(self)?;
                     return Some(ConstantValue::Number(lnum + rnum));
                 }
                 None

crates/oxc_ecmascript/src/constant_evaluation/value.rs

@@ -76,7 +76,7 @@ impl<'a> ToJsString<'a> for ConstantValue<'a> {
 }
 
 impl<'a> ToNumber<'a> for ConstantValue<'a> {
-    fn to_number(&self) -> Option<f64> {
+    fn to_number(&self, _is_global_reference: &impl IsGlobalReference) -> Option<f64> {
         use crate::StringToNumber;
         match self {
             Self::Number(n) => Some(*n),

crates/oxc_ecmascript/src/to_number.rs

@@ -1,14 +1,16 @@
 use oxc_ast::ast::*;
 
+use crate::is_global_reference::IsGlobalReference;
+
 /// `ToNumber`
 ///
-/// <https://tc39.es/ecma262/#sec-tonumber>
+/// <https://tc39.es/ecma262/multipage/abstract-operations.html#sec-tonumber>
 pub trait ToNumber<'a> {
-    fn to_number(&self) -> Option<f64>;
+    fn to_number(&self, is_global_reference: &impl IsGlobalReference) -> Option<f64>;
 }
 
 impl<'a> ToNumber<'a> for Expression<'a> {
-    fn to_number(&self) -> Option<f64> {
+    fn to_number(&self, is_global_reference: &impl IsGlobalReference) -> Option<f64> {
         match self {
             Expression::NumericLiteral(number_literal) => Some(number_literal.value),
             Expression::BooleanLiteral(bool_literal) => {
@@ -20,16 +22,22 @@ impl<'a> ToNumber<'a> for Expression<'a> {
             }
             Expression::NullLiteral(_) => Some(0.0),
             Expression::Identifier(ident) => match ident.name.as_str() {
-                "Infinity" => Some(f64::INFINITY),
-                "NaN" | "undefined" => Some(f64::NAN),
+                "Infinity" if is_global_reference.is_global_reference(ident) == Some(true) => {
+                    Some(f64::INFINITY)
+                }
+                "NaN" | "undefined"
+                    if is_global_reference.is_global_reference(ident) == Some(true) =>
+                {
+                    Some(f64::NAN)
+                }
                 _ => None,
             },
             Expression::StringLiteral(lit) => {
                 use crate::StringToNumber;
                 Some(lit.value.as_str().string_to_number())
             }
             Expression::UnaryExpression(unary) if unary.operator.is_not() => {
-                let number = unary.argument.to_number()?;
+                let number = unary.argument.to_number(is_global_reference)?;
                 Some(if number == 0.0 { 1.0 } else { 0.0 })
             }
             _ => None,

crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs

@@ -635,7 +635,7 @@ impl<'a> PeepholeOptimizations {
                 span,
                 match arg {
                     None => 0.0,
-                    Some(arg) => arg.to_number()?,
+                    Some(arg) => arg.to_number(&ctx)?,
                 },
                 None,
                 NumberBase::Decimal,

crates/oxc_minifier/tests/ecmascript/mod.rs

@@ -2,5 +2,6 @@ mod array_join;
 mod may_have_side_effects;
 mod prop_name;
 mod to_boolean;
+mod to_number;
 mod to_string;
 mod value_type;

crates/oxc_minifier/tests/ecmascript/to_number.rs

@@ -0,0 +1,33 @@
+use oxc_allocator::Allocator;
+use oxc_ast::{ast::*, AstBuilder};
+use oxc_ecmascript::{is_global_reference::IsGlobalReference, ToNumber};
+use oxc_span::SPAN;
+
+struct GlobalReferenceInformation {
+    is_undefined_shadowed: bool,
+}
+
+impl IsGlobalReference for GlobalReferenceInformation {
+    fn is_global_reference(&self, ident: &IdentifierReference<'_>) -> Option<bool> {
+        if ident.name == "undefined" {
+            Some(!self.is_undefined_shadowed)
+        } else {
+            None
+        }
+    }
+}
+
+#[test]
+fn test() {
+    let allocator = Allocator::default();
+    let ast = AstBuilder::new(&allocator);
+
+    let undefined = ast.expression_identifier(SPAN, "undefined");
+    let shadowed_undefined_number =
+        undefined.to_number(&GlobalReferenceInformation { is_undefined_shadowed: true });
+    let global_undefined_number =
+        undefined.to_number(&GlobalReferenceInformation { is_undefined_shadowed: false });
+
+    assert_eq!(shadowed_undefined_number, None);
+    assert!(global_undefined_number.is_some_and(f64::is_nan));
+}