feat(transformer): Optional Chaining (#6990)

close: #6958

crates/oxc_ast/src/ast_impl/js.rs

@@ -427,6 +427,15 @@ impl<'a> MemberExpression<'a> {
         }
     }
 
+    #[allow(missing_docs)]
+    pub fn object_mut(&mut self) -> &mut Expression<'a> {
+        match self {
+            MemberExpression::ComputedMemberExpression(expr) => &mut expr.object,
+            MemberExpression::StaticMemberExpression(expr) => &mut expr.object,
+            MemberExpression::PrivateFieldExpression(expr) => &mut expr.object,
+        }
+    }
+
     #[allow(missing_docs)]
     pub fn static_property_name(&self) -> Option<&'a str> {
         match self {

crates/oxc_transformer/src/compiler_assumptions.rs

@@ -45,7 +45,6 @@ pub struct CompilerAssumptions {
     pub no_class_calls: bool,
 
     #[serde(default)]
-    #[deprecated = "Not Implemented"]
     pub no_document_all: bool,
 
     #[serde(default)]
@@ -73,7 +72,6 @@ pub struct CompilerAssumptions {
     pub private_fields_as_properties: bool,
 
     #[serde(default)]
-    #[deprecated = "Not Implemented"]
     pub pure_getters: bool,
 
     #[serde(default)]

crates/oxc_transformer/src/context.rs

@@ -31,7 +31,6 @@ pub struct TransformCtx<'a> {
 
     pub module: Module,
 
-    #[expect(dead_code)]
     pub assumptions: CompilerAssumptions,
 
     // Helpers

crates/oxc_transformer/src/es2020/mod.rs

@@ -1,27 +1,34 @@
+mod nullish_coalescing_operator;
+mod optional_chaining;
+mod options;
+
 use oxc_ast::ast::*;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_traverse::{Traverse, TraverseCtx};
 
-use crate::TransformCtx;
-
-mod nullish_coalescing_operator;
-mod options;
-
 pub use nullish_coalescing_operator::NullishCoalescingOperator;
+pub use optional_chaining::OptionalChaining;
 pub use options::ES2020Options;
 
+use crate::TransformCtx;
+
 pub struct ES2020<'a, 'ctx> {
     ctx: &'ctx TransformCtx<'a>,
-
     options: ES2020Options,
 
     // Plugins
     nullish_coalescing_operator: NullishCoalescingOperator<'a, 'ctx>,
+    optional_chaining: OptionalChaining<'a, 'ctx>,
 }
 
 impl<'a, 'ctx> ES2020<'a, 'ctx> {
     pub fn new(options: ES2020Options, ctx: &'ctx TransformCtx<'a>) -> Self {
-        Self { ctx, nullish_coalescing_operator: NullishCoalescingOperator::new(ctx), options }
+        Self {
+            ctx,
+            options,
+            nullish_coalescing_operator: NullishCoalescingOperator::new(ctx),
+            optional_chaining: OptionalChaining::new(ctx),
+        }
     }
 }
 
@@ -30,6 +37,30 @@ impl<'a, 'ctx> Traverse<'a> for ES2020<'a, 'ctx> {
         if self.options.nullish_coalescing_operator {
             self.nullish_coalescing_operator.enter_expression(expr, ctx);
         }
+
+        if self.options.optional_chaining {
+            self.optional_chaining.enter_expression(expr, ctx);
+        }
+    }
+
+    fn enter_formal_parameters(
+        &mut self,
+        node: &mut FormalParameters<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+        if self.options.optional_chaining {
+            self.optional_chaining.enter_formal_parameters(node, ctx);
+        }
+    }
+
+    fn exit_formal_parameters(
+        &mut self,
+        node: &mut FormalParameters<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+        if self.options.optional_chaining {
+            self.optional_chaining.exit_formal_parameters(node, ctx);
+        }
     }
 
     fn enter_big_int_literal(&mut self, node: &mut BigIntLiteral<'a>, _ctx: &mut TraverseCtx<'a>) {