diff --git a/Cargo.lock b/Cargo.lock
index a1c2b49fa2f9a..0e684d26157a4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2161,6 +2161,7 @@ dependencies = [
  "oxc_formatter",
  "oxc_linter",
  "oxc_parser 0.94.0",
+ "oxc_span 0.94.0",
  "papaya",
  "rustc-hash",
  "serde",
diff --git a/crates/oxc_language_server/Cargo.toml b/crates/oxc_language_server/Cargo.toml
index 9d1c2eab0d154..cbf20bc35f808 100644
--- a/crates/oxc_language_server/Cargo.toml
+++ b/crates/oxc_language_server/Cargo.toml
@@ -28,6 +28,7 @@ oxc_diagnostics = { workspace = true }
 oxc_formatter = { workspace = true }
 oxc_linter = { workspace = true, features = ["language_server"] }
 oxc_parser = { workspace = true }
+oxc_span = { workspace = true }
 
 #
 env_logger = { workspace = true, features = ["humantime"] }
diff --git a/crates/oxc_language_server/src/linter/error_with_position.rs b/crates/oxc_language_server/src/linter/error_with_position.rs
index 5285783bf797f..3fa703398b55c 100644
--- a/crates/oxc_language_server/src/linter/error_with_position.rs
+++ b/crates/oxc_language_server/src/linter/error_with_position.rs
@@ -1,14 +1,14 @@
 use std::{borrow::Cow, str::FromStr};
 
-use oxc_linter::{
-    FixWithPosition, MessageWithPosition, PossibleFixesWithPosition, SpanPositionMessage,
-};
 use tower_lsp_server::lsp_types::{
     self, CodeDescription, DiagnosticRelatedInformation, DiagnosticSeverity, NumberOrString,
     Position, Range, Uri,
 };
 
-use oxc_diagnostics::Severity;
+use oxc_data_structures::rope::{Rope, get_line_column};
+use oxc_diagnostics::{OxcCode, OxcDiagnostic, Severity};
+use oxc_linter::{Fix, Message, PossibleFixes};
+use oxc_span::GetSpan;
 
 #[derive(Debug, Clone, Default)]
 pub struct DiagnosticReport {
@@ -171,3 +171,356 @@ pub fn generate_inverted_diagnostics(
     }
     inverted_diagnostics
 }
+
+#[derive(Clone, Debug)]
+pub struct SpanPositionMessage<'a> {
+    /// A brief suggestion message describing the fix. Will be shown in
+    /// editors via code actions.
+    message: Option<Cow<'a, str>>,
+
+    start: SpanPosition,
+    end: SpanPosition,
+}
+
+impl<'a> SpanPositionMessage<'a> {
+    pub fn new(start: SpanPosition, end: SpanPosition) -> Self {
+        Self { start, end, message: None }
+    }
+
+    #[must_use]
+    pub fn with_message(mut self, message: Option<Cow<'a, str>>) -> Self {
+        self.message = message;
+        self
+    }
+
+    pub fn start(&self) -> &SpanPosition {
+        &self.start
+    }
+
+    pub fn end(&self) -> &SpanPosition {
+        &self.end
+    }
+
+    pub fn message(&self) -> Option<&Cow<'a, str>> {
+        self.message.as_ref()
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct SpanPosition {
+    pub line: u32,
+    pub character: u32,
+}
+
+impl SpanPosition {
+    pub fn new(line: u32, column: u32) -> Self {
+        Self { line, character: column }
+    }
+}
+
+pub fn offset_to_position(rope: &Rope, offset: u32, source_text: &str) -> SpanPosition {
+    let (line, column) = get_line_column(rope, offset, source_text);
+    SpanPosition::new(line, column)
+}
+
+#[derive(Debug)]
+pub struct MessageWithPosition<'a> {
+    pub message: Cow<'a, str>,
+    pub labels: Option<Vec<SpanPositionMessage<'a>>>,
+    pub help: Option<Cow<'a, str>>,
+    pub severity: Severity,
+    pub code: OxcCode,
+    pub url: Option<Cow<'a, str>>,
+    pub fixes: PossibleFixesWithPosition<'a>,
+}
+
+// clippy: the source field is checked and assumed to be less than 4GB, and
+// we assume that the fix offset will not exceed 2GB in either direction
+#[expect(clippy::cast_possible_truncation)]
+pub fn oxc_diagnostic_to_message_with_position<'a>(
+    diagnostic: OxcDiagnostic,
+    source_text: &str,
+    rope: &Rope,
+) -> MessageWithPosition<'a> {
+    let inner = diagnostic.inner_owned();
+
+    let labels = inner.labels.as_ref().map(|labels| {
+        labels
+            .iter()
+            .map(|labeled_span| {
+                let offset = labeled_span.offset() as u32;
+                let start_position = offset_to_position(rope, offset, source_text);
+                let end_position =
+                    offset_to_position(rope, offset + labeled_span.len() as u32, source_text);
+                let message = labeled_span.label().map(|label| Cow::Owned(label.to_string()));
+
+                SpanPositionMessage::new(start_position, end_position).with_message(message)
+            })
+            .collect::<Vec<_>>()
+    });
+
+    MessageWithPosition {
+        message: inner.message,
+        severity: inner.severity,
+        help: inner.help,
+        url: inner.url,
+        code: inner.code,
+        labels,
+        fixes: PossibleFixesWithPosition::None,
+    }
+}
+
+pub fn message_to_message_with_position<'a>(
+    message: Message<'a>,
+    source_text: &str,
+    rope: &Rope,
+) -> MessageWithPosition<'a> {
+    let code = message.error.code.clone();
+    let error_offset = message.span().start;
+    let section_offset = message.section_offset;
+
+    let mut result = oxc_diagnostic_to_message_with_position(message.error, source_text, rope);
+    let fixes = match &message.fixes {
+        PossibleFixes::None => PossibleFixesWithPosition::None,
+        PossibleFixes::Single(fix) => {
+            PossibleFixesWithPosition::Single(fix_to_fix_with_position(fix, rope, source_text))
+        }
+        PossibleFixes::Multiple(fixes) => PossibleFixesWithPosition::Multiple(
+            fixes.iter().map(|fix| fix_to_fix_with_position(fix, rope, source_text)).collect(),
+        ),
+    };
+
+    result.fixes = add_ignore_fixes(fixes, &code, error_offset, section_offset, rope, source_text);
+
+    result
+}
+
+/// Possible fixes with position information.
+///
+/// This is similar to `PossibleFixes` but with position information.
+/// It also includes "ignore this line" and "ignore this rule" fixes for the Language Server.
+///
+/// The struct should be build with `message_to_message_with_position`
+/// or `oxc_diagnostic_to_message_with_position` function to ensure the ignore fixes are added correctly.
+#[derive(Debug)]
+pub enum PossibleFixesWithPosition<'a> {
+    // No possible fixes.
+    // This happens on parser/semantic errors.
+    None,
+    // A single possible fix.
+    // This happens when a unused disable directive is reported.
+    Single(FixWithPosition<'a>),
+    // Multiple possible fixes.
+    // This happens when a lint reports a violation, then ignore fixes are added.
+    Multiple(Vec<FixWithPosition<'a>>),
+}
+
+#[derive(Debug)]
+pub struct FixWithPosition<'a> {
+    pub content: Cow<'a, str>,
+    pub span: SpanPositionMessage<'a>,
+}
+
+fn fix_to_fix_with_position<'a>(
+    fix: &Fix<'a>,
+    rope: &Rope,
+    source_text: &str,
+) -> FixWithPosition<'a> {
+    let start_position = offset_to_position(rope, fix.span.start, source_text);
+    let end_position = offset_to_position(rope, fix.span.end, source_text);
+    FixWithPosition {
+        content: fix.content.clone(),
+        span: SpanPositionMessage::new(start_position, end_position)
+            .with_message(fix.message.as_ref().map(|label| Cow::Owned(label.to_string()))),
+    }
+}
+
+/// Add "ignore this line" and "ignore this rule" fixes to the existing fixes.
+/// These fixes will be added to the end of the existing fixes.
+/// If the existing fixes already contain an "remove unused disable directive" fix,
+/// then no ignore fixes will be added.
+fn add_ignore_fixes<'a>(
+    fixes: PossibleFixesWithPosition<'a>,
+    code: &OxcCode,
+    error_offset: u32,
+    section_offset: u32,
+    rope: &Rope,
+    source_text: &str,
+) -> PossibleFixesWithPosition<'a> {
+    // do not append ignore code actions when the error is the ignore action
+    if matches!(fixes, PossibleFixesWithPosition::Single(ref fix) if fix.span.message.as_ref().is_some_and(|message| message.starts_with("remove unused disable directive")))
+    {
+        return fixes;
+    }
+
+    let mut new_fixes: Vec<FixWithPosition<'a>> = vec![];
+    if let PossibleFixesWithPosition::Single(fix) = fixes {
+        new_fixes.push(fix);
+    } else if let PossibleFixesWithPosition::Multiple(existing_fixes) = fixes {
+        new_fixes.extend(existing_fixes);
+    }
+
+    if let Some(rule_name) = code.number.as_ref() {
+        // TODO:  doesn't support disabling multiple rules by name for a given line.
+        new_fixes.push(disable_for_this_line(rule_name, error_offset, rope, source_text));
+        new_fixes.push(disable_for_this_section(rule_name, section_offset, rope, source_text));
+    }
+
+    if new_fixes.is_empty() {
+        PossibleFixesWithPosition::None
+    } else if new_fixes.len() == 1 {
+        PossibleFixesWithPosition::Single(new_fixes.remove(0))
+    } else {
+        PossibleFixesWithPosition::Multiple(new_fixes)
+    }
+}
+
+fn disable_for_this_line<'a>(
+    rule_name: &str,
+    error_offset: u32,
+    rope: &Rope,
+    source_text: &str,
+) -> FixWithPosition<'a> {
+    let mut start_position = offset_to_position(rope, error_offset, source_text);
+    start_position.character = 0; // TODO: character should be set to match the first non-whitespace character in the source text to match the existing indentation.
+    let end_position = start_position.clone();
+    FixWithPosition {
+        content: Cow::Owned(format!("// oxlint-disable-next-line {rule_name}\n")),
+        span: SpanPositionMessage::new(start_position, end_position)
+            .with_message(Some(Cow::Owned(format!("Disable {rule_name} for this line")))),
+    }
+}
+
+fn disable_for_this_section<'a>(
+    rule_name: &str,
+    section_offset: u32,
+    rope: &Rope,
+    source_text: &str,
+) -> FixWithPosition<'a> {
+    let comment = format!("// oxlint-disable {rule_name}\n");
+
+    let (content, offset) = if section_offset == 0 {
+        // JS files - insert at the beginning
+        (Cow::Owned(comment), section_offset)
+    } else {
+        // Framework files - check for line breaks at section_offset
+        let bytes = source_text.as_bytes();
+        let current = bytes.get(section_offset as usize);
+        let next = bytes.get((section_offset + 1) as usize);
+
+        match (current, next) {
+            (Some(b'\n'), _) => {
+                // LF at offset, insert after it
+                (Cow::Owned(comment), section_offset + 1)
+            }
+            (Some(b'\r'), Some(b'\n')) => {
+                // CRLF at offset, insert after both
+                (Cow::Owned(comment), section_offset + 2)
+            }
+            _ => {
+                // Not at line start, prepend newline
+                (Cow::Owned("\n".to_owned() + &comment), section_offset)
+            }
+        }
+    };
+
+    let position = offset_to_position(rope, offset, source_text);
+
+    FixWithPosition {
+        content,
+        span: SpanPositionMessage::new(position.clone(), position)
+            .with_message(Some(Cow::Owned(format!("Disable {rule_name} for this file")))),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use oxc_data_structures::rope::Rope;
+
+    use super::offset_to_position;
+
+    #[test]
+    fn single_line() {
+        let source = "foo.bar!;";
+        assert_position(source, 0, (0, 0));
+        assert_position(source, 4, (0, 4));
+        assert_position(source, 9, (0, 9));
+    }
+
+    #[test]
+    fn multi_line() {
+        let source = "console.log(\n  foo.bar!\n);";
+        assert_position(source, 0, (0, 0));
+        assert_position(source, 12, (0, 12));
+        assert_position(source, 13, (1, 0));
+        assert_position(source, 23, (1, 10));
+        assert_position(source, 24, (2, 0));
+        assert_position(source, 26, (2, 2));
+    }
+
+    #[test]
+    fn multi_byte() {
+        let source = "let foo = \n  '👍';";
+        assert_position(source, 10, (0, 10));
+        assert_position(source, 11, (1, 0));
+        assert_position(source, 14, (1, 3));
+        assert_position(source, 18, (1, 5));
+        assert_position(source, 19, (1, 6));
+    }
+
+    #[test]
+    #[should_panic(expected = "out of bounds")]
+    fn out_of_bounds() {
+        offset_to_position(&Rope::from_str("foo"), 100, "foo");
+    }
+
+    #[test]
+    fn disable_for_section_js_file() {
+        let source = "console.log('hello');";
+        let rope = Rope::from_str(source);
+        let fix = super::disable_for_this_section("no-console", 0, &rope, source);
+
+        assert_eq!(fix.content, "// oxlint-disable no-console\n");
+        assert_eq!(fix.span.start.line, 0);
+        assert_eq!(fix.span.start.character, 0);
+    }
+
+    #[test]
+    fn disable_for_section_after_lf() {
+        let source = "<script>\nconsole.log('hello');";
+        let rope = Rope::from_str(source);
+        let fix = super::disable_for_this_section("no-console", 8, &rope, source);
+
+        assert_eq!(fix.content, "// oxlint-disable no-console\n");
+        assert_eq!(fix.span.start.line, 1);
+        assert_eq!(fix.span.start.character, 0);
+    }
+
+    #[test]
+    fn disable_for_section_after_crlf() {
+        let source = "<script>\r\nconsole.log('hello');";
+        let rope = Rope::from_str(source);
+        let fix = super::disable_for_this_section("no-console", 8, &rope, source);
+
+        assert_eq!(fix.content, "// oxlint-disable no-console\n");
+        assert_eq!(fix.span.start.line, 1);
+        assert_eq!(fix.span.start.character, 0);
+    }
+
+    #[test]
+    fn disable_for_section_mid_line() {
+        let source = "const x = 5;";
+        let rope = Rope::from_str(source);
+        let fix = super::disable_for_this_section("no-unused-vars", 6, &rope, source);
+
+        assert_eq!(fix.content, "\n// oxlint-disable no-unused-vars\n");
+        assert_eq!(fix.span.start.line, 0);
+        assert_eq!(fix.span.start.character, 6);
+    }
+
+    fn assert_position(source: &str, offset: u32, expected: (u32, u32)) {
+        let position = offset_to_position(&Rope::from_str(source), offset, source);
+        assert_eq!(position.line, expected.0);
+        assert_eq!(position.character, expected.1);
+    }
+}
diff --git a/crates/oxc_language_server/src/linter/isolated_lint_handler.rs b/crates/oxc_language_server/src/linter/isolated_lint_handler.rs
index d754cc07641e3..6b6a0c0e1b260 100644
--- a/crates/oxc_language_server/src/linter/isolated_lint_handler.rs
+++ b/crates/oxc_language_server/src/linter/isolated_lint_handler.rs
@@ -11,13 +11,14 @@ use tower_lsp_server::{UriExt, lsp_types::Uri};
 use oxc_allocator::Allocator;
 use oxc_linter::{
     AllowWarnDeny, ConfigStore, DirectivesStore, DisableDirectives, LINTABLE_EXTENSIONS,
-    LintOptions, LintService, LintServiceOptions, Linter, MessageWithPosition,
-    message_to_message_with_position, read_to_arena_str,
+    LintOptions, LintService, LintServiceOptions, Linter, RuntimeFileSystem,
+    create_unused_directives_diagnostics, read_to_arena_str, read_to_string,
 };
-use oxc_linter::{RuntimeFileSystem, read_to_string};
 
 use super::error_with_position::{
-    DiagnosticReport, generate_inverted_diagnostics, message_with_position_to_lsp_diagnostic_report,
+    DiagnosticReport, MessageWithPosition, generate_inverted_diagnostics,
+    message_to_message_with_position, message_with_position_to_lsp_diagnostic_report,
+    oxc_diagnostic_to_message_with_position,
 };
 
 /// smaller subset of LintServiceOptions, which is used by IsolatedLintHandler
@@ -159,10 +160,6 @@ impl IsolatedLintHandler {
         source_text: &str,
         rope: &Rope,
     ) -> Vec<MessageWithPosition<'static>> {
-        use oxc_linter::{
-            create_unused_directives_diagnostics, oxc_diagnostic_to_message_with_position,
-        };
-
         let diagnostics = create_unused_directives_diagnostics(directives, severity);
         diagnostics
             .into_iter()
diff --git a/crates/oxc_language_server/src/linter/tsgo_linter.rs b/crates/oxc_language_server/src/linter/tsgo_linter.rs
index 913168bfb4a03..79c9bcf3b5bf8 100644
--- a/crates/oxc_language_server/src/linter/tsgo_linter.rs
+++ b/crates/oxc_language_server/src/linter/tsgo_linter.rs
@@ -6,13 +6,14 @@ use std::{
 use oxc_data_structures::rope::Rope;
 use oxc_linter::{
     ConfigStore, LINTABLE_EXTENSIONS, TsGoLintState, loader::LINT_PARTIAL_LOADER_EXTENSIONS,
-    message_to_message_with_position, read_to_string,
+    read_to_string,
 };
 use rustc_hash::FxHashSet;
 use tower_lsp_server::{UriExt, lsp_types::Uri};
 
 use crate::linter::error_with_position::{
-    DiagnosticReport, generate_inverted_diagnostics, message_with_position_to_lsp_diagnostic_report,
+    DiagnosticReport, generate_inverted_diagnostics, message_to_message_with_position,
+    message_with_position_to_lsp_diagnostic_report,
 };
 
 pub struct TsgoLinter {
diff --git a/crates/oxc_linter/src/fixer/fix.rs b/crates/oxc_linter/src/fixer/fix.rs
index 908a7abce168c..a69afdfb337c3 100644
--- a/crates/oxc_linter/src/fixer/fix.rs
+++ b/crates/oxc_linter/src/fixer/fix.rs
@@ -282,7 +282,7 @@ impl<'a> Deref for RuleFix<'a> {
 
 /// A completed, normalized fix ready to be applied to the source code.
 ///
-/// Used internally by this module. Lint rules should use [`RuleFix`].
+/// Used internally by this module. Lint rules should use `RuleFix`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub struct Fix<'a> {
@@ -332,6 +332,7 @@ impl<'a> Fix<'a> {
         Self { content: Cow::Borrowed(""), message: None, span: SPAN }
     }
 
+    #[must_use]
     pub fn with_message(mut self, message: impl Into<Cow<'a, str>>) -> Self {
         self.message = Some(message.into());
         self
diff --git a/crates/oxc_linter/src/fixer/mod.rs b/crates/oxc_linter/src/fixer/mod.rs
index f173ce1fd76cf..20cf07c80123a 100644
--- a/crates/oxc_linter/src/fixer/mod.rs
+++ b/crates/oxc_linter/src/fixer/mod.rs
@@ -264,6 +264,7 @@ impl<'a> Message<'a> {
     }
 
     #[cfg(feature = "language_server")]
+    #[must_use]
     pub fn with_section_offset(mut self, section_offset: u32) -> Self {
         self.section_offset = section_offset;
         self
diff --git a/crates/oxc_linter/src/lib.rs b/crates/oxc_linter/src/lib.rs
index 847874b67f824..0854fa9cb141f 100644
--- a/crates/oxc_linter/src/lib.rs
+++ b/crates/oxc_linter/src/lib.rs
@@ -25,8 +25,6 @@ mod external_plugin_store;
 mod fixer;
 mod frameworks;
 mod globals;
-#[cfg(feature = "language_server")]
-mod lsp;
 mod module_graph_visitor;
 mod module_record;
 mod options;
@@ -65,7 +63,7 @@ pub use crate::{
         LintFileResult, PluginLoadResult,
     },
     external_plugin_store::{ExternalPluginStore, ExternalRuleId},
-    fixer::FixKind,
+    fixer::{Fix, FixKind, Message, PossibleFixes},
     frameworks::FrameworkFlags,
     lint_runner::{DirectivesStore, LintRunner, LintRunnerBuilder},
     loader::LINTABLE_EXTENSIONS,
@@ -80,18 +78,12 @@ pub use crate::{
 use crate::{
     config::{LintConfig, OxlintEnv, OxlintGlobals, OxlintSettings},
     context::ContextHost,
-    fixer::{CompositeFix, Fix, Fixer, Message, PossibleFixes},
+    fixer::{CompositeFix, Fixer},
     loader::LINT_PARTIAL_LOADER_EXTENSIONS,
     rules::RuleEnum,
     utils::iter_possible_jest_call_node,
 };
 
-#[cfg(feature = "language_server")]
-pub use crate::lsp::{
-    FixWithPosition, MessageWithPosition, PossibleFixesWithPosition, SpanPositionMessage,
-    message_to_message_with_position, oxc_diagnostic_to_message_with_position,
-};
-
 #[cfg(target_pointer_width = "64")]
 #[test]
 fn size_asserts() {
diff --git a/crates/oxc_linter/src/lsp.rs b/crates/oxc_linter/src/lsp.rs
deleted file mode 100644
index 9c0d7b55ab67b..0000000000000
--- a/crates/oxc_linter/src/lsp.rs
+++ /dev/null
@@ -1,359 +0,0 @@
-use oxc_data_structures::rope::{Rope, get_line_column};
-use oxc_span::GetSpan;
-use std::borrow::Cow;
-
-use crate::fixer::{Fix, Message, PossibleFixes};
-use oxc_diagnostics::{OxcCode, OxcDiagnostic, Severity};
-
-#[derive(Clone, Debug)]
-pub struct SpanPositionMessage<'a> {
-    /// A brief suggestion message describing the fix. Will be shown in
-    /// editors via code actions.
-    message: Option<Cow<'a, str>>,
-
-    start: SpanPosition,
-    end: SpanPosition,
-}
-
-impl<'a> SpanPositionMessage<'a> {
-    pub fn new(start: SpanPosition, end: SpanPosition) -> Self {
-        Self { start, end, message: None }
-    }
-
-    #[must_use]
-    pub fn with_message(mut self, message: Option<Cow<'a, str>>) -> Self {
-        self.message = message;
-        self
-    }
-
-    pub fn start(&self) -> &SpanPosition {
-        &self.start
-    }
-
-    pub fn end(&self) -> &SpanPosition {
-        &self.end
-    }
-
-    pub fn message(&self) -> Option<&Cow<'a, str>> {
-        self.message.as_ref()
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct SpanPosition {
-    pub line: u32,
-    pub character: u32,
-}
-
-impl SpanPosition {
-    pub fn new(line: u32, column: u32) -> Self {
-        Self { line, character: column }
-    }
-}
-
-pub fn offset_to_position(rope: &Rope, offset: u32, source_text: &str) -> SpanPosition {
-    let (line, column) = get_line_column(rope, offset, source_text);
-    SpanPosition::new(line, column)
-}
-
-#[derive(Debug)]
-pub struct MessageWithPosition<'a> {
-    pub message: Cow<'a, str>,
-    pub labels: Option<Vec<SpanPositionMessage<'a>>>,
-    pub help: Option<Cow<'a, str>>,
-    pub severity: Severity,
-    pub code: OxcCode,
-    pub url: Option<Cow<'a, str>>,
-    pub fixes: PossibleFixesWithPosition<'a>,
-}
-
-// clippy: the source field is checked and assumed to be less than 4GB, and
-// we assume that the fix offset will not exceed 2GB in either direction
-#[expect(clippy::cast_possible_truncation)]
-pub fn oxc_diagnostic_to_message_with_position<'a>(
-    diagnostic: OxcDiagnostic,
-    source_text: &str,
-    rope: &Rope,
-) -> MessageWithPosition<'a> {
-    let inner = diagnostic.inner_owned();
-
-    let labels = inner.labels.as_ref().map(|labels| {
-        labels
-            .iter()
-            .map(|labeled_span| {
-                let offset = labeled_span.offset() as u32;
-                let start_position = offset_to_position(rope, offset, source_text);
-                let end_position =
-                    offset_to_position(rope, offset + labeled_span.len() as u32, source_text);
-                let message = labeled_span.label().map(|label| Cow::Owned(label.to_string()));
-
-                SpanPositionMessage::new(start_position, end_position).with_message(message)
-            })
-            .collect::<Vec<_>>()
-    });
-
-    MessageWithPosition {
-        message: inner.message,
-        severity: inner.severity,
-        help: inner.help,
-        url: inner.url,
-        code: inner.code,
-        labels,
-        fixes: PossibleFixesWithPosition::None,
-    }
-}
-
-pub fn message_to_message_with_position<'a>(
-    message: Message<'a>,
-    source_text: &str,
-    rope: &Rope,
-) -> MessageWithPosition<'a> {
-    let code = message.error.code.clone();
-    let error_offset = message.span().start;
-    let section_offset = message.section_offset;
-
-    let mut result = oxc_diagnostic_to_message_with_position(message.error, source_text, rope);
-    let fixes = match &message.fixes {
-        PossibleFixes::None => PossibleFixesWithPosition::None,
-        PossibleFixes::Single(fix) => {
-            PossibleFixesWithPosition::Single(fix_to_fix_with_position(fix, rope, source_text))
-        }
-        PossibleFixes::Multiple(fixes) => PossibleFixesWithPosition::Multiple(
-            fixes.iter().map(|fix| fix_to_fix_with_position(fix, rope, source_text)).collect(),
-        ),
-    };
-
-    result.fixes = add_ignore_fixes(fixes, &code, error_offset, section_offset, rope, source_text);
-
-    result
-}
-
-/// Possible fixes with position information.
-///
-/// This is similar to `PossibleFixes` but with position information.
-/// It also includes "ignore this line" and "ignore this rule" fixes for the Language Server.
-///
-/// The struct should be build with `message_to_message_with_position`
-/// or `oxc_diagnostic_to_message_with_position` function to ensure the ignore fixes are added correctly.
-#[derive(Debug)]
-pub enum PossibleFixesWithPosition<'a> {
-    // No possible fixes.
-    // This happens on parser/semantic errors.
-    None,
-    // A single possible fix.
-    // This happens when a unused disable directive is reported.
-    Single(FixWithPosition<'a>),
-    // Multiple possible fixes.
-    // This happens when a lint reports a violation, then ignore fixes are added.
-    Multiple(Vec<FixWithPosition<'a>>),
-}
-
-#[derive(Debug)]
-pub struct FixWithPosition<'a> {
-    pub content: Cow<'a, str>,
-    pub span: SpanPositionMessage<'a>,
-}
-
-fn fix_to_fix_with_position<'a>(
-    fix: &Fix<'a>,
-    rope: &Rope,
-    source_text: &str,
-) -> FixWithPosition<'a> {
-    let start_position = offset_to_position(rope, fix.span.start, source_text);
-    let end_position = offset_to_position(rope, fix.span.end, source_text);
-    FixWithPosition {
-        content: fix.content.clone(),
-        span: SpanPositionMessage::new(start_position, end_position)
-            .with_message(fix.message.as_ref().map(|label| Cow::Owned(label.to_string()))),
-    }
-}
-
-/// Add "ignore this line" and "ignore this rule" fixes to the existing fixes.
-/// These fixes will be added to the end of the existing fixes.
-/// If the existing fixes already contain an "remove unused disable directive" fix,
-/// then no ignore fixes will be added.
-fn add_ignore_fixes<'a>(
-    fixes: PossibleFixesWithPosition<'a>,
-    code: &OxcCode,
-    error_offset: u32,
-    section_offset: u32,
-    rope: &Rope,
-    source_text: &str,
-) -> PossibleFixesWithPosition<'a> {
-    // do not append ignore code actions when the error is the ignore action
-    if matches!(fixes, PossibleFixesWithPosition::Single(ref fix) if fix.span.message.as_ref().is_some_and(|message| message.starts_with("remove unused disable directive")))
-    {
-        return fixes;
-    }
-
-    let mut new_fixes: Vec<FixWithPosition<'a>> = vec![];
-    if let PossibleFixesWithPosition::Single(fix) = fixes {
-        new_fixes.push(fix);
-    } else if let PossibleFixesWithPosition::Multiple(existing_fixes) = fixes {
-        new_fixes.extend(existing_fixes);
-    }
-
-    if let Some(rule_name) = code.number.as_ref() {
-        // TODO:  doesn't support disabling multiple rules by name for a given line.
-        new_fixes.push(disable_for_this_line(rule_name, error_offset, rope, source_text));
-        new_fixes.push(disable_for_this_section(rule_name, section_offset, rope, source_text));
-    }
-
-    if new_fixes.is_empty() {
-        PossibleFixesWithPosition::None
-    } else if new_fixes.len() == 1 {
-        PossibleFixesWithPosition::Single(new_fixes.remove(0))
-    } else {
-        PossibleFixesWithPosition::Multiple(new_fixes)
-    }
-}
-
-fn disable_for_this_line<'a>(
-    rule_name: &str,
-    error_offset: u32,
-    rope: &Rope,
-    source_text: &str,
-) -> FixWithPosition<'a> {
-    let mut start_position = offset_to_position(rope, error_offset, source_text);
-    start_position.character = 0; // TODO: character should be set to match the first non-whitespace character in the source text to match the existing indentation.
-    let end_position = start_position.clone();
-    FixWithPosition {
-        content: Cow::Owned(format!("// oxlint-disable-next-line {rule_name}\n")),
-        span: SpanPositionMessage::new(start_position, end_position)
-            .with_message(Some(Cow::Owned(format!("Disable {rule_name} for this line")))),
-    }
-}
-
-fn disable_for_this_section<'a>(
-    rule_name: &str,
-    section_offset: u32,
-    rope: &Rope,
-    source_text: &str,
-) -> FixWithPosition<'a> {
-    let comment = format!("// oxlint-disable {rule_name}\n");
-
-    let (content, offset) = if section_offset == 0 {
-        // JS files - insert at the beginning
-        (Cow::Owned(comment), section_offset)
-    } else {
-        // Framework files - check for line breaks at section_offset
-        let bytes = source_text.as_bytes();
-        let current = bytes.get(section_offset as usize);
-        let next = bytes.get((section_offset + 1) as usize);
-
-        match (current, next) {
-            (Some(b'\n'), _) => {
-                // LF at offset, insert after it
-                (Cow::Owned(comment), section_offset + 1)
-            }
-            (Some(b'\r'), Some(b'\n')) => {
-                // CRLF at offset, insert after both
-                (Cow::Owned(comment), section_offset + 2)
-            }
-            _ => {
-                // Not at line start, prepend newline
-                (Cow::Owned("\n".to_owned() + &comment), section_offset)
-            }
-        }
-    };
-
-    let position = offset_to_position(rope, offset, source_text);
-
-    FixWithPosition {
-        content,
-        span: SpanPositionMessage::new(position.clone(), position)
-            .with_message(Some(Cow::Owned(format!("Disable {rule_name} for this file")))),
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use oxc_data_structures::rope::Rope;
-
-    use super::offset_to_position;
-
-    #[test]
-    fn single_line() {
-        let source = "foo.bar!;";
-        assert_position(source, 0, (0, 0));
-        assert_position(source, 4, (0, 4));
-        assert_position(source, 9, (0, 9));
-    }
-
-    #[test]
-    fn multi_line() {
-        let source = "console.log(\n  foo.bar!\n);";
-        assert_position(source, 0, (0, 0));
-        assert_position(source, 12, (0, 12));
-        assert_position(source, 13, (1, 0));
-        assert_position(source, 23, (1, 10));
-        assert_position(source, 24, (2, 0));
-        assert_position(source, 26, (2, 2));
-    }
-
-    #[test]
-    fn multi_byte() {
-        let source = "let foo = \n  '👍';";
-        assert_position(source, 10, (0, 10));
-        assert_position(source, 11, (1, 0));
-        assert_position(source, 14, (1, 3));
-        assert_position(source, 18, (1, 5));
-        assert_position(source, 19, (1, 6));
-    }
-
-    #[test]
-    #[should_panic(expected = "out of bounds")]
-    fn out_of_bounds() {
-        offset_to_position(&Rope::from_str("foo"), 100, "foo");
-    }
-
-    #[test]
-    fn disable_for_section_js_file() {
-        let source = "console.log('hello');";
-        let rope = Rope::from_str(source);
-        let fix = super::disable_for_this_section("no-console", 0, &rope, source);
-
-        assert_eq!(fix.content, "// oxlint-disable no-console\n");
-        assert_eq!(fix.span.start.line, 0);
-        assert_eq!(fix.span.start.character, 0);
-    }
-
-    #[test]
-    fn disable_for_section_after_lf() {
-        let source = "<script>\nconsole.log('hello');";
-        let rope = Rope::from_str(source);
-        let fix = super::disable_for_this_section("no-console", 8, &rope, source);
-
-        assert_eq!(fix.content, "// oxlint-disable no-console\n");
-        assert_eq!(fix.span.start.line, 1);
-        assert_eq!(fix.span.start.character, 0);
-    }
-
-    #[test]
-    fn disable_for_section_after_crlf() {
-        let source = "<script>\r\nconsole.log('hello');";
-        let rope = Rope::from_str(source);
-        let fix = super::disable_for_this_section("no-console", 8, &rope, source);
-
-        assert_eq!(fix.content, "// oxlint-disable no-console\n");
-        assert_eq!(fix.span.start.line, 1);
-        assert_eq!(fix.span.start.character, 0);
-    }
-
-    #[test]
-    fn disable_for_section_mid_line() {
-        let source = "const x = 5;";
-        let rope = Rope::from_str(source);
-        let fix = super::disable_for_this_section("no-unused-vars", 6, &rope, source);
-
-        assert_eq!(fix.content, "\n// oxlint-disable no-unused-vars\n");
-        assert_eq!(fix.span.start.line, 0);
-        assert_eq!(fix.span.start.character, 6);
-    }
-
-    fn assert_position(source: &str, offset: u32, expected: (u32, u32)) {
-        let position = offset_to_position(&Rope::from_str(source), offset, source);
-        assert_eq!(position.line, expected.0);
-        assert_eq!(position.character, expected.1);
-    }
-}