feat(transformer): move explicit resource management to ES2026

Move explicit resource management from proposals to ES2026, as it is now
a finalized ECMAScript 2026 feature.

Changes:
- Create ES2026 module with explicit_resource_management
- Update EnvOptions to include ES2026Options
- Remove explicit_resource_management from proposals
- Update TransformerImpl to use x2_es2026 instead of explicit_resource_management

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Boshen

crates/oxc_compat/src/es_features.rs

@@ -20,6 +20,7 @@ impl ESVersion for ESTarget {
             Self::ES2023 => Version(2023, 0, 0),
             Self::ES2024 => Version(2024, 0, 0),
             Self::ES2025 => Version(2025, 0, 0),
+            Self::ES2026 => Version(2026, 0, 0),
             Self::ESNext => Version(9999, 0, 0),
         }
     }

crates/oxc_compat/src/es_target.rs

@@ -18,6 +18,7 @@ pub enum ESTarget {
     ES2023,
     ES2024,
     ES2025,
+    ES2026,
     #[default]
     ESNext,
 }
@@ -39,6 +40,7 @@ impl FromStr for ESTarget {
             "es2023" => Ok(Self::ES2023),
             "es2024" => Ok(Self::ES2024),
             "es2025" => Ok(Self::ES2025),
+            "es2026" => Ok(Self::ES2026),
             "esnext" => Ok(Self::ESNext),
             _ => Err(format!("Invalid target \"{s}\".")),
         }
@@ -59,6 +61,7 @@ impl fmt::Display for ESTarget {
             Self::ES2023 => "es2023",
             Self::ES2024 => "es2024",
             Self::ES2025 => "es2025",
+            Self::ES2026 => "es2026",
             Self::ESNext => "esnext",
         };
         f.write_str(s)

crates/oxc_syntax/src/es_target.rs

@@ -0,0 +1,70 @@
+use oxc_ast::ast::*;
+use oxc_traverse::Traverse;
+
+use crate::{
+    context::{TransformCtx, TraverseCtx},
+    state::TransformState,
+};
+
+mod explicit_resource_management;
+mod options;
+
+use explicit_resource_management::ExplicitResourceManagement;
+pub use options::ES2026Options;
+
+pub struct ES2026<'a, 'ctx> {
+    explicit_resource_management: Option<ExplicitResourceManagement<'a, 'ctx>>,
+}
+
+impl<'a, 'ctx> ES2026<'a, 'ctx> {
+    pub fn new(options: ES2026Options, ctx: &'ctx TransformCtx<'a>) -> Self {
+        let explicit_resource_management = if options.explicit_resource_management {
+            Some(ExplicitResourceManagement::new(ctx))
+        } else {
+            None
+        };
+        Self { explicit_resource_management }
+    }
+}
+
+impl<'a> Traverse<'a, TransformState<'a>> for ES2026<'a, '_> {
+    fn enter_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
+        if let Some(explicit_resource_management) = &mut self.explicit_resource_management {
+            explicit_resource_management.enter_program(program, ctx);
+        }
+    }
+
+    fn enter_for_of_statement(
+        &mut self,
+        for_of_stmt: &mut ForOfStatement<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+        if let Some(explicit_resource_management) = &mut self.explicit_resource_management {
+            explicit_resource_management.enter_for_of_statement(for_of_stmt, ctx);
+        }
+    }
+
+    fn exit_static_block(&mut self, block: &mut StaticBlock<'a>, ctx: &mut TraverseCtx<'a>) {
+        if let Some(explicit_resource_management) = &mut self.explicit_resource_management {
+            explicit_resource_management.exit_static_block(block, ctx);
+        }
+    }
+
+    fn enter_function_body(&mut self, body: &mut FunctionBody<'a>, ctx: &mut TraverseCtx<'a>) {
+        if let Some(explicit_resource_management) = &mut self.explicit_resource_management {
+            explicit_resource_management.enter_function_body(body, ctx);
+        }
+    }
+
+    fn enter_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
+        if let Some(explicit_resource_management) = &mut self.explicit_resource_management {
+            explicit_resource_management.enter_statement(stmt, ctx);
+        }
+    }
+
+    fn enter_try_statement(&mut self, node: &mut TryStatement<'a>, ctx: &mut TraverseCtx<'a>) {
+        if let Some(explicit_resource_management) = &mut self.explicit_resource_management {
+            explicit_resource_management.enter_try_statement(node, ctx);
+        }
+    }
+}

crates/oxc_transformer/src/proposals/explicit_resource_management.rs renamed to crates/oxc_transformer/src/es2026/explicit_resource_management.rs

