feat: parser support jsx

crates/node_binding/napi-binding.d.ts

@@ -2333,6 +2333,11 @@ export interface RawJavascriptParserOptions {
    * @experimental
    */
   typeReexportsPresence?: string
+  /**
+   * This option is experimental in Rspack only and subject to change or be removed anytime.
+   * @experimental
+   */
+  jsx?: boolean
 }
 
 export interface RawJsonGeneratorOptions {

crates/rspack/src/builder/mod.rs

@@ -1716,6 +1716,7 @@ impl ModuleOptionsBuilder {
           import_dynamic: Some(true),
           commonjs_magic_comments: Some(false),
           inline_const: Some(false),
+          jsx: Some(false),
           ..Default::default()
         }),
       );

crates/rspack/tests/snapshots/defaults__default_options.snap

@@ -1444,6 +1444,9 @@ CompilerOptions {
                             inline_const: Some(
                                 false,
                             ),
+                            jsx: Some(
+                                false,
+                            ),
                         },
                     ),
                 },

crates/rspack_binding_api/src/raw_options/raw_module/mod.rs

@@ -298,6 +298,9 @@ pub struct RawJavascriptParserOptions {
   /// This option is experimental in Rspack only and subject to change or be removed anytime.
   /// @experimental
   pub type_reexports_presence: Option<String>,
+  /// This option is experimental in Rspack only and subject to change or be removed anytime.
+  /// @experimental
+  pub jsx: Option<bool>,
 }
 
 impl From<RawJavascriptParserOptions> for JavascriptParserOptions {
@@ -344,6 +347,7 @@ impl From<RawJavascriptParserOptions> for JavascriptParserOptions {
       import_dynamic: value.import_dynamic,
       commonjs_magic_comments: value.commonjs_magic_comments,
       inline_const: value.inline_const,
+      jsx: value.jsx,
     }
   }
 }

crates/rspack_core/src/concatenated_module.rs

@@ -30,7 +30,7 @@ use swc_core::{
   ecma::{
     ast::{EsVersion, Program},
     atoms::Atom,
-    parser::{Syntax, parse_file_as_module},
+    parser::{EsSyntax, Syntax, parse_file_as_module},
     transforms::base::resolver,
   },
 };
@@ -47,13 +47,13 @@ use crate::{
   IdentCollector, InitFragment, InitFragmentStage, LibIdentOptions,
   MaybeDynamicTargetExportInfoHashKey, Module, ModuleArgument, ModuleGraph,
   ModuleGraphCacheArtifact, ModuleGraphConnection, ModuleIdentifier, ModuleLayer,
-  ModuleStaticCacheArtifact, ModuleType, NAMESPACE_OBJECT_EXPORT, PrefetchExportsInfoMode, Resolve,
-  RuntimeCondition, RuntimeGlobals, RuntimeSpec, SourceType, UsageState, UsedName, UsedNameItem,
-  define_es_module_flag_statement, escape_identifier, filter_runtime, get_runtime_key,
-  impl_source_map_config, merge_runtime_condition, merge_runtime_condition_non_false,
-  module_update_hash, property_access, property_name, reserved_names::RESERVED_NAMES,
-  returning_function, runtime_condition_expression, subtract_runtime_condition,
-  to_identifier_with_escaped, to_normal_comment,
+  ModuleStaticCacheArtifact, ModuleType, NAMESPACE_OBJECT_EXPORT, ParserOptions,
+  PrefetchExportsInfoMode, Resolve, RuntimeCondition, RuntimeGlobals, RuntimeSpec, SourceType,
+  UsageState, UsedName, UsedNameItem, define_es_module_flag_statement, escape_identifier,
+  filter_runtime, get_runtime_key, impl_source_map_config, merge_runtime_condition,
+  merge_runtime_condition_non_false, module_update_hash, property_access, property_name,
+  reserved_names::RESERVED_NAMES, returning_function, runtime_condition_expression,
+  subtract_runtime_condition, to_identifier_with_escaped, to_normal_comment,
 };
 
 type ExportsDefinitionArgs = Vec<(String, String)>;
