perf: only query settings once

arendjr · arendjr · commit bbaaaa615550 · 2025-09-25T14:22:03.000+02:00
diff --git a/.changeset/max-managers-mandate.md b/.changeset/max-managers-mandate.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed an issue with the `files.maxSize` setting. Previously the setting would always be looked up in the root settings, even in monorepos where a closer `biome.json` is available. It now correctly uses the nearest configuration.
diff --git a/crates/biome_service/src/projects.rs b/crates/biome_service/src/projects.rs
@@ -327,31 +327,6 @@ impl Projects {
 
         belongs_to_project && !belongs_to_other
     }
-
-    /// Returns the maximum file size setting for the given project.
-    pub fn get_max_file_size(&self, project_key: ProjectKey, file_path: &Utf8Path) -> usize {
-        let limit = self
-            .0
-            .pin()
-            .get(&project_key)
-            .and_then(|data| {
-                data.root_settings
-                    .override_settings
-                    .patterns
-                    .iter()
-                    .find_map(|pattern| {
-                        if pattern.is_file_included(file_path) {
-                            pattern.files.max_size
-                        } else {
-                            None
-                        }
-                    })
-                    .or(data.root_settings.files.max_size)
-            })
-            .unwrap_or_default();
-
-        usize::from(limit)
-    }
 }
 
 #[inline]
diff --git a/crates/biome_service/src/settings.rs b/crates/biome_service/src/settings.rs
@@ -1162,6 +1162,25 @@ impl Settings {
             .unwrap_or_default()
             .into()
     }
+
+    /// Returns the maximum file size setting for the given `file_path`.
+    pub fn get_max_file_size(&self, file_path: &Utf8Path) -> usize {
+        let limit = self
+            .override_settings
+            .patterns
+            .iter()
+            .find_map(|pattern| {
+                if pattern.is_file_included(file_path) {
+                    pattern.files.max_size
+                } else {
+                    None
+                }
+            })
+            .or(self.files.max_size)
+            .unwrap_or_default();
+
+        usize::from(limit)
+    }
 }
 
 #[derive(Clone, Debug, Default)]
diff --git a/crates/biome_service/src/workspace/server.rs b/crates/biome_service/src/workspace/server.rs
@@ -18,6 +18,7 @@ use crate::workspace::document::EmbeddedLanguageSnippets;
 use append_only_vec::AppendOnlyVec;
 use biome_analyze::{AnalyzerPluginVec, RuleCategory};
 use biome_configuration::bool::Bool;
+use biome_configuration::max_size::MaxSize;
 use biome_configuration::plugins::{PluginConfiguration, Plugins};
 use biome_configuration::vcs::VcsClientKind;
 use biome_configuration::{BiomeDiagnostic, Configuration, ConfigurationPathHint};
