fix(isolated_declarations): Emit computed properties when they are well known symbols

crates/oxc_isolated_declarations/src/class.rs

@@ -32,8 +32,15 @@ impl<'a> IsolatedDeclarations<'a> {
 
     pub fn report_property_key(&self, key: &PropertyKey<'a>, computed: bool) -> bool {
         if computed && !self.is_literal_key(key) {
-            self.error(computed_property_name(key.span()));
-            true
+            if self
+                .global_symbol_binding_tracker
+                .does_computed_property_reference_well_known_symbol(key)
+            {
+                false
+            } else {
+                self.error(computed_property_name(key.span()));
+                true
+            }
         } else {
             false
         }
@@ -281,19 +288,59 @@ impl<'a> IsolatedDeclarations<'a> {
     /// 1. If it has no parameter, create a parameter with the name `value`
     /// 2. If it has no parameter type, infer it from the getter method's return type
     fn transform_getter_or_setter_methods(&self, decl: &mut Class<'a>) {
-        let mut method_annotations: FxHashMap<_, (bool, _, _)> = FxHashMap::default();
+        let mut method_annotations_for_static_name: FxHashMap<_, (bool, _, _)> =
+            FxHashMap::default();
+        let mut method_annotations_for_well_known_symbol: FxHashMap<_, (bool, _, _)> =
+            FxHashMap::default();
+
         for element in decl.body.body.iter_mut() {
             if let ClassElement::MethodDefinition(method) = element {
-                if method.key.is_private_identifier()
-                    && (method.computed && !self.is_literal_key(&method.key))
-                {
+                if method.key.is_private_identifier() {
                     continue;
                 }
 
-                let Some(name) = method.key.static_name() else {
+                let Some((name, is_static)) =
+                    method.key.static_name().map(|name| (name, true)).or_else(|| {
+                        if let PropertyKey::StaticMemberExpression(expr) = &method.key {
+                            match &expr.object {
+                                Expression::Identifier(object_identifier) => {
+                                    if object_identifier.name == "Symbol" {
+                                        Some((expr.property.name.clone().into(), false))
+                                    } else {
+                                        None
+                                    }
+                                }
+                                Expression::StaticMemberExpression(static_member) => {
+                                    if let Expression::Identifier(identifier) =
+                                        &static_member.object
+                                    {
+                                        if identifier.name == "globalThis"
+                                            && static_member.property.name == "Symbol"
+                                        {
+                                            Some((expr.property.name.clone().into(), false))
+                                        } else {
+                                            None
+                                        }
+                                    } else {
+                                        None
+                                    }
+                                }
+                                _ => None,
+                            }
+                        } else {
+                            None
+                        }
+                    })
+                else {
                     continue;
                 };
 
+                let method_annotations = if is_static {
+                    &mut method_annotations_for_static_name
+                } else {
+                    &mut method_annotations_for_well_known_symbol
+                };
+
                 match method.kind {
                     MethodDefinitionKind::Set => {
                         let params = &mut method.value.params;
@@ -328,7 +375,10 @@ impl<'a> IsolatedDeclarations<'a> {
             }
         }
 
-        for (requires_inference, param, return_type) in method_annotations.into_values() {
+        for (requires_inference, param, return_type) in method_annotations_for_static_name
+            .into_values()
+            .chain(method_annotations_for_well_known_symbol.into_values())
+        {
             if requires_inference {
                 if let (Some(Some(annotation)), Some(option))
                 | (Some(option), Some(Some(annotation))) = (param, return_type)

crates/oxc_isolated_declarations/src/global_symbol_binding_tracker.rs

@@ -0,0 +1,251 @@
+use std::cell::Cell;
+
+#[allow(clippy::wildcard_imports)]
+use oxc_ast::ast::*;
+#[allow(clippy::wildcard_imports)]
+use oxc_ast::{visit::walk::*, Visit};
+use oxc_span::{Atom, GetSpan, Span};
+use oxc_syntax::scope::{ScopeFlags, ScopeId};
+use rustc_hash::FxHashSet;
+
+pub struct GlobalSymbolBindingTracker {
+    depth: u8,
+    symbol_binding_depth: Option<u8>,
+    global_this_binding_depth: Option<u8>,
+    computed_properties_using_non_global_symbol: FxHashSet<Span>,
+    computed_properties_using_non_global_global_this: FxHashSet<Span>,
+}
+
+impl GlobalSymbolBindingTracker {
+    pub fn new() -> Self {
+        Self {
+            depth: 0,
+            symbol_binding_depth: None,
+            global_this_binding_depth: None,
+            computed_properties_using_non_global_symbol: FxHashSet::default(),
+            computed_properties_using_non_global_global_this: FxHashSet::default(),
+        }
+    }
+
+    fn does_computed_property_reference_non_global_symbol(&self, key: &PropertyKey) -> bool {
+        self.computed_properties_using_non_global_symbol.contains(&key.span())
+    }
+
+    fn does_computed_property_reference_non_global_global_this(&self, key: &PropertyKey) -> bool {
+        self.computed_properties_using_non_global_global_this.contains(&key.span())
+    }
+
+    pub fn does_computed_property_reference_well_known_symbol(&self, key: &PropertyKey) -> bool {
+        if let PropertyKey::StaticMemberExpression(expr) = key {
+            if let Expression::Identifier(identifier) = &expr.object {
+                identifier.name == "Symbol"
+                    && !self.does_computed_property_reference_non_global_symbol(key)
+            } else if let Expression::StaticMemberExpression(static_member) = &expr.object {
+                if let Expression::Identifier(identifier) = &static_member.object {
+                    identifier.name == "globalThis"
+                        && static_member.property.name == "Symbol"
+                        && !self.does_computed_property_reference_non_global_global_this(key)
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
+    fn handle_name_binding(&mut self, name: &Atom) {
+        match name.as_str() {
+            "Symbol" if self.symbol_binding_depth.is_none() => {
+                self.symbol_binding_depth = Some(self.depth);
+            }
+            "globalThis" if self.global_this_binding_depth.is_none() => {
+                self.global_this_binding_depth = Some(self.depth);
+            }
+            _ => {}
+        }
+    }
+}
+
+impl<'a> Visit<'a> for GlobalSymbolBindingTracker {
+    fn enter_scope(&mut self, _: ScopeFlags, _: &Cell<Option<ScopeId>>) {
+        self.depth += 1;
+    }
+
+    fn leave_scope(&mut self) {
+        if self.symbol_binding_depth == Some(self.depth) {
+            self.symbol_binding_depth = None;
+        }
+        if self.global_this_binding_depth == Some(self.depth) {
+            self.global_this_binding_depth = None;
+        }
+        self.depth -= 1;
+    }
+
+    fn visit_ts_type(&mut self, _: &TSType<'a>) {
+        // Optimization: we don't need to traverse down into types.
+    }
+
+    fn visit_statement(&mut self, statement: &Statement<'a>) {
+        // Optimizations: Only try to visit parts of statements containing other statements.
+        match statement {
+            Statement::TSEnumDeclaration(_)
+            | Statement::TSTypeAliasDeclaration(_)
+            | Statement::TSInterfaceDeclaration(_) => (),
+            Statement::WhileStatement(stmt) => walk_statement(self, &stmt.body),
+            Statement::DoWhileStatement(stmt) => walk_statement(self, &stmt.body),
+            Statement::ForStatement(stmt) => walk_statement(self, &stmt.body),
+            Statement::ForInStatement(stmt) => walk_statement(self, &stmt.body),
+            Statement::ForOfStatement(stmt) => walk_statement(self, &stmt.body),
+            Statement::IfStatement(stmt) => {
+                walk_statement(self, &stmt.consequent);
+                if let Some(alt) = &stmt.alternate {
+                    walk_statement(self, alt);
+                }
+            }
+            Statement::SwitchStatement(stmt) => {
+                walk_switch_cases(self, &stmt.cases);
+            }
+            _ => walk_statement(self, statement),
+        }
+    }
+
+    fn visit_binding_pattern(&mut self, pattern: &BindingPattern<'a>) {
+        if let BindingPatternKind::BindingIdentifier(ident) = &pattern.kind {
+            self.handle_name_binding(&ident.name);
+        }
+        walk_binding_pattern(self, pattern);
+    }
+
+    fn visit_assignment_pattern(&mut self, pattern: &AssignmentPattern<'a>) {
+        // If the left side of the assignment already has a type annotation, we don't need to visit the right side.
+        if pattern.left.type_annotation.is_some() {
+            self.visit_binding_pattern(&pattern.left);
+            return;
+        }
+        walk_assignment_pattern(self, pattern);
+    }
+
+    fn visit_variable_declarator(&mut self, decl: &VariableDeclarator<'a>) {
+        // If the variable already has a type annotation, we don't need to visit the initializer.
+        if decl.id.type_annotation.is_some() {
+            self.visit_binding_pattern(&decl.id);
+        } else {
+            walk_variable_declarator(self, decl);
+        }
+    }
+
+    fn visit_assignment_expression(&mut self, expr: &AssignmentExpression<'a>) {
+        // If the left side of the assignment is a member expression, it won't affect emitted declarations.
+        if expr.left.is_member_expression() {
+            return;
+        }
+        walk_assignment_expression(self, expr);
+    }
+
+    fn visit_function(&mut self, func: &Function<'a>, flags: ScopeFlags) {
+        // Async and generator functions always need explicit declarations.
+        if func.generator || func.r#async {
+            return;
+        }
+
+        if let Some(id) = func.id.as_ref() {
+            self.handle_name_binding(&id.name);
+        }
+
+        // If the function already has a return type annotation, we don't need to visit the body.
+        if func.return_type.is_some() {
+            return;
+        }
+
+        walk_function(self, func, flags);
+    }
+
+    fn visit_arrow_function_expression(&mut self, func: &ArrowFunctionExpression<'a>) {
+        // If the arrow function already has a return type annotation, we don't need to visit the body.
+        if func.return_type.is_some() {
+            return;
+        }
+
+        walk_arrow_function_expression(self, func);
+    }
+
+    fn visit_expression(&mut self, expr: &Expression<'a>) {
+        match expr {
+            Expression::ArrowFunctionExpression(_)
+            | Expression::Identifier(_)
+            | Expression::ArrayExpression(_)
+            | Expression::AssignmentExpression(_)
+            | Expression::ClassExpression(_)
+            | Expression::FunctionExpression(_)
+            | Expression::ObjectExpression(_)
+            | Expression::ParenthesizedExpression(_) => {
+                // Expressions whose types can be inferred, but excluding trivial ones
+                // whose types will never contain a Symbol computed property.
+                walk_expression(self, expr);
+            }
+            _ => (),
+        }
+    }
+
+    fn visit_declaration(&mut self, declaration: &Declaration<'a>) {
+        match declaration {
+            Declaration::VariableDeclaration(_) | Declaration::FunctionDeclaration(_) => {
+                // handled in BindingPattern and Function
+            }
+            Declaration::ClassDeclaration(decl) => {
+                if let Some(id) = decl.id.as_ref() {
+                    self.handle_name_binding(&id.name);
+                }
+            }
+            Declaration::TSModuleDeclaration(decl) => {
+                if let TSModuleDeclarationName::Identifier(ident) = &decl.id {
+                    self.handle_name_binding(&ident.name);
+                }
+            }
+            Declaration::TSImportEqualsDeclaration(decl) => {
+                self.handle_name_binding(&decl.id.name);
+                return;
+            }
+            Declaration::TSEnumDeclaration(decl) => {
+                self.handle_name_binding(&decl.id.name);
+                return;
+            }
+            Declaration::TSTypeAliasDeclaration(_) | Declaration::TSInterfaceDeclaration(_) => {
+                return;
+            }
+        }
+        walk_declaration(self, declaration);
+    }
+
+    fn visit_object_property(&mut self, prop: &ObjectProperty<'a>) {
+        if prop.computed {
+            if let PropertyKey::StaticMemberExpression(expr) = &prop.key {
+                if self.symbol_binding_depth.is_some() {
+                    if let Expression::Identifier(identifier) = &expr.object {
+                        if identifier.name == "Symbol" {
+                            self.computed_properties_using_non_global_symbol.insert(expr.span);
+                        }
+                    }
+                }
+
+                if self.global_this_binding_depth.is_some() {
+                    if let Expression::StaticMemberExpression(static_member) = &expr.object {
+                        if let Expression::Identifier(identifier) = &static_member.object {
+                            if identifier.name == "globalThis"
+                                && static_member.property.name == "Symbol"
+                            {
+                                self.computed_properties_using_non_global_global_this
+                                    .insert(expr.span);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        walk_object_property(self, prop);
+    }
+}

crates/oxc_isolated_declarations/src/lib.rs

@@ -11,6 +11,7 @@ mod diagnostics;
 mod r#enum;
 mod formal_parameter_binding_pattern;
 mod function;
+mod global_symbol_binding_tracker;
 mod inferrer;
 mod literal;
 mod module;
@@ -29,6 +30,7 @@ use oxc_diagnostics::OxcDiagnostic;
 use oxc_span::{Atom, GetSpan, SourceType, SPAN};
 use rustc_hash::{FxHashMap, FxHashSet};
 
+use crate::global_symbol_binding_tracker::GlobalSymbolBindingTracker;
 use crate::scope::ScopeTree;
 
 #[derive(Debug, Clone, Copy)]
@@ -49,6 +51,7 @@ pub struct IsolatedDeclarations<'a> {
 
     // state
     scope: ScopeTree<'a>,
+    global_symbol_binding_tracker: GlobalSymbolBindingTracker,
     errors: RefCell<Vec<OxcDiagnostic>>,
 
     // options
@@ -75,6 +78,7 @@ impl<'a> IsolatedDeclarations<'a> {
             strip_internal,
             internal_annotations: is_internal_set,
             scope: ScopeTree::new(allocator),
+            global_symbol_binding_tracker: GlobalSymbolBindingTracker::new(),
             errors: RefCell::new(vec![]),
         }
     }
@@ -126,6 +130,10 @@ impl<'a> IsolatedDeclarations<'a> {
         &mut self,
         program: &Program<'a>,
     ) -> oxc_allocator::Vec<'a, Statement<'a>> {
+        // Collect information about global Symbol usage within computed
+        // properties before performing any transformations.
+        self.global_symbol_binding_tracker.visit_program(program);
+
         let has_import_or_export = program.body.iter().any(|stmt| {
             matches!(
                 stmt,

crates/oxc_isolated_declarations/src/types.rs

@@ -129,7 +129,7 @@ impl<'a> IsolatedDeclarations<'a> {
 
                     let property_signature = self.ast.ts_signature_property_signature(
                         object.span,
-                        false,
+                        object.computed,
                         false,
                         is_const,
                         // SAFETY: `ast.copy` is unsound! We need to fix.