@@ -1993,10 +1993,24 @@ impl ConcatenatedModule {
       let comments = SwcComments::default();
       let mut module_info = concatenation_scope.current_module;
 
+      let jsx = module
+        .as_ref()
+        .as_normal_module()
+        .and_then(|normal_module| normal_module.get_parser_options())
+        .and_then(|options: &ParserOptions| {
+          options
+            .get_javascript()
+            .and_then(|js_options| js_options.jsx)
+        })
+        .unwrap_or(false);
+
       let mut errors = vec![];
       let program = match parse_file_as_module(
         &fm,
-        Syntax::default(),
+        Syntax::Es(EsSyntax {
+          jsx,
+          ..Default::default()
+        }),
         EsVersion::EsNext,
         Some(&comments),
         &mut errors,

crates/rspack_core/src/options/module.rs

@@ -284,6 +284,7 @@ pub struct JavascriptParserOptions {
   pub import_dynamic: Option<bool>,
   pub commonjs_magic_comments: Option<bool>,
   pub inline_const: Option<bool>,
+  pub jsx: Option<bool>,
 }
 
 #[cacheable]

crates/rspack_plugin_javascript/src/parser_and_generator/mod.rs

@@ -179,8 +179,15 @@ impl ParserAndGenerator for JavaScriptParserAndGenerator {
     );
     let comments = SwcComments::default();
     let target = ast::EsVersion::EsNext;
+
+    let jsx = module_parser_options
+      .and_then(|options| options.get_javascript())
+      .and_then(|options| options.jsx)
+      .unwrap_or(false);
+
     let parser_lexer = Lexer::new(
       Syntax::Es(EsSyntax {
+        jsx,
         allow_return_outside_function: matches!(
           module_type,
           ModuleType::JsDynamic | ModuleType::JsAuto

crates/rspack_plugin_javascript/src/visitors/dependency/parser/walk.rs

@@ -7,11 +7,13 @@ use swc_core::{
     ArrayLit, ArrayPat, ArrowExpr, AssignExpr, AssignPat, AssignTarget, AssignTargetPat, AwaitExpr,
     BinExpr, BlockStmt, BlockStmtOrExpr, CallExpr, Callee, CatchClause, Class, ClassExpr,
     ClassMember, CondExpr, DefaultDecl, DoWhileStmt, ExportDefaultDecl, Expr, ExprOrSpread,
-    ExprStmt, FnExpr, ForHead, ForInStmt, ForOfStmt, ForStmt, Function, GetterProp, Ident, IfStmt,
-    KeyValueProp, LabeledStmt, MemberExpr, MemberProp, MetaPropExpr, ModuleDecl, ModuleItem,
-    NewExpr, ObjectLit, ObjectPat, ObjectPatProp, OptCall, OptChainExpr, Param, Pat, Prop,
-    PropName, PropOrSpread, RestPat, ReturnStmt, SeqExpr, SetterProp, SimpleAssignTarget, Stmt,
-    SwitchCase, SwitchStmt, TaggedTpl, ThisExpr, ThrowStmt, Tpl, TryStmt, UnaryExpr, UnaryOp,
+    ExprStmt, FnExpr, ForHead, ForInStmt, ForOfStmt, ForStmt, Function, GetterProp, Ident,
+    IdentName, IfStmt, JSXAttr, JSXAttrOrSpread, JSXAttrValue, JSXElement, JSXElementChild,
+    JSXElementName, JSXExpr, JSXExprContainer, JSXFragment, JSXMemberExpr, JSXNamespacedName,
+    JSXObject, KeyValueProp, LabeledStmt, MemberExpr, MemberProp, MetaPropExpr, ModuleDecl,
+    ModuleItem, NewExpr, ObjectLit, ObjectPat, ObjectPatProp, OptCall, OptChainExpr, Param, Pat,
+    Prop, PropName, PropOrSpread, RestPat, ReturnStmt, SeqExpr, SetterProp, SimpleAssignTarget,
+    Stmt, SwitchCase, SwitchStmt, TaggedTpl, ThisExpr, ThrowStmt, Tpl, TryStmt, UnaryExpr, UnaryOp,
     UpdateExpr, VarDeclOrExpr, WhileStmt, WithStmt, YieldExpr,
   },
 };
@@ -431,12 +433,18 @@ impl JavascriptParser<'_> {
       Expr::Update(expr) => self.walk_update_expression(expr),
       Expr::Yield(expr) => self.walk_yield_expression(expr),
       Expr::SuperProp(_) | Expr::Lit(_) | Expr::PrivateName(_) | Expr::Invalid(_) => (),
+      Expr::JSXMember(_) | Expr::JSXNamespacedName(_) | Expr::JSXEmpty(_) => {
+        self.ensure_jsx_enabled();
+      }
+      Expr::JSXElement(element) => {
+        self.ensure_jsx_enabled();
+        self.walk_jsx_element(element);
+      }
+      Expr::JSXFragment(fragment) => {
+        self.ensure_jsx_enabled();
+        self.walk_jsx_fragment(fragment);
+      }
       Expr::Paren(_)
-      | Expr::JSXMember(_)
-      | Expr::JSXNamespacedName(_)
-      | Expr::JSXEmpty(_)
-      | Expr::JSXElement(_)
-      | Expr::JSXFragment(_)
       | Expr::TsTypeAssertion(_)
       | Expr::TsConstAssertion(_)
       | Expr::TsNonNull(_)
@@ -516,6 +524,114 @@ impl JavascriptParser<'_> {
     }
   }
 
+  fn ensure_jsx_enabled(&self) {
+    if !self.javascript_options.jsx.unwrap_or_default() {
+      unreachable!();
+    }
+  }
+
+  fn walk_jsx_element(&mut self, element: &JSXElement) {
+    self.walk_jsx_element_name(&element.opening.name);
+    if element.opening.type_args.is_some() {
+      // JSX type arguments only exist in TSX; this walker assumes pure JSX input.
+      unreachable!();
+    }
+    for attr in &element.opening.attrs {
+      self.walk_jsx_attr_or_spread(attr);
+    }
+    for child in &element.children {
+      self.walk_jsx_child(child);
+    }
+    if let Some(closing) = &element.closing {
+      self.walk_jsx_element_name(&closing.name);
+    }
+  }
+
+  fn walk_jsx_fragment(&mut self, fragment: &JSXFragment) {
+    for child in &fragment.children {
+      self.walk_jsx_child(child);
+    }
+  }
+
+  fn walk_jsx_child(&mut self, child: &JSXElementChild) {
+    match child {
+      JSXElementChild::JSXElement(element) => self.walk_jsx_element(element),
+      JSXElementChild::JSXFragment(fragment) => self.walk_jsx_fragment(fragment),
+      JSXElementChild::JSXExprContainer(container) => self.walk_jsx_expr_container(container),
+      JSXElementChild::JSXSpreadChild(spread) => self.walk_expression(&spread.expr),
+      JSXElementChild::JSXText(_) => (),
+    }
+  }
+
+  fn walk_jsx_expr_container(&mut self, container: &JSXExprContainer) {
+    match &container.expr {
+      JSXExpr::Expr(expr) => self.walk_expression(expr),
+      JSXExpr::JSXEmptyExpr(_) => (),
+    }
+  }
+
+  fn walk_jsx_attr_or_spread(&mut self, attr: &JSXAttrOrSpread) {
+    match attr {
+      JSXAttrOrSpread::JSXAttr(attr) => self.walk_jsx_attr(attr),
+      JSXAttrOrSpread::SpreadElement(spread) => self.walk_expression(&spread.expr),
+    }
+  }
+
+  fn walk_jsx_attr(&mut self, attr: &JSXAttr) {
+    if let Some(value) = &attr.value {
+      self.walk_jsx_attr_value(value);
+    }
+  }
+
+  fn walk_jsx_attr_value(&mut self, value: &JSXAttrValue) {
+    match value {
+      JSXAttrValue::Lit(_) => (),
+      JSXAttrValue::JSXExprContainer(container) => self.walk_jsx_expr_container(container),
+      JSXAttrValue::JSXElement(element) => self.walk_jsx_element(element),
+      JSXAttrValue::JSXFragment(fragment) => self.walk_jsx_fragment(fragment),
+    }
+  }
+
+  fn walk_jsx_element_name(&mut self, name: &JSXElementName) {
+    match name {
+      JSXElementName::Ident(ident) => self.walk_identifier(ident),
+      JSXElementName::JSXMemberExpr(member) => self.walk_jsx_member_expr(member),
+      JSXElementName::JSXNamespacedName(namespaced) => self.walk_jsx_namespaced_name(namespaced),
+    }
+  }
+
+  fn walk_jsx_member_expr(&mut self, member: &JSXMemberExpr) {
+    let member_expr = Self::jsx_member_expr_to_member_expr(member);
+    self.walk_member_expression(&member_expr);
+  }
+
+  fn jsx_member_expr_to_member_expr(member: &JSXMemberExpr) -> MemberExpr {
+    MemberExpr {
+      span: member.span,
+      obj: Box::new(Self::jsx_object_to_expr(&member.obj)),
+      prop: MemberProp::Ident(member.prop.clone()),
+    }
+  }
+
+  fn jsx_object_to_expr(obj: &JSXObject) -> Expr {
+    match obj {
+      JSXObject::Ident(ident) => Expr::Ident(ident.clone()),
+      JSXObject::JSXMemberExpr(member) => {
+        Expr::Member(Self::jsx_member_expr_to_member_expr(member))
+      }
+    }
+  }
+
+  fn walk_jsx_namespaced_name(&mut self, name: &JSXNamespacedName) {
+    self.walk_ident_name(&name.ns);
+    self.walk_ident_name(&name.name);
+  }
+
+  fn walk_ident_name(&mut self, name: &IdentName) {
+    let ident: Ident = name.clone().into();
+    self.walk_identifier(&ident);
+  }
+
   fn walk_object_expression(&mut self, expr: &ObjectLit) {
     for prop in &expr.props {
       self.walk_property_or_spread(prop);

packages/rspack/etc/core.api.md

@@ -3380,6 +3380,7 @@ export type JavascriptParserOptions = {
     commonjsMagicComments?: boolean;
     inlineConst?: boolean;
     typeReexportsPresence?: "no-tolerant" | "tolerant" | "tolerant-no-check";
+    jsx?: boolean;
 };
 
 // @public (undocumented)

packages/rspack/src/config/adapter.ts

@@ -586,7 +586,8 @@ function getRawJavascriptParserOptions(
 		importDynamic: parser.importDynamic,
 		commonjsMagicComments: parser.commonjsMagicComments,
 		inlineConst: parser.inlineConst,
-		typeReexportsPresence: parser.typeReexportsPresence
+		typeReexportsPresence: parser.typeReexportsPresence,
+		jsx: parser.jsx
 	};
 }
 

packages/rspack/src/config/defaults.ts

@@ -322,6 +322,7 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "importMeta", true);
 	D(parserOptions, "inlineConst", usedExports && inlineConst);
 	D(parserOptions, "typeReexportsPresence", "no-tolerant");
+	D(parserOptions, "jsx", false);
 };
 
 const applyJsonGeneratorOptionsDefaults = (

packages/rspack/src/config/types.ts

@@ -1118,6 +1118,9 @@ export type JavascriptParserOptions = {
 
 	/** Whether to tolerant exportsPresence for type reexport */
 	typeReexportsPresence?: "no-tolerant" | "tolerant" | "tolerant-no-check";
+
+	/** Whether to enable JSX parsing */
+	jsx?: boolean;
 };
 
 export type JsonParserOptions = {

packages/rspack/src/schema/config.ts

@@ -658,6 +658,7 @@ export const getRspackOptionsSchema = memoize(() => {
 		"tolerant",
 		"tolerant-no-check"
 	]);
+	const jsx = z.boolean();
 
 	const javascriptParserOptions = z
 		.strictObject({
@@ -684,7 +685,8 @@ export const getRspackOptionsSchema = memoize(() => {
 			requireResolve: requireResolve,
 			importDynamic: importDynamic,
 			inlineConst: inlineConst,
-			typeReexportsPresence: typeReexportsPresence
+			typeReexportsPresence: typeReexportsPresence,
+			jsx: jsx
 			// #endregion
 		})
 		.partial() satisfies z.ZodType<t.JavascriptParserOptions>;

packages/rspack/src/schema/loaders.ts

@@ -253,7 +253,7 @@ export const getZodSwcLoaderOptionsSchema = memoize(() => {
 					})
 					.partial()
 			),
-			runtime: z.enum(["automatic", "classic"]),
+			runtime: z.enum(["automatic", "classic", "preserve"]),
 			importSource: z.string()
 		})
 		.partial() satisfies z.ZodType<ReactConfig>;