@@ -292,6 +293,11 @@ impl WorkspaceServer {
 
         let mut source = document_file_source.unwrap_or(DocumentFileSource::from_path(&path));
 
+        let settings = self
+            .projects
+            .get_settings_based_on_path(project_key, &path)
+            .ok_or_else(WorkspaceError::no_project)?;
+
         if let DocumentFileSource::Js(js) = &mut source {
             match path.extension() {
                 Some("js") => {
@@ -308,10 +314,6 @@ impl WorkspaceServer {
                 _ => {}
             }
             if !js.is_typescript() && !js.is_jsx() {
-                let settings = self
-                    .projects
-                    .get_settings_based_on_path(project_key, &biome_path)
-                    .ok_or_else(WorkspaceError::no_project)?;
                 let jsx_everywhere = settings
                     .languages
                     .javascript
@@ -333,7 +335,7 @@ impl WorkspaceServer {
         let mut file_source_index = self.insert_source(source);
 
         let size = content.len();
-        let limit = self.projects.get_max_file_size(project_key, path.as_path());
+        let limit = settings.get_max_file_size(&path);
 
         let syntax = if size > limit {
             Some(Err(FileTooLarge { size, limit }))
@@ -342,9 +344,9 @@ impl WorkspaceServer {
         } else {
             let mut node_cache = NodeCache::default();
             let parsed = self.parse(
-                project_key,
                 &path,
                 &content,
+                &settings,
                 file_source_index,
                 &mut node_cache,
             )?;
@@ -363,19 +365,14 @@ impl WorkspaceServer {
             Some(Ok(parsed.any_parse))
         };
 
-        // Second-pass parsing for HTML files with embedded JavaScript and CSS content
-        let embedded_snippets = if let Some(DocumentFileSource::Html(_)) =
-            self.get_source(file_source_index)
-            && let Some(Ok(any_parse)) = &syntax
-            && let Some(html_root) = biome_html_syntax::HtmlRoot::cast(any_parse.syntax())
-        {
-            let mut node_cache = NodeCache::default();
+        // Second-pass parsing for HTML files with embedded JavaScript and CSS
+        // content.
+        let embedded_snippets = if let Some(Ok(parse)) = &syntax {
             self.parse_embedded_language_snippets(
-                project_key,
                 &biome_path,
-                &source,
-                &html_root,
-                &mut node_cache,
+                parse,
+                &settings,
+                file_source_index,
                 |file_source| self.insert_source(file_source),
             )?
         } else {
@@ -502,21 +499,26 @@ impl WorkspaceServer {
     /// parsing.
     fn parse_embedded_language_snippets(
         &self,
-        project_key: ProjectKey,
         path: &BiomePath,
-        source: &DocumentFileSource,
-        html_root: &HtmlRoot,
-        cache: &mut NodeCache,
+        parse: &AnyParse,
+        settings: &Settings,
+        file_source_index: usize,
         source_index_fn: impl Fn(DocumentFileSource) -> usize,
     ) -> Result<EmbeddedLanguageSnippets, WorkspaceError> {
+        let (source, html_root) = match self.get_source(file_source_index) {
+            Some(source @ DocumentFileSource::Html(_)) => match HtmlRoot::cast(parse.syntax()) {
+                Some(html_root) => (source, html_root),
+                None => return Ok(Default::default()),
+            },
+            _ => return Ok(Default::default()),
+        };
+
         let mut scripts = Vec::new();
         let mut json = Vec::new();
         let mut styles = Vec::new();
 
-        let settings = self
-            .projects
-            .get_settings_based_on_path(project_key, path)
-            .ok_or_else(WorkspaceError::no_project)?;
+        let mut cache = NodeCache::default();
+
         // Walk through all HTML elements looking for script and style tags
         for element in html_root.syntax().descendants() {
             let Some(element) = HtmlElement::cast(element) else {
@@ -527,34 +529,36 @@ impl WorkspaceServer {
 
             if let Some(script_type) = element.get_script_type() {
                 if script_type.is_javascript() {
-                    let options = settings.parse_options::<JsLanguage>(path, source);
+                    let options = settings.parse_options::<JsLanguage>(path, &source);
 
                     if let Some(list) = parse_embedded_js_script(
                         element,
                         script_type,
-                        cache,
+                        &mut cache,
                         options,
                         |file_source| source_index_fn(file_source.into()),
                     ) {
                         scripts.extend(list)
                     }
                 } else if script_type.is_json() {
-                    let options = settings.parse_options::<JsonLanguage>(path, source);
+                    let options = settings.parse_options::<JsonLanguage>(path, &source);
 
                     if let Some(list) =
-                        parse_embedded_json(element, cache, options, |file_source| {
+                        parse_embedded_json(element, &mut cache, options, |file_source| {
                             source_index_fn(file_source.into())
                         })
                     {
                         json.extend(list)
                     }
                 }
             } else if element.is_style_tag() {
-                let options = settings.parse_options::<CssLanguage>(path, source);
+                let options = settings.parse_options::<CssLanguage>(path, &source);
 
-                if let Some(list) = parse_embedded_style(element, cache, options, |file_source| {
-                    source_index_fn(file_source.into())
-                }) {
+                if let Some(list) =
+                    parse_embedded_style(element, &mut cache, options, |file_source| {
+                        source_index_fn(file_source.into())
+                    })
+                {
                     styles.extend(list)
                 }
             }
@@ -569,9 +573,9 @@ impl WorkspaceServer {
 
     fn parse(
         &self,
-        project_key: ProjectKey,
         path: &Utf8Path,
         content: &str,
+        settings: &Settings,
         file_source_index: usize,
         node_cache: &mut NodeCache,
     ) -> Result<ParseResult, WorkspaceError> {
@@ -585,15 +589,11 @@ impl WorkspaceServer {
             .parse
             .ok_or_else(self.build_capability_error(path))?;
 
-        let settings = self
-            .projects
-            .get_settings_based_on_path(project_key, path)
-            .ok_or_else(WorkspaceError::no_project)?;
         let parsed = parse(
             &BiomePath::new(path),
             file_source,
             content,
-            &settings,
+            settings,
             node_cache,
         );
         Ok(parsed)
@@ -1254,7 +1254,11 @@ impl Workspace for WorkspaceServer {
         let file_size = document.content.len();
         let limit = self
             .projects
-            .get_max_file_size(params.project_key, params.path.as_path());
+            .get_settings_based_on_path(params.project_key, &params.path)
+            .map_or_else(
+                || MaxSize::default().into(),
+                |settings| settings.get_max_file_size(&params.path),
+            );
         Ok(CheckFileSizeResult { file_size, limit })
     }
 
@@ -1276,11 +1280,17 @@ impl Workspace for WorkspaceServer {
 
         if existing_version.is_some_and(|existing_version| existing_version >= version) {
             warn!(%version, %path, "outdated_file_change");
+            // Safely ignore older versions.
             return Ok(ChangeFileResult {
-                diagnostics: vec![],
-            }); // Safely ignore older versions.
+                diagnostics: Vec::new(),
+            });
         }
 
+        let settings = self
+            .projects
+            .get_settings_based_on_path(project_key, &path)
+            .ok_or_else(WorkspaceError::no_project)?;
+
         // We remove the node cache for the document, if it exists.
         // This is done so that we need to hold the lock as short as possible
         // (it's released directly after the statement). The potential downside
@@ -1293,27 +1303,17 @@ impl Workspace for WorkspaceServer {
         let persist_node_cache = node_cache.is_some();
         let mut node_cache = node_cache.unwrap_or_default();
 
-        let parsed = self.parse(project_key, &path, &content, index, &mut node_cache)?;
+        let parsed = self.parse(&path, &content, &settings, index, &mut node_cache)?;
         let root = parsed.any_parse.root();
 
         // Second-pass parsing for HTML files with embedded JavaScript and CSS content
-        let embedded_snippets = if let Some(file_source) = self.get_source(index)
-            && matches!(file_source, DocumentFileSource::Html(_))
-            && let Some(html_root) =
-                biome_html_syntax::HtmlRoot::cast(parsed.any_parse.syntax().clone())
-        {
-            let mut embedded_node_cache = NodeCache::default();
-            self.parse_embedded_language_snippets(
-                project_key,
-                &path,
-                &file_source,
-                &html_root,
-                &mut embedded_node_cache,
-                |file_source| self.insert_source(file_source),
-            )?
-        } else {
-            Default::default()
-        };
+        let embedded_snippets = self.parse_embedded_language_snippets(
+            &path,
+            &parsed.any_parse,
+            &settings,
+            index,
+            |file_source| self.insert_source(file_source),
+        )?;
 
         let document = Document {
             content,

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@biomejs/biome": patch
 +---
++
 +Fixed an issue with the `files.maxSize` setting. Previously the setting would always be looked up in the root settings, even in monorepos where a closer `biome.json` is available. It now correctly uses the nearest configuration.