@@ -0,0 +1,8 @@
+use serde::Deserialize;
+
+#[derive(Debug, Default, Clone, Copy, Deserialize)]
+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]
+pub struct ES2026Options {
+    #[serde(skip)]
+    pub explicit_resource_management: bool,
+}

crates/oxc_transformer/src/es2026/mod.rs

@@ -31,6 +31,7 @@ mod es2019;
 mod es2020;
 mod es2021;
 mod es2022;
+mod es2026;
 mod jsx;
 mod proposals;
 mod regexp;
@@ -50,8 +51,8 @@ use es2019::ES2019;
 use es2020::ES2020;
 use es2021::ES2021;
 use es2022::ES2022;
+use es2026::ES2026;
 use jsx::Jsx;
-use proposals::ExplicitResourceManagement;
 use regexp::RegExp;
 use rustc_hash::FxHashMap;
 use state::TransformState;
@@ -70,6 +71,7 @@ pub use crate::{
     es2020::ES2020Options,
     es2021::ES2021Options,
     es2022::{ClassPropertiesOptions, ES2022Options},
+    es2026::ES2026Options,
     jsx::{JsxOptions, JsxRuntime, ReactRefreshOptions},
     options::{
         ESTarget, Engine, EngineTargets, EnvOptions, Module, TransformOptions,
@@ -98,6 +100,7 @@ pub struct Transformer<'a> {
     plugins: PluginsOptions,
     jsx: JsxOptions,
     env: EnvOptions,
+    #[expect(dead_code)]
     proposals: ProposalOptions,
 }
 
@@ -140,15 +143,12 @@ impl<'a> Transformer<'a> {
             common: Common::new(&self.env, &self.ctx),
             decorator: Decorator::new(self.decorator, &self.ctx),
             plugins: Plugins::new(self.plugins, &self.ctx),
-            explicit_resource_management: self
-                .proposals
-                .explicit_resource_management
-                .then(|| ExplicitResourceManagement::new(&self.ctx)),
             x0_typescript: program
                 .source_type
                 .is_typescript()
                 .then(|| TypeScript::new(&self.typescript, &self.ctx)),
             x1_jsx: Jsx::new(self.jsx, self.env.es2018.object_rest_spread, ast_builder, &self.ctx),
+            x2_es2026: ES2026::new(self.env.es2026, &self.ctx),
             x2_es2022: ES2022::new(
                 self.env.es2022,
                 !self.typescript.allow_declare_fields
@@ -178,8 +178,8 @@ struct TransformerImpl<'a, 'ctx> {
     x0_typescript: Option<TypeScript<'a, 'ctx>>,
     decorator: Decorator<'a, 'ctx>,
     plugins: Plugins<'a, 'ctx>,
-    explicit_resource_management: Option<ExplicitResourceManagement<'a, 'ctx>>,
     x1_jsx: Jsx<'a, 'ctx>,
+    x2_es2026: ES2026<'a, 'ctx>,
     x2_es2022: ES2022<'a, 'ctx>,
     x2_es2021: ES2021<'a, 'ctx>,
     x2_es2020: ES2020<'a, 'ctx>,
@@ -200,9 +200,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for TransformerImpl<'a, '_> {
         }
         self.plugins.enter_program(program, ctx);
         self.x1_jsx.enter_program(program, ctx);
-        if let Some(explicit_resource_management) = self.explicit_resource_management.as_mut() {
-            explicit_resource_management.enter_program(program, ctx);
-        }
+        self.x2_es2026.enter_program(program, ctx);
     }
 
     fn exit_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
@@ -316,9 +314,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for TransformerImpl<'a, '_> {
 
     fn exit_static_block(&mut self, block: &mut StaticBlock<'a>, ctx: &mut TraverseCtx<'a>) {
         self.common.exit_static_block(block, ctx);
-        if let Some(explicit_resource_management) = self.explicit_resource_management.as_mut() {
-            explicit_resource_management.exit_static_block(block, ctx);
-        }
+        self.x2_es2026.exit_static_block(block, ctx);
         self.x2_es2022.exit_static_block(block, ctx);
     }
 
@@ -409,9 +405,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for TransformerImpl<'a, '_> {
 
     fn enter_function_body(&mut self, body: &mut FunctionBody<'a>, ctx: &mut TraverseCtx<'a>) {
         self.common.enter_function_body(body, ctx);
-        if let Some(explicit_resource_management) = self.explicit_resource_management.as_mut() {
-            explicit_resource_management.enter_function_body(body, ctx);
-        }
+        self.x2_es2026.enter_function_body(body, ctx);
     }
 
     fn exit_function_body(&mut self, body: &mut FunctionBody<'a>, ctx: &mut TraverseCtx<'a>) {
@@ -603,9 +597,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for TransformerImpl<'a, '_> {
             typescript.enter_statement(stmt, ctx);
         }
         self.x2_es2018.enter_statement(stmt, ctx);
-        if let Some(explicit_resource_management) = self.explicit_resource_management.as_mut() {
-            explicit_resource_management.enter_statement(stmt, ctx);
-        }
+        self.x2_es2026.enter_statement(stmt, ctx);
     }
 
     fn enter_declaration(&mut self, decl: &mut Declaration<'a>, ctx: &mut TraverseCtx<'a>) {
@@ -646,9 +638,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for TransformerImpl<'a, '_> {
         if let Some(typescript) = self.x0_typescript.as_mut() {
             typescript.enter_for_of_statement(stmt, ctx);
         }
-        if let Some(explicit_resource_management) = self.explicit_resource_management.as_mut() {
-            explicit_resource_management.enter_for_of_statement(stmt, ctx);
-        }
+        self.x2_es2026.enter_for_of_statement(stmt, ctx);
         self.x2_es2018.enter_for_of_statement(stmt, ctx);
     }
 
@@ -660,9 +650,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for TransformerImpl<'a, '_> {
     }
 
     fn enter_try_statement(&mut self, stmt: &mut TryStatement<'a>, ctx: &mut TraverseCtx<'a>) {
-        if let Some(explicit_resource_management) = self.explicit_resource_management.as_mut() {
-            explicit_resource_management.enter_try_statement(stmt, ctx);
-        }
+        self.x2_es2026.enter_try_statement(stmt, ctx);
     }
 
     fn enter_catch_clause(&mut self, clause: &mut CatchClause<'a>, ctx: &mut TraverseCtx<'a>) {

crates/oxc_transformer/src/es2026/options.rs

@@ -70,10 +70,10 @@ pub struct BabelPlugins {
     // ES2022
     pub class_static_block: bool,
     pub class_properties: Option<ClassPropertiesOptions>,
+    // ES2026
+    pub explicit_resource_management: bool,
     // Decorator
     pub legacy_decorator: Option<DecoratorOptions>,
-    // Proposals
-    pub explicit_resource_management: bool,
     // Built-in plugins
     pub styled_components: Option<StyledComponentsOptions>,
 }

crates/oxc_transformer/src/lib.rs

@@ -9,6 +9,7 @@ use crate::{
     es2020::ES2020Options,
     es2021::ES2021Options,
     es2022::{ClassPropertiesOptions, ES2022Options},
+    es2026::ES2026Options,
     regexp::RegExpOptions,
 };
 
@@ -38,6 +39,8 @@ pub struct EnvOptions {
     pub es2021: ES2021Options,
 
     pub es2022: ES2022Options,
+
+    pub es2026: ES2026Options,
 }
 
 impl EnvOptions {
@@ -84,6 +87,7 @@ impl EnvOptions {
                 class_static_block: true,
                 class_properties: Some(ClassPropertiesOptions::default()),
             },
+            es2026: ES2026Options { explicit_resource_management: true },
         }
     }
 
@@ -161,6 +165,9 @@ impl From<EngineTargets> for EnvOptions {
                 class_static_block: o.has_feature(ES2022ClassStaticBlock),
                 class_properties: o.has_feature(ES2022ClassProperties).then(Default::default),
             },
+            es2026: ES2026Options {
+                explicit_resource_management: o.has_feature(ES2026ExplicitResourceManagement),
+            },
         }
     }
 }

crates/oxc_transformer/src/options/babel/plugins.rs

@@ -13,6 +13,7 @@ use crate::{
     es2020::ES2020Options,
     es2021::ES2021Options,
     es2022::ES2022Options,
+    es2026::ES2026Options,
     jsx::JsxOptions,
     plugins::{PluginsOptions, StyledComponentsOptions},
     proposals::ProposalOptions,
@@ -277,10 +278,11 @@ impl TryFrom<&BabelOptions> for TransformOptions {
                 es2020,
                 es2021,
                 es2022,
+                es2026: ES2026Options {
+                    explicit_resource_management: options.plugins.explicit_resource_management,
+                },
             },
-            proposals: ProposalOptions {
-                explicit_resource_management: options.plugins.explicit_resource_management,
-            },
+            proposals: ProposalOptions::default(),
             helper_loader,
             plugins,
         })