fix(ecmascript): resolve identifier value type via tracked constants

`value_type` returned `Undetermined` for any non-global identifier, even
when the binding had zero writes and a known constant initializer. As a
result `slot?.()` on a `let slot;` (with all writers tree-shaken away)
was not folded to `void 0`, leaving dead optional calls in the output.

Consult `get_constant_value_for_reference_id` for non-global identifier
references and map the resulting `ConstantValue` to a `ValueType`. This
lets `fold_chain_expr` (and other consumers of `value_type`) recognise
read-only `let`/`const` bindings whose value is statically known.

Closes rolldown/rolldown#9281

Author: TheAlexLichter

crates/oxc_ecmascript/src/constant_evaluation/value_type.rs

@@ -1,6 +1,7 @@
 use oxc_ast::ast::*;
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
+use super::value::ConstantValue;
 use crate::{GlobalContext, to_numeric::ToNumeric, to_primitive::ToPrimitive};
 
 /// JavaScript Language Type
@@ -52,6 +53,17 @@ impl ValueType {
     }
 }
 
+fn constant_value_type(value: &ConstantValue<'_>) -> ValueType {
+    match value {
+        ConstantValue::Number(_) => ValueType::Number,
+        ConstantValue::BigInt(_) => ValueType::BigInt,
+        ConstantValue::String(_) => ValueType::String,
+        ConstantValue::Boolean(_) => ValueType::Boolean,
+        ConstantValue::Undefined => ValueType::Undefined,
+        ConstantValue::Null => ValueType::Null,
+    }
+}
+
 /// Based on `get_known_value_type` in closure compiler
 /// <https://github.com/google/closure-compiler/blob/v20240609/src/com/google/javascript/jscomp/NodeUtil.java#L1517>
 ///
@@ -91,6 +103,12 @@ impl<'a> DetermineValueType<'a> for Expression<'a> {
                         "NaN" | "Infinity" => ValueType::Number,
                         _ => ValueType::Undetermined,
                     }
+                } else if let Some(value) = ident
+                    .reference_id
+                    .get()
+                    .and_then(|reference_id| ctx.get_constant_value_for_reference_id(reference_id))
+                {
+                    constant_value_type(&value)
                 } else {
                     ValueType::Undetermined
                 }

crates/oxc_minifier/tests/peephole/dead_code_elimination.rs

@@ -546,3 +546,17 @@ fn remove_pure_function_calls() {
     test("var foo = function() {}; foo()", "");
     test_same("function foo() { bar() } foo()");
 }
+
+#[test]
+fn fold_optional_chain_on_undefined_let_binding() {
+    // https://github.com/rolldown/rolldown/issues/9281
+    // A `let` binding with no writes is statically known to be `undefined`,
+    // so optional calls / member accesses on it should fold to `void 0`.
+    test("let slot; export function call() { slot?.() }", "export function call() {}");
+    test("let slot; export function call() { slot?.foo }", "export function call() {}");
+    test("let slot; export function call() { slot?.[foo()] }", "export function call() {}");
+    // A binding that is written somewhere is not nullish-known: leave it alone.
+    test_same(
+        "let slot; export function setSlot(v) { slot = v } export function call() { slot?.() }",
+    );
+}