refactor(linter): introduce ContextSubHost for cross script block analyse (#12724)

Another approach to #12541 stack.
Because `vue/valid-define-emit` and other rules required the semantics of the other script block.

## The Goal:
`Linter.run` should run with the complete file context. In `vue` files and others, there can be multiple Semantics / Module Records.
Because `vue` requires some magic compiler rules, the linter should have access to the complete file.
This will also fix the offset bug in #12758. ~~**Don't** merge both stacks without rebasing.~~

I do not like the loop part. Maybe you guys have some better ideas.

---

<img width="1160" height="422" alt="benchmark results" src="https://github.com/user-attachments/assets/88702a01-eeb2-4a4f-8d80-c5236d3fa8cc" />

Author: Sysix

crates/oxc_linter/src/context/host.rs

@@ -9,14 +9,73 @@ use crate::{
     config::LintConfig,
     disable_directives::{DisableDirectives, DisableDirectivesBuilder, RuleCommentType},
     fixer::{Fix, FixKind, Message, PossibleFixes},
-    frameworks,
+    frameworks::{self, FrameworkOptions},
     module_record::ModuleRecord,
     options::LintOptions,
     rules::RuleEnum,
 };
 
 use super::{LintContext, plugin_name_to_prefix};
 
+/// Stores shared information about a script block being linted.
+pub struct ContextSubHost<'a> {
+    /// Shared semantic information about the file being linted, which includes scopes, symbols
+    /// and AST nodes. See [`Semantic`].
+    pub(super) semantic: Rc<Semantic<'a>>,
+    /// Cross module information.
+    pub(super) module_record: Arc<ModuleRecord>,
+    /// Information about specific rules that should be disabled or enabled, via comment directives like
+    /// `eslint-disable` or `eslint-disable-next-line`.
+    pub(super) disable_directives: Rc<DisableDirectives<'a>>,
+    // Specific framework options, for example, whether the context is inside `<script setup>` in Vue files.
+    #[expect(dead_code)]
+    pub(super) framework_options: FrameworkOptions,
+    /// The source text offset of the sub host
+    #[expect(dead_code)]
+    pub(super) source_text_offset: u32,
+}
+
+impl<'a> ContextSubHost<'a> {
+    pub fn new(
+        semantic: Rc<Semantic<'a>>,
+        module_record: Arc<ModuleRecord>,
+        source_text_offset: u32,
+    ) -> Self {
+        Self::new_with_framework_options(
+            semantic,
+            module_record,
+            source_text_offset,
+            FrameworkOptions::Default,
+        )
+    }
+
+    /// # Panics
+    /// If `semantic.cfg()` is `None`.
+    pub fn new_with_framework_options(
+        semantic: Rc<Semantic<'a>>,
+        module_record: Arc<ModuleRecord>,
+        source_text_offset: u32,
+        frameworks_options: FrameworkOptions,
+    ) -> Self {
+        // We should always check for `semantic.cfg()` being `Some` since we depend on it and it is
+        // unwrapped without any runtime checks after construction.
+        assert!(
+            semantic.cfg().is_some(),
+            "`LintContext` depends on `Semantic::cfg`, Build your semantic with cfg enabled(`SemanticBuilder::with_cfg`)."
+        );
+
+        let disable_directives =
+            DisableDirectivesBuilder::new().build(semantic.source_text(), semantic.comments());
+
+        Self {
+            semantic,
+            module_record,
+            source_text_offset,
+            disable_directives: Rc::new(disable_directives),
+            framework_options: frameworks_options,
+        }
+    }
+}
 /// Stores shared information about a file being linted.
 ///
 /// When linting a file, there are a number of shared resources that are
@@ -38,14 +97,11 @@ use super::{LintContext, plugin_name_to_prefix};
 #[must_use]
 #[non_exhaustive]
 pub struct ContextHost<'a> {
-    /// Shared semantic information about the file being linted, which includes scopes, symbols
-    /// and AST nodes. See [`Semantic`].
-    pub(super) semantic: Rc<Semantic<'a>>,
-    /// Cross module information.
-    pub(super) module_record: Arc<ModuleRecord>,
-    /// Information about specific rules that should be disabled or enabled, via comment directives like
-    /// `eslint-disable` or `eslint-disable-next-line`.
-    pub(super) disable_directives: DisableDirectives<'a>,
+    /// A file can have multiple script entries.
+    /// Some rules (like vue) need the information of the other entries.
+    pub(super) sub_hosts: Vec<ContextSubHost<'a>>,
+    /// The current index which will be linted.
+    current_sub_host_index: RefCell<usize>,
     /// Diagnostics reported by the linter.
     ///
     /// Contains diagnostics for all rules across a single file.
@@ -67,32 +123,25 @@ pub struct ContextHost<'a> {
 
 impl<'a> ContextHost<'a> {
     /// # Panics
-    /// If `semantic.cfg()` is `None`.
+    /// If `sub_hosts` is empty.
     pub fn new<P: AsRef<Path>>(
         file_path: P,
-        semantic: Rc<Semantic<'a>>,
-        module_record: Arc<ModuleRecord>,
+        sub_hosts: Vec<ContextSubHost<'a>>,
         options: LintOptions,
         config: Arc<LintConfig>,
     ) -> Self {
         const DIAGNOSTICS_INITIAL_CAPACITY: usize = 512;
 
-        // We should always check for `semantic.cfg()` being `Some` since we depend on it and it is
-        // unwrapped without any runtime checks after construction.
         assert!(
-            semantic.cfg().is_some(),
-            "`LintContext` depends on `Semantic::cfg`, Build your semantic with cfg enabled(`SemanticBuilder::with_cfg`)."
+            !sub_hosts.is_empty(),
+            "ContextHost requires at least one ContextSubHost to be analyzed"
         );
 
-        let disable_directives =
-            DisableDirectivesBuilder::new().build(semantic.source_text(), semantic.comments());
-
         let file_path = file_path.as_ref().to_path_buf().into_boxed_path();
 
         Self {
-            semantic,
-            module_record,
-            disable_directives,
+            sub_hosts,
+            current_sub_host_index: RefCell::new(0),
             diagnostics: RefCell::new(Vec::with_capacity(DIAGNOSTICS_INITIAL_CAPACITY)),
             fix: options.fix,
             file_path,
@@ -102,16 +151,26 @@ impl<'a> ContextHost<'a> {
         .sniff_for_frameworks()
     }
 
-    /// Shared reference to the [`Semantic`] analysis of the file.
+    /// The current [`ContextSubHost`]
+    fn current_sub_host(&self) -> &ContextSubHost<'a> {
+        &self.sub_hosts[*self.current_sub_host_index.borrow()]
+    }
+
+    /// Shared reference to the [`Semantic`] analysis of current script block.
     #[inline]
-    pub fn semantic(&self) -> &Semantic<'a> {
-        &self.semantic
+    pub fn semantic(&self) -> &Rc<Semantic<'a>> {
+        &self.current_sub_host().semantic
     }
 
-    /// Shared reference to the [`ModuleRecord`] of the file.
+    /// Shared reference to the [`ModuleRecord`] of the current script block.
     #[inline]
     pub fn module_record(&self) -> &ModuleRecord {
-        &self.module_record
+        &self.current_sub_host().module_record
+    }
+
+    /// Shared reference to the [`DisableDirectives`] of the current script block.
+    pub fn disable_directives(&self) -> &Rc<DisableDirectives<'a>> {
+        &self.current_sub_host().disable_directives
     }
 
     /// Path to the file being linted.
@@ -127,7 +186,7 @@ impl<'a> ContextHost<'a> {
     /// CJS, ESM, etc.
     #[inline]
     pub fn source_type(&self) -> &SourceType {
-        self.semantic.source_type()
+        self.semantic().source_type()
     }
 
     #[inline]
@@ -147,14 +206,20 @@ impl<'a> ContextHost<'a> {
         self.diagnostics.borrow_mut().extend(diagnostics);
     }
 
+    // move the context to the next sub host
+    pub fn next_sub_host(&self) -> bool {
+        *self.current_sub_host_index.borrow_mut() += 1;
+        self.sub_hosts.get(*self.current_sub_host_index.borrow()).is_some()
+    }
+
     /// report unused enable/disable directives, add these as Messages to diagnostics
     pub fn report_unused_directives(&self, rule_severity: Severity) {
         // report unused disable
         // relate to lint result, check after linter run finish
-        let unused_disable_comments = self.disable_directives.collect_unused_disable_comments();
+        let unused_disable_comments = self.disable_directives().collect_unused_disable_comments();
         let message_for_disable = "Unused eslint-disable directive (no problems were reported).";
         let fix_message = "remove unused disable directive";
-        let source_text = self.semantic.source_text();
+        let source_text = self.semantic().source_text();
 
         for unused_disable_comment in unused_disable_comments {
             let span = unused_disable_comment.span;
@@ -188,14 +253,14 @@ impl<'a> ContextHost<'a> {
             }
         }
 
-        let unused_enable_comments = self.disable_directives.unused_enable_comments();
+        let unused_enable_comments = self.disable_directives().unused_enable_comments();
         let mut unused_directive_diagnostics: Vec<(Cow<str>, Span)> =
             Vec::with_capacity(unused_enable_comments.len());
         // report unused enable
         // not relate to lint result, check during comment directives' construction
         let message_for_enable =
             "Unused eslint-enable directive (no matching eslint-disable directives were found).";
-        for (rule_name, enable_comment_span) in self.disable_directives.unused_enable_comments() {
+        for (rule_name, enable_comment_span) in self.disable_directives().unused_enable_comments() {
             unused_directive_diagnostics.push((
                 rule_name.map_or(Cow::Borrowed(message_for_enable), |name| {
                     Cow::Owned(format!(

crates/oxc_linter/src/context/mod.rs

@@ -20,7 +20,7 @@ use crate::{
 };
 
 mod host;
-pub use host::ContextHost;
+pub use host::{ContextHost, ContextSubHost};
 
 /// Contains all of the state and context specific to this lint rule.
 ///
@@ -106,7 +106,7 @@ impl<'a> LintContext<'a> {
     /// Refer to [`Semantic`]'s documentation for more information.
     #[inline]
     pub fn semantic(&self) -> &Rc<Semantic<'a>> {
-        &self.parent.semantic
+        self.parent.semantic()
     }
 
     #[inline]
@@ -119,19 +119,19 @@ impl<'a> LintContext<'a> {
     pub fn cfg(&self) -> &ControlFlowGraph {
         // SAFETY: `LintContext::new` is the only way to construct a `LintContext` and we always
         // assert the existence of control flow so it should always be `Some`.
-        unsafe { self.parent.semantic.cfg().unwrap_unchecked() }
+        unsafe { self.parent.semantic().cfg().unwrap_unchecked() }
     }
 
     /// List of all disable directives in the file being linted.
     #[inline]
-    pub fn disable_directives(&self) -> &DisableDirectives<'a> {
-        &self.parent.disable_directives
+    pub fn disable_directives(&self) -> &Rc<DisableDirectives<'a>> {
+        self.parent.disable_directives()
     }
 
     /// Get a snippet of source text covered by the given [`Span`]. For details,
     /// see [`Span::source_text`].
     pub fn source_range(&self, span: Span) -> &'a str {
-        span.source_text(self.parent.semantic.source_text())
+        span.source_text(self.parent.semantic().source_text())
     }
 
     /// Path to the file currently being linted.
@@ -222,7 +222,7 @@ impl<'a> LintContext<'a> {
     /// Add a diagnostic message to the list of diagnostics. Outputs a diagnostic with the current rule
     /// name, severity, and a link to the rule's documentation URL.
     fn add_diagnostic(&self, mut message: Message<'a>) {
-        if self.parent.disable_directives.contains(self.current_rule_name, message.span()) {
+        if self.parent.disable_directives().contains(self.current_rule_name, message.span()) {
             return;
         }
         message.error = message

crates/oxc_linter/src/frameworks.rs

@@ -95,3 +95,10 @@ pub fn has_vitest_imports(module_record: &ModuleRecord) -> bool {
 pub fn has_jest_imports(module_record: &ModuleRecord) -> bool {
     module_record.import_entries.iter().any(|entry| entry.module_request.name() == "@jest/globals")
 }
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+
+pub enum FrameworkOptions {
+    Default,  // default
+    VueSetup, // context is inside `<script setup>`
+}