refactor(linter): add FrameworkOptions to ContextSubHost

Author: Sysix

crates/oxc_linter/src/context/host.rs

@@ -9,7 +9,7 @@ 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,
@@ -27,12 +27,23 @@ pub struct ContextSubHost<'a> {
     /// 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,
 }
 
 impl<'a> ContextSubHost<'a> {
+    pub fn new(semantic: Rc<Semantic<'a>>, module_record: Arc<ModuleRecord>) -> Self {
+        Self::new_with_framework_options(semantic, module_record, FrameworkOptions::Default)
+    }
+
     /// # Panics
     /// If `semantic.cfg()` is `None`.
-    pub fn new(semantic: Rc<Semantic<'a>>, module_record: Arc<ModuleRecord>) -> Self {
+    pub fn new_with_framework_options(
+        semantic: Rc<Semantic<'a>>,
+        module_record: Arc<ModuleRecord>,
+        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!(
@@ -43,7 +54,12 @@ impl<'a> ContextSubHost<'a> {
         let disable_directives =
             DisableDirectivesBuilder::new().build(semantic.source_text(), semantic.comments());
 
-        Self { semantic, module_record, disable_directives: Rc::new(disable_directives) }
+        Self {
+            semantic,
+            module_record,
+            disable_directives: Rc::new(disable_directives),
+            framework_options: frameworks_options,
+        }
     }
 }
 /// Stores shared information about a file being linted.

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>`
+}

crates/oxc_linter/src/loader/partial_loader/vue.rs

@@ -2,6 +2,8 @@ use memchr::memmem::Finder;
 
 use oxc_span::SourceType;
 
+use crate::frameworks::FrameworkOptions;
+
 use super::{JavaScriptSource, SCRIPT_END, SCRIPT_START, find_script_closing_angle};
 
 pub struct VuePartialLoader<'a> {
@@ -52,6 +54,7 @@ impl<'a> VuePartialLoader<'a> {
 
         // parse `lang`
         let lang = Self::extract_lang_attribute(content);
+        let is_setup = content.contains("setup"); // check if "setup" is present, does not check if its inside an attribute
 
         let Ok(mut source_type) = SourceType::from_extension(lang) else { return None };
         if !lang.contains('x') {
@@ -70,7 +73,12 @@ impl<'a> VuePartialLoader<'a> {
         let source_text = &self.source_text[js_start..js_end];
         // NOTE: loader checked that source_text.len() is less than u32::MAX
         #[expect(clippy::cast_possible_truncation)]
-        Some(JavaScriptSource::partial(source_text, source_type, js_start as u32))
+        Some(JavaScriptSource::partial_with_framework_options(
+            source_text,
+            source_type,
+            if is_setup { FrameworkOptions::VueSetup } else { FrameworkOptions::Default },
+            js_start as u32,
+        ))
     }
 
     fn extract_lang_attribute(content: &str) -> &str {

crates/oxc_linter/src/loader/source.rs

@@ -1,5 +1,7 @@
 use oxc_span::SourceType;
 
+use crate::frameworks::FrameworkOptions;
+
 #[derive(Debug, Clone, Copy)]
 #[non_exhaustive]
 pub struct JavaScriptSource<'a> {
@@ -10,15 +12,38 @@ pub struct JavaScriptSource<'a> {
     pub start: u32,
     #[expect(dead_code)]
     is_partial: bool,
+
+    // some partial sources can have special options defined, like Vue's `<script setup>`.
+    pub framework_options: FrameworkOptions,
 }
 
 impl<'a> JavaScriptSource<'a> {
     pub fn new(source_text: &'a str, source_type: SourceType) -> Self {
-        Self { source_text, source_type, start: 0, is_partial: false }
+        Self {
+            source_text,
+            source_type,
+            start: 0,
+            is_partial: false,
+            framework_options: FrameworkOptions::Default,
+        }
     }
 
     pub fn partial(source_text: &'a str, source_type: SourceType, start: u32) -> Self {
-        Self { source_text, source_type, start, is_partial: true }
+        Self::partial_with_framework_options(
+            source_text,
+            source_type,
+            FrameworkOptions::Default,
+            start,
+        )
+    }
+
+    pub fn partial_with_framework_options(
+        source_text: &'a str,
+        source_type: SourceType,
+        framework_options: FrameworkOptions,
+        start: u32,
+    ) -> Self {
+        Self { source_text, source_type, start, is_partial: true, framework_options }
     }
 
     pub fn as_str(&self) -> &'a str {