refactor(language_server): simplify offset adjustment by using Message.move_offset (#12647)

Author: Sysix

crates/oxc_linter/src/service/runtime.rs

@@ -602,11 +602,10 @@ impl Runtime {
         fn fix_to_fix_with_position<'a>(
             fix: &Fix<'a>,
             rope: &Rope,
-            offset: u32,
             source_text: &str,
         ) -> FixWithPosition<'a> {
-            let start_position = offset_to_position(rope, offset + fix.span.start, source_text);
-            let end_position = offset_to_position(rope, offset + fix.span.end, source_text);
+            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)
@@ -629,99 +628,93 @@ impl Runtime {
                             .into_iter()
                             .zip(section_contents.drain(..))
                         {
-                            match record_result {
+                            let mut section_messages = match record_result {
                                 Err(diagnostics) => {
-                                    messages.lock().unwrap().extend(
-                                        diagnostics.into_iter().map(std::convert::Into::into),
-                                    );
+                                    messages
+                                        .lock()
+                                        .unwrap()
+                                        .extend(diagnostics.into_iter().map(Into::into));
+                                    continue;
                                 }
-                                Ok(module_record) => {
-                                    let section_message = me.linter.run(
-                                        Path::new(&module.path),
-                                        Rc::new(section.semantic.unwrap()),
-                                        Arc::clone(&module_record),
-                                        allocator_guard,
-                                    );
-
-                                    messages.lock().unwrap().extend(section_message.iter().map(
-                                        |message| {
-                                            let message = message.clone_in(allocator);
-
-                                            let labels =
-                                                &message.error.labels.clone().map(|labels| {
-                                                    labels
-                                                        .into_iter()
-                                                        .map(|labeled_span| {
-                                                            let offset =
-                                                                labeled_span.offset() as u32;
-                                                            let start_position = offset_to_position(
-                                                                rope,
-                                                                offset + section.source.start,
-                                                                source_text,
-                                                            );
-                                                            let end_position = offset_to_position(
-                                                                rope,
-                                                                offset
-                                                                    + section.source.start
-                                                                    + 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: message.error.message.clone(),
-                                                severity: message.error.severity,
-                                                help: message.error.help.clone(),
-                                                url: message.error.url.clone(),
-                                                code: message.error.code.clone(),
-                                                labels: labels.clone(),
-                                                fixes: match &message.fixes {
-                                                    PossibleFixes::None => {
-                                                        PossibleFixesWithPosition::None
-                                                    }
-                                                    PossibleFixes::Single(fix) => {
-                                                        PossibleFixesWithPosition::Single(
+                                Ok(module_record) => me.linter.run(
+                                    Path::new(&module.path),
+                                    Rc::new(section.semantic.unwrap()),
+                                    Arc::clone(&module_record),
+                                    allocator_guard,
+                                ),
+                            };
+                            // adjust offset for multiple source text in a single file
+                            if section.source.start != 0 {
+                                for message in &mut section_messages {
+                                    message.move_offset(section.source.start);
+                                }
+                            }
+
+                            messages.lock().unwrap().extend(section_messages.iter().map(
+                                |message| {
+                                    let message = message.clone_in(allocator);
+
+                                    let labels = &message.error.labels.clone().map(|labels| {
+                                        labels
+                                            .into_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: message.error.message.clone(),
+                                        severity: message.error.severity,
+                                        help: message.error.help.clone(),
+                                        url: message.error.url.clone(),
+                                        code: message.error.code.clone(),
+                                        labels: labels.clone(),
+                                        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,
-                                                                section.source.start,
                                                                 source_text,
-                                                            ),
-                                                        )
-                                                    }
-                                                    PossibleFixes::Multiple(fixes) => {
-                                                        PossibleFixesWithPosition::Multiple(
-                                                            fixes
-                                                                .iter()
-                                                                .map(|fix| {
-                                                                    fix_to_fix_with_position(
-                                                                        fix,
-                                                                        rope,
-                                                                        section.source.start,
-                                                                        source_text,
-                                                                    )
-                                                                })
-                                                                .collect(),
-                                                        )
-                                                    }
-                                                },
+                                                            )
+                                                        })
+                                                        .collect(),
+                                                )
                                             }
                                         },
-                                    ));
-                                }
-                            }
+                                    }
+                                },
+                            ));
                         }
                     },
                 );