allow to configure last successful parse cache state

crates/next-core/src/next_client/context.rs

@@ -338,6 +338,7 @@ pub async fn get_client_module_options_context(
         tree_shaking_mode: tree_shaking_mode_for_user_code,
         enable_postcss_transform,
         side_effect_free_packages: next_config.optimize_package_imports().await?.clone_value(),
+        keep_last_successful_parse: next_mode.is_development(),
         ..Default::default()
     };
 

crates/next-core/src/next_server/context.rs

@@ -556,6 +556,7 @@ pub async fn get_server_module_options_context(
         } else {
             None
         },
+        keep_last_successful_parse: next_mode.is_development(),
         ..Default::default()
     };
 

turbopack/crates/turbopack-cli/src/contexts.rs

@@ -109,16 +109,18 @@ async fn get_client_module_options_context(
     node_env: Vc<NodeEnv>,
     source_maps_type: SourceMapsType,
 ) -> Result<Vc<ModuleOptionsContext>> {
+    let is_dev = matches!(*node_env.await?, NodeEnv::Development);
     let module_options_context = ModuleOptionsContext {
         preset_env_versions: Some(env),
         execution_context: Some(execution_context),
         tree_shaking_mode: Some(TreeShakingMode::ReexportsOnly),
+        keep_last_successful_parse: is_dev,
         ..Default::default()
     };
 
     let resolve_options_context = get_client_resolve_options_context(project_path, node_env);
 
-    let enable_react_refresh = matches!(*node_env.await?, NodeEnv::Development)
+    let enable_react_refresh = is_dev
         && assert_can_resolve_react_refresh(project_path, resolve_options_context)
             .await?
             .is_found();
@@ -153,7 +155,7 @@ async fn get_client_module_options_context(
                 TypescriptTransformOptions::default().resolved_cell(),
             ),
             source_maps: source_maps_type,
-            ..Default::default()
+            ..module_options_context.ecmascript.clone()
         },
         enable_postcss_transform: Some(PostCssTransformOptions::default().resolved_cell()),
         rules: vec![(

turbopack/crates/turbopack-ecmascript/src/lib.rs

@@ -151,6 +151,10 @@ pub struct EcmascriptOptions {
     /// If true, it reads a sourceMappingURL comment from the end of the file,
     /// reads and generates a source map.
     pub extract_source_map: bool,
+    /// If true, it stores the last successful parse result in state and keeps using it when
+    /// parsing fails. This is useful to keep the module graph structure intact when syntax errors
+    /// are temporarily introduced.
+    pub keep_last_successful_parse: bool,
 }
 
 #[turbo_tasks::value(serialization = "auto_for_input")]
@@ -347,16 +351,20 @@ impl EcmascriptParsable for EcmascriptModuleAsset {
     #[turbo_tasks::function]
     async fn failsafe_parse(self: Vc<Self>) -> Result<Vc<ParseResult>> {
         let real_result = self.parse();
-        let real_result_value = real_result.await?;
         let this = self.await?;
-        let result_value = if matches!(*real_result_value, ParseResult::Ok { .. }) {
-            this.last_successful_parse.set(real_result_value.clone());
-            real_result_value
+        if this.options.await?.keep_last_successful_parse {
+            let real_result_value = real_result.await?;
+            let result_value = if matches!(*real_result_value, ParseResult::Ok { .. }) {
+                this.last_successful_parse.set(real_result_value.clone());
+                real_result_value
+            } else {
+                let state_ref = this.last_successful_parse.get();
+                state_ref.as_ref().unwrap_or(&real_result_value).clone()
+            };
+            Ok(ReadRef::cell(result_value))
         } else {
-            let state_ref = this.last_successful_parse.get();
-            state_ref.as_ref().unwrap_or(&real_result_value).clone()
-        };
-        Ok(ReadRef::cell(result_value))
+            Ok(real_result)
+        }
     }
 
     #[turbo_tasks::function]

turbopack/crates/turbopack/src/module_options/mod.rs

@@ -98,6 +98,7 @@ impl ModuleOptions {
             execution_context,
             ref rules,
             tree_shaking_mode,
+            keep_last_successful_parse,
             ..
         } = *module_options_context.await?;
 
@@ -141,6 +142,7 @@ impl ModuleOptions {
             ignore_dynamic_requests,
             refresh,
             extract_source_map: matches!(ecmascript_source_maps, SourceMapsType::Full),
+            keep_last_successful_parse,
             ..Default::default()
         };
         let ecmascript_options_vc = ecmascript_options.resolved_cell();

turbopack/crates/turbopack/src/module_options/module_options_context.rs

@@ -135,6 +135,11 @@ pub struct ModuleOptionsContext {
     /// runtime.
     pub enable_externals_tracing: Option<ResolvedVc<FileSystemPath>>,
 
+    /// If true, it stores the last successful parse result in state and keeps using it when
+    /// parsing fails. This is useful to keep the module graph structure intact when syntax errors
+    /// are temporarily introduced.
+    pub keep_last_successful_parse: bool,
+
     /// Custom rules to be applied after all default rules.
     pub module_rules: Vec<ModuleRule>,
     /// A list of rules to use a different module option context for certain