diff --git a/crates/rome_analyze/src/context.rs b/crates/rome_analyze/src/context.rs
index 0537c28cf41..5a18cd4522a 100644
--- a/crates/rome_analyze/src/context.rs
+++ b/crates/rome_analyze/src/context.rs
@@ -2,7 +2,7 @@ use crate::options::OptionsDeserializationDiagnostic;
 use crate::{
     registry::RuleRoot, AnalyzerOptions, FromServices, Queryable, Rule, RuleKey, ServiceBag,
 };
-use rome_diagnostics::v2::{Error, Result};
+use rome_diagnostics::{Error, Result};
 use std::ops::Deref;
 
 type RuleQueryResult<R> = <<R as Rule>::Query as Queryable>::Output;
diff --git a/crates/rome_analyze/src/lib.rs b/crates/rome_analyze/src/lib.rs
index 981caa3d480..b4a0e349c35 100644
--- a/crates/rome_analyze/src/lib.rs
+++ b/crates/rome_analyze/src/lib.rs
@@ -19,7 +19,7 @@ mod syntax;
 mod visitor;
 
 // Re-exported for use in the `declare_group` macro
-pub use rome_diagnostics::v2::category_concat;
+pub use rome_diagnostics::category_concat;
 
 pub use crate::categories::{
     ActionCategory, RefactorKind, RuleCategories, RuleCategory, SourceActionKind,
@@ -41,10 +41,10 @@ pub use crate::signals::{AnalyzerAction, AnalyzerSignal};
 pub use crate::syntax::SyntaxVisitor;
 pub use crate::visitor::{NodeVisitor, Visitor, VisitorContext, VisitorFinishContext};
 use rome_console::{markup, MarkupBuf};
-use rome_diagnostics::file::FileId;
-use rome_diagnostics::v2::advice::CodeSuggestionAdvice;
-use rome_diagnostics::v2::{
-    category, Advices, Category, Diagnostic, DiagnosticTags, Error, Location, Severity, Visit,
+use rome_diagnostics::advice::CodeSuggestionAdvice;
+use rome_diagnostics::{
+    category, Advices, Category, Diagnostic, DiagnosticTags, Error, FileId, Location, Severity,
+    Visit,
 };
 use rome_rowan::{
     AstNode, Direction, Language, SyntaxElement, SyntaxToken, TextRange, TextSize, TriviaPieceKind,
diff --git a/crates/rome_analyze/src/matcher.rs b/crates/rome_analyze/src/matcher.rs
index 475e8cae15c..1241732f63d 100644
--- a/crates/rome_analyze/src/matcher.rs
+++ b/crates/rome_analyze/src/matcher.rs
@@ -1,6 +1,6 @@
 use std::{cmp::Ordering, collections::BinaryHeap};
 
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_rowan::{Language, TextRange};
 
 use crate::{
@@ -153,8 +153,8 @@ where
 
 #[cfg(test)]
 mod tests {
-    use rome_diagnostics::v2::{Diagnostic, Error, Severity};
-    use rome_diagnostics::{file::FileId, v2::category};
+    use rome_diagnostics::{category, location::FileId};
+    use rome_diagnostics::{Diagnostic, Error, Severity};
     use rome_rowan::{
         raw_language::{RawLanguage, RawLanguageKind, RawLanguageRoot, RawSyntaxTreeBuilder},
         AstNode, TextRange, TextSize, TriviaPiece, TriviaPieceKind,
diff --git a/crates/rome_analyze/src/options.rs b/crates/rome_analyze/src/options.rs
index 543d4d0afe8..9dd3f791f24 100644
--- a/crates/rome_analyze/src/options.rs
+++ b/crates/rome_analyze/src/options.rs
@@ -1,5 +1,5 @@
 use crate::{RuleKey, TextRange, TextSize};
-use rome_diagnostics::v2::{Diagnostic, LineIndexBuf, Resource, SourceCode};
+use rome_diagnostics::{Diagnostic, LineIndexBuf, Resource, SourceCode};
 use serde::Deserialize;
 use serde_json::Error;
 use serde_json::Value;
diff --git a/crates/rome_analyze/src/registry.rs b/crates/rome_analyze/src/registry.rs
index 2145285ae77..713ebe672da 100644
--- a/crates/rome_analyze/src/registry.rs
+++ b/crates/rome_analyze/src/registry.rs
@@ -1,6 +1,6 @@
 use std::{borrow, collections::BTreeSet};
 
-use rome_diagnostics::v2::Error;
+use rome_diagnostics::Error;
 use rome_rowan::{AstNode, Language, RawSyntaxKind, SyntaxKind, SyntaxNode};
 use rustc_hash::FxHashSet;
 
diff --git a/crates/rome_analyze/src/rule.rs b/crates/rome_analyze/src/rule.rs
index 83b0ca63d1a..4a7168ff4d1 100644
--- a/crates/rome_analyze/src/rule.rs
+++ b/crates/rome_analyze/src/rule.rs
@@ -4,14 +4,14 @@ use crate::registry::{RegistryVisitor, RuleLanguage, RuleSuppressions};
 use crate::{AnalyzerDiagnostic, Phase, Phases, Queryable};
 use rome_console::fmt::Display;
 use rome_console::{markup, MarkupBuf};
-use rome_diagnostics::file::FileId;
-use rome_diagnostics::v2::advice::CodeSuggestionAdvice;
-use rome_diagnostics::v2::location::AsSpan;
-use rome_diagnostics::v2::{
+use rome_diagnostics::advice::CodeSuggestionAdvice;
+use rome_diagnostics::location::AsSpan;
+use rome_diagnostics::location::FileId;
+use rome_diagnostics::Applicability;
+use rome_diagnostics::{
     Advices, Category, Diagnostic, DiagnosticTags, Location, LogCategory, MessageAndDescription,
     Visit,
 };
-use rome_diagnostics::Applicability;
 use rome_rowan::{BatchMutation, Language, TextRange};
 use serde::de::DeserializeOwned;
 
diff --git a/crates/rome_analyze/src/services.rs b/crates/rome_analyze/src/services.rs
index 7ac0ba87b32..19e075005ff 100644
--- a/crates/rome_analyze/src/services.rs
+++ b/crates/rome_analyze/src/services.rs
@@ -1,5 +1,5 @@
 use crate::{RuleKey, TextRange};
-use rome_diagnostics::v2::{Diagnostic, LineIndexBuf, Resource, Result, SourceCode};
+use rome_diagnostics::{Diagnostic, LineIndexBuf, Resource, Result, SourceCode};
 use std::{
     any::{Any, TypeId},
     collections::HashMap,
diff --git a/crates/rome_analyze/src/signals.rs b/crates/rome_analyze/src/signals.rs
index 3c118029daf..a4fce7da4c5 100644
--- a/crates/rome_analyze/src/signals.rs
+++ b/crates/rome_analyze/src/signals.rs
@@ -6,9 +6,8 @@ use crate::{
     AnalyzerDiagnostic, AnalyzerOptions, Queryable, RuleGroup, ServiceBag,
 };
 use rome_console::MarkupBuf;
-use rome_diagnostics::file::FileSpan;
-use rome_diagnostics::v2::advice::CodeSuggestionAdvice;
-use rome_diagnostics::{file::FileId, Applicability, CodeSuggestion};
+use rome_diagnostics::advice::CodeSuggestionAdvice;
+use rome_diagnostics::{location::FileId, Applicability, CodeSuggestion, FileSpan};
 use rome_rowan::{BatchMutation, Language};
 
 /// Event raised by the analyzer when a [Rule](crate::Rule)
diff --git a/crates/rome_analyze/src/syntax.rs b/crates/rome_analyze/src/syntax.rs
index 6528e1968d2..be92f46bc62 100644
--- a/crates/rome_analyze/src/syntax.rs
+++ b/crates/rome_analyze/src/syntax.rs
@@ -49,7 +49,7 @@ impl<L: Language> Visitor for SyntaxVisitor<L> {
 #[cfg(test)]
 mod tests {
 
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_rowan::{
         raw_language::{RawLanguage, RawLanguageKind, RawLanguageRoot, RawSyntaxTreeBuilder},
         AstNode,
diff --git a/crates/rome_analyze/src/visitor.rs b/crates/rome_analyze/src/visitor.rs
index e4ac8927f1c..dbdaa3c67ab 100644
--- a/crates/rome_analyze/src/visitor.rs
+++ b/crates/rome_analyze/src/visitor.rs
@@ -1,6 +1,6 @@
 use std::collections::BinaryHeap;
 
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_rowan::{AstNode, Language, SyntaxNode, TextRange, WalkEvent};
 
 use crate::{
diff --git a/crates/rome_cli/src/execute.rs b/crates/rome_cli/src/execute.rs
index 7937557dfcf..828b9cc119b 100644
--- a/crates/rome_cli/src/execute.rs
+++ b/crates/rome_cli/src/execute.rs
@@ -1,7 +1,7 @@
 use crate::traversal::traverse;
 use crate::{CliSession, Termination};
 use rome_console::{markup, ConsoleExt};
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_diagnostics::MAXIMUM_DISPLAYABLE_DIAGNOSTICS;
 use rome_fs::RomePath;
 use rome_service::workspace::{
diff --git a/crates/rome_cli/src/main.rs b/crates/rome_cli/src/main.rs
index 53e5bcbe815..fead72a1361 100644
--- a/crates/rome_cli/src/main.rs
+++ b/crates/rome_cli/src/main.rs
@@ -5,7 +5,7 @@
 //! [website]: https://rome.tools
 
 use rome_cli::{open_transport, setup_panic_handler, Arguments, CliSession, Termination};
-use rome_diagnostics::v2::set_bottom_frame;
+use rome_diagnostics::set_bottom_frame;
 use rome_service::workspace;
 use tokio::runtime::Runtime;
 
diff --git a/crates/rome_cli/src/reports/mod.rs b/crates/rome_cli/src/reports/mod.rs
index 42654459fd3..cfa97b90aee 100644
--- a/crates/rome_cli/src/reports/mod.rs
+++ b/crates/rome_cli/src/reports/mod.rs
@@ -2,7 +2,7 @@ pub mod formatter;
 
 use crate::reports::formatter::{FormatterReportFileDetail, FormatterReportSummary};
 use formatter::FormatterReport;
-use rome_diagnostics::v2::{Category, Severity};
+use rome_diagnostics::{Category, Severity};
 use rome_service::RomeError;
 use serde::Serialize;
 use std::collections::HashMap;
diff --git a/crates/rome_cli/src/traversal.rs b/crates/rome_cli/src/traversal.rs
index fd6fcb5ef90..74806957221 100644
--- a/crates/rome_cli/src/traversal.rs
+++ b/crates/rome_cli/src/traversal.rs
@@ -8,13 +8,11 @@ use crossbeam::{
 };
 use rome_console::{fmt, markup, Console, ConsoleExt};
 use rome_diagnostics::{
-    file::FileId,
-    v2::{
-        self,
-        adapters::{IoError, StdError},
-        category, Advices, Category, DiagnosticExt, Error, FilePath, PrintDescription,
-        PrintDiagnostic, Severity, Visit,
-    },
+    adapters::{IoError, StdError},
+    category,
+    location::FileId,
+    Advices, Category, Diagnostic, DiagnosticExt, Error, FilePath, PrintDescription,
+    PrintDiagnostic, Resource, Severity, Visit,
 };
 use rome_fs::{FileSystem, OpenOptions, PathInterner, RomePath};
 use rome_fs::{TraversalContext, TraversalScope};
@@ -266,7 +264,7 @@ struct ProcessMessagesOptions<'ctx> {
     report: &'ctx mut Report,
 }
 
-#[derive(Debug, v2::Diagnostic)]
+#[derive(Debug, Diagnostic)]
 #[diagnostic(
     category = "format",
     message = "File content differs from formatting output"
@@ -278,7 +276,7 @@ struct CIDiffDiagnostic<'a> {
     diff: FormatDiffAdvice<'a>,
 }
 
-#[derive(Debug, v2::Diagnostic)]
+#[derive(Debug, Diagnostic)]
 #[diagnostic(
     severity = Information,
     category = "format",
@@ -304,12 +302,12 @@ impl Advices for FormatDiffAdvice<'_> {
     }
 }
 
-#[derive(Debug, v2::Diagnostic)]
+#[derive(Debug, Diagnostic)]
 struct TraversalDiagnostic<'a> {
     #[location(resource)]
     file_name: Option<&'a str>,
     #[severity]
-    severity: v2::Severity,
+    severity: Severity,
     #[category]
     category: &'static Category,
     #[message]
@@ -371,7 +369,7 @@ fn process_messages(options: ProcessMessagesOptions) {
 
             Message::Error(mut err) => {
                 if let Some(location) = err.location() {
-                    if let v2::Resource::File(FilePath::FileId(file_id)) = location.resource {
+                    if let Resource::File(FilePath::FileId(file_id)) = location.resource {
                         // Retrieves the file name from the file ID cache, if it's a miss
                         // flush entries from the interner channel until it's found
                         let file_name = match paths.get(&file_id) {
@@ -423,7 +421,7 @@ fn process_messages(options: ProcessMessagesOptions) {
                         .location()
                         .and_then(|location| {
                             let path = match &location.resource {
-                                v2::Resource::File(file) => file,
+                                Resource::File(file) => file,
                                 _ => return None,
                             };
 
@@ -944,7 +942,7 @@ where
     }
 }
 
-#[derive(Debug, v2::Diagnostic)]
+#[derive(Debug, Diagnostic)]
 #[diagnostic(category = "internalError/panic", tags(INTERNAL))]
 struct PanicDiagnostic {
     #[description]
@@ -952,11 +950,11 @@ struct PanicDiagnostic {
     message: String,
 }
 
-#[derive(Debug, v2::Diagnostic)]
+#[derive(Debug, Diagnostic)]
 #[diagnostic(category = "files/missingHandler", message = "unhandled file type")]
 struct UnhandledDiagnostic;
 
-#[derive(Debug, v2::Diagnostic)]
+#[derive(Debug, Diagnostic)]
 #[diagnostic(category = "parse", message = "Skipped file with syntax errors")]
 struct SkippedDiagnostic;
 
diff --git a/crates/rome_diagnostics/examples/cli.rs b/crates/rome_diagnostics/examples/cli.rs
index 8544986f19f..18014358c88 100644
--- a/crates/rome_diagnostics/examples/cli.rs
+++ b/crates/rome_diagnostics/examples/cli.rs
@@ -1,7 +1,7 @@
 use std::io;
 
 use rome_console::{markup, ConsoleExt, EnvConsole};
-use rome_diagnostics::v2::{Advices, Diagnostic, LogCategory, PrintDiagnostic, Resource, Visit};
+use rome_diagnostics::{Advices, Diagnostic, LogCategory, PrintDiagnostic, Resource, Visit};
 use rome_rowan::{TextRange, TextSize};
 
 #[derive(Debug, Diagnostic)]
diff --git a/crates/rome_diagnostics/examples/fs.rs b/crates/rome_diagnostics/examples/fs.rs
index ca32be845d9..5ad3ec67fdf 100644
--- a/crates/rome_diagnostics/examples/fs.rs
+++ b/crates/rome_diagnostics/examples/fs.rs
@@ -1,7 +1,7 @@
 use std::io;
 
 use rome_console::{fmt, markup, ConsoleExt, EnvConsole};
-use rome_diagnostics::v2::{
+use rome_diagnostics::{
     Advices, Diagnostic, FilePath, Location, LogCategory, PrintDiagnostic, Resource, SourceCode,
     Visit,
 };
diff --git a/crates/rome_diagnostics/examples/lint.rs b/crates/rome_diagnostics/examples/lint.rs
index 16208a0da07..01d12d36a4d 100644
--- a/crates/rome_diagnostics/examples/lint.rs
+++ b/crates/rome_diagnostics/examples/lint.rs
@@ -1,7 +1,7 @@
 use std::io;
 
 use rome_console::{markup, ConsoleExt, EnvConsole};
-use rome_diagnostics::v2::{
+use rome_diagnostics::{
     Advices, Diagnostic, FilePath, Location, LogCategory, PrintDiagnostic, Resource, SourceCode,
     Visit,
 };
diff --git a/crates/rome_diagnostics/examples/serde.rs b/crates/rome_diagnostics/examples/serde.rs
index 6c1cbff4602..428bc17226c 100644
--- a/crates/rome_diagnostics/examples/serde.rs
+++ b/crates/rome_diagnostics/examples/serde.rs
@@ -1,7 +1,5 @@
 use rome_console::{markup, ConsoleExt, EnvConsole};
-use rome_diagnostics::v2::{
-    Diagnostic, LineIndexBuf, PrintDiagnostic, Resource, Result, SourceCode,
-};
+use rome_diagnostics::{Diagnostic, LineIndexBuf, PrintDiagnostic, Resource, Result, SourceCode};
 use rome_rowan::{TextRange, TextSize};
 use serde_json::Error;
 
diff --git a/crates/rome_diagnostics/src/v2/adapters.rs b/crates/rome_diagnostics/src/adapters.rs
similarity index 97%
rename from crates/rome_diagnostics/src/v2/adapters.rs
rename to crates/rome_diagnostics/src/adapters.rs
index 7d92c2b662b..7024ed54913 100644
--- a/crates/rome_diagnostics/src/v2/adapters.rs
+++ b/crates/rome_diagnostics/src/adapters.rs
@@ -6,7 +6,7 @@ use std::io;
 
 use rome_console::{fmt, markup};
 
-use super::{category, Category, Diagnostic};
+use crate::{category, Category, Diagnostic};
 
 /// Implements [Diagnostic] over types implementing [std::error::Error].
 #[derive(Debug)]
diff --git a/crates/rome_diagnostics/src/v2/advice.rs b/crates/rome_diagnostics/src/advice.rs
similarity index 99%
rename from crates/rome_diagnostics/src/v2/advice.rs
rename to crates/rome_diagnostics/src/advice.rs
index 2559627993e..4bd20e7ec0a 100644
--- a/crates/rome_diagnostics/src/v2/advice.rs
+++ b/crates/rome_diagnostics/src/advice.rs
@@ -1,9 +1,9 @@
-use super::{
+use crate::Applicability;
+use crate::{
     display::Backtrace,
     location::{AsResource, AsSourceCode, AsSpan},
     Location,
 };
-use crate::Applicability;
 use rome_console::fmt::{self, Display};
 use rome_console::markup;
 use rome_text_edit::TextEdit;
diff --git a/crates/rome_diagnostics/src/v2/context.rs b/crates/rome_diagnostics/src/context.rs
similarity index 99%
rename from crates/rome_diagnostics/src/v2/context.rs
rename to crates/rome_diagnostics/src/context.rs
index 761969d24fa..8fb32efef99 100644
--- a/crates/rome_diagnostics/src/v2/context.rs
+++ b/crates/rome_diagnostics/src/context.rs
@@ -1,6 +1,6 @@
 use rome_console::fmt;
 
-use super::{
+use crate::{
     diagnostic::internal::AsDiagnostic,
     location::{AsResource, AsSourceCode},
     Category, Error, Resource, SourceCode,
@@ -156,7 +156,7 @@ mod internal {
     use rome_console::{fmt, markup};
     use rome_text_edit::TextEdit;
 
-    use crate::v2::{
+    use crate::{
         diagnostic::internal::AsDiagnostic, Advices, Backtrace, Category, Diagnostic,
         DiagnosticTags, LineIndex, LineIndexBuf, Location, LogCategory, Resource, Severity,
         SourceCode, Visit,
diff --git a/crates/rome_diagnostics/src/diagnostic.rs b/crates/rome_diagnostics/src/diagnostic.rs
index 3401cb3b641..74b8807eb69 100644
--- a/crates/rome_diagnostics/src/diagnostic.rs
+++ b/crates/rome_diagnostics/src/diagnostic.rs
@@ -1,255 +1,186 @@
-use crate::{
-    file::{FileId, FileSpan, Span},
-    v2::Category,
-    Applicability, CodeSuggestion, DiagnosticTag,
-};
-use rome_console::fmt::Display;
-use rome_console::{markup, MarkupBuf};
-use rome_text_edit::TextEdit;
-use serde::{Deserialize, Serialize};
-
-/// A diagnostic message that can give information
-/// like errors or warnings.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub struct Diagnostic {
-    pub file_id: FileId,
-
-    pub severity: Severity,
-    pub code: Option<&'static Category>,
-    pub title: MarkupBuf,
-    pub summary: Option<String>,
-    pub tag: Option<DiagnosticTag>,
-
-    pub primary: Option<SubDiagnostic>,
-    pub children: Vec<SubDiagnostic>,
-    pub suggestions: Vec<CodeSuggestion>,
-    pub footers: Vec<Footer>,
-}
-
-impl Diagnostic {
-    /// Creates a new [`Diagnostic`] with the `Error` severity.
-    pub fn error(file_id: FileId, code: &'static Category, title: impl Display) -> Self {
-        Self::new_with_code(file_id, Severity::Error, title, Some(code))
-    }
-
-    /// Creates a new [`Diagnostic`] with the `Warning` severity.
-    pub fn warning(file_id: FileId, code: &'static Category, title: impl Display) -> Self {
-        Self::new_with_code(file_id, Severity::Warning, title, Some(code))
-    }
-
-    /// Creates a new [`Diagnostic`] with the `Help` severity.
-    pub fn help(file_id: FileId, code: &'static Category, title: impl Display) -> Self {
-        Self::new_with_code(file_id, Severity::Help, title, Some(code))
-    }
-
-    /// Creates a new [`Diagnostic`] with the `Note` severity.
-    pub fn note(file_id: FileId, code: &'static Category, title: impl Display) -> Self {
-        Self::new_with_code(file_id, Severity::Note, title, Some(code))
-    }
-
-    /// Creates a new [`Diagnostic`] with the `Bug` severity.
-    pub fn bug(file_id: FileId, code: &'static Category, title: impl Display) -> Self {
-        Self::new_with_code(file_id, Severity::Bug, title, Some(code))
-    }
+use std::{fmt::Debug, io};
 
-    /// Creates a new [`Diagnostic`] that will be used in a builder-like way
-    /// to modify labels, and suggestions.
-    pub fn new(file_id: FileId, severity: Severity, title: impl Display) -> Self {
-        Self::new_with_code(file_id, severity, title, None)
-    }
-
-    /// Creates a new [`Diagnostic`] with an error code that will be used in a builder-like way
-    /// to modify labels, and suggestions.
-    pub fn new_with_code(
-        file_id: FileId,
-        severity: Severity,
-        title: impl Display,
-        code: Option<&'static Category>,
-    ) -> Self {
-        Self {
-            file_id,
-            code,
-            severity,
-            title: markup!({ title }).to_owned(),
-            summary: None,
-            primary: None,
-            tag: None,
-            children: vec![],
-            suggestions: vec![],
-            footers: vec![],
-        }
-    }
+use bitflags::bitflags;
+use serde::{Deserialize, Serialize};
 
-    /// Overwrites the severity of this diagnostic.
-    pub fn severity(mut self, severity: Severity) -> Self {
-        self.severity = severity;
-        self
-    }
+use rome_console::fmt;
 
-    /// Set an explicit plain-text summary for this diagnostic.
-    pub fn summary(mut self, summary: impl Into<String>) -> Self {
-        self.summary = Some(summary.into());
-        self
-    }
+use crate::{Category, Location, Visit};
 
-    /// Marks this diagnostic as deprecated code, which will
-    /// be displayed in the language server.
+/// The `Diagnostic` trait defines the metadata that can be exposed by error
+/// types in order to print details diagnostics in the console of the editor
+///
+/// ## Implementation
+///
+/// Most types should not have to implement this trait manually, and should
+/// instead rely on the `Diagnostic` derive macro also provided by this crate:
+///
+/// ```
+/// # use rome_diagnostics::Diagnostic;
+/// #[derive(Debug, Diagnostic)]
+/// #[diagnostic(category = "lint/style/noShoutyConstants", tags(FIXABLE))]
+/// struct ExampleDiagnostic {
+///     #[message]
+///     #[description]
+///     message: String,
+/// }
+/// ```
+pub trait Diagnostic: Debug {
+    /// The category of a diagnostic uniquely identifying this
+    /// diagnostic type, such as `lint/correctness/noArguments`, `args/invalid`
+    /// or `format/disabled`.
+    fn category(&self) -> Option<&'static Category> {
+        None
+    }
+
+    /// The severity defines whether this diagnostic reports an error, a
+    /// warning, an information or a hint to the user.
+    fn severity(&self) -> Severity {
+        Severity::Error
+    }
+
+    /// The description is a text-only explanation of the issue this diagnostic
+    /// is reporting, intended for display contexts that do not support rich
+    /// markup such as in-editor popovers
     ///
-    /// This does not have any influence on the diagnostic rendering.
-    pub fn deprecated(mut self) -> Self {
-        self.tag = if matches!(self.tag, Some(DiagnosticTag::Unnecessary)) {
-            Some(DiagnosticTag::Both)
-        } else {
-            Some(DiagnosticTag::Deprecated)
-        };
-        self
+    /// The description should generally be as exhaustive as possible, since
+    /// the clients that do not support rendering markup will not render the
+    /// advices for the diagnostic either.
+    fn description(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let _ = fmt;
+        Ok(())
     }
 
-    /// Marks this diagnostic as unnecessary code, which will
-    /// be displayed in the language server.
+    /// An explanation of the issue this diagnostic is reporting
     ///
-    /// This does not have any influence on the diagnostic rendering.
-    pub fn unnecessary(mut self) -> Self {
-        self.tag = if matches!(self.tag, Some(DiagnosticTag::Deprecated)) {
-            Some(DiagnosticTag::Both)
-        } else {
-            Some(DiagnosticTag::Unnecessary)
-        };
-        self
-    }
-
-    /// Attaches a label to this [`Diagnostic`], that will point to another file
-    /// that is provided.
-    pub fn label_in_file(mut self, severity: Severity, span: FileSpan, msg: impl Display) -> Self {
-        self.children.push(SubDiagnostic {
-            severity,
-            msg: markup!({ msg }).to_owned(),
-            span,
-        });
-        self
+    /// In general it's better to keep this message as short as possible, and
+    /// instead rely on advices to better convey contextual explanations to the
+    /// user.
+    fn message(&self, fmt: &mut fmt::Formatter<'_>) -> io::Result<()> {
+        let _ = fmt;
+        Ok(())
+    }
+
+    /// Advices are the main building blocks used compose rich errors. They are
+    /// implemented using a visitor pattern, where consumers of a diagnostic
+    /// can visit the object and collect the advices that make it up for the
+    /// purpose of display or introspection.
+    fn advices(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        let _ = visitor;
+        Ok(())
+    }
+
+    /// Diagnostics can defines additional advices to be printed if the user
+    /// requires more detail about the diagnostic.
+    fn verbose_advices(&self, visitor: &mut dyn Visit) -> io::Result<()> {
+        let _ = visitor;
+        Ok(())
+    }
+
+    /// A diagnostic can be tied to a specific "location": this can be a file,
+    /// memory buffer, command line argument, etc. It may also be tied to a
+    /// specific text range within the content of that location. Finally, it
+    /// may also provide the source string for that location (this is required
+    /// in order to display a code frame advice for the diagnostic).
+    fn location(&self) -> Option<Location<'_>> {
+        None
+    }
+
+    /// Tags convey additional boolean metadata about the nature of a diagnostic:
+    /// - If the diagnostic can be automatically fixed
+    /// - If the diagnostic resulted from and internal error
+    /// - If the diagnostic is being emitted as part of a crash / fatal error
+    /// - If the diagnostic is a warning about a piece of unused or unnecessary code
+    /// - If the diagnostic is a warning about a piece of deprecated or obsolete code.
+    fn tags(&self) -> DiagnosticTags {
+        DiagnosticTags::empty()
+    }
+
+    /// Similarly to the `source` method of the [std::error::Error] trait, this
+    /// returns another diagnostic that's the logical "cause" for this issue.
+    /// For instance, a "request failed" diagnostic may have been cause by a
+    /// "deserialization error". This allows low-level error to be wrapped in
+    /// higher level concepts, while retaining enough information to display
+    /// and fix the underlying issue.
+    fn source(&self) -> Option<&dyn Diagnostic> {
+        None
     }
+}
 
-    /// Attaches a label to this [`Diagnostic`].
-    ///
-    /// The given span has to be in the file that was provided while creating this [`Diagnostic`].
-    pub fn label(mut self, severity: Severity, span: impl Span, msg: impl Display) -> Self {
-        self.children.push(SubDiagnostic {
-            severity,
-            msg: markup!({ msg }).to_owned(),
-            span: FileSpan::new(self.file_id, span),
-        });
-        self
-    }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+/// The severity to associate to a diagnostic.
+pub enum Severity {
+    /// Reports a crash.
+    Fatal,
+    /// Reports an error.
+    Error,
+    /// Reports a warning.
+    Warning,
+    /// Reports an information.
+    Information,
+    /// Reports a hint.
+    Hint,
+}
 
-    /// Attaches a primary label to this [`Diagnostic`].
-    pub fn primary(mut self, span: impl Span, msg: impl Display) -> Self {
-        self.primary = Some(SubDiagnostic {
-            severity: self.severity,
-            msg: markup!({ msg }).to_owned(),
-            span: FileSpan::new(self.file_id, span),
-        });
-        self
-    }
+/// Internal enum used to automatically generate bit offsets for [DiagnosticTags]
+/// and help with the implementation of `serde` and `schemars` for tags.
+#[derive(Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub(super) enum DiagnosticTag {
+    Fixable,
+    Internal,
+    UnnecessaryCode,
+    DeprecatedCode,
+}
 
-    /// Attaches a secondary label to this [`Diagnostic`].
-    pub fn secondary(self, span: impl Span, msg: impl Display) -> Self {
-        self.label(Severity::Note, span, msg)
+bitflags! {
+    pub struct DiagnosticTags: u8 {
+        /// This diagnostic has a fix suggestion.
+        const FIXABLE = 1 << DiagnosticTag::Fixable as u8;
+        /// This diagnostic results from an internal error.
+        const INTERNAL = 1 << DiagnosticTag::Internal as u8;
+        /// This diagnostic tags unused or unnecessary code, this may change
+        /// how the diagnostic is render in editors.
+        const UNNECESSARY_CODE = 1 << DiagnosticTag::UnnecessaryCode as u8;
+        /// This diagnostic tags deprecated or obsolete code, this may change
+        /// how the diagnostic is render in editors.
+        const DEPRECATED_CODE = 1 << DiagnosticTag::DeprecatedCode as u8;
     }
+}
 
-    /// Add a suggestion to this `Diagnostic`
-    pub fn suggestion_full(
-        mut self,
-        span: impl Span,
-        msg: impl Display,
-        suggestion: TextEdit,
-        applicability: Applicability,
-    ) -> Self {
-        let file = self.file_id;
-        let span = FileSpan {
-            file,
-            range: span.as_range(),
-        };
-        let suggestion = CodeSuggestion {
-            applicability,
-            msg: markup!({ msg }).to_owned(),
-            labels: vec![],
-            span,
-            suggestion,
-        };
-        self.suggestions.push(suggestion);
-        self
-    }
+pub(crate) mod internal {
+    //! The `AsDiagnostic` trait needs to be declared as public as its referred
+    //! to in the `where` clause of other public items, but as it's not part of
+    //! the public API it's declared in a private module so it's not accessible
+    //! outside of the crate
 
-    /// Adds a footer to this `Diagnostic`, which will be displayed under the actual error.
-    pub fn footer(mut self, severity: Severity, msg: impl Display) -> Self {
-        self.footers.push(Footer {
-            msg: markup!({ msg }).to_owned(),
-            severity,
-        });
-        self
-    }
+    use std::fmt::Debug;
 
-    /// Adds a footer to this `Diagnostic`, with the `Help` severity.
-    pub fn footer_help(self, msg: impl Display) -> Self {
-        self.footer(Severity::Help, msg)
-    }
+    use crate::Diagnostic;
 
-    /// Adds a footer to this `Diagnostic`, with the `Note` severity.
-    pub fn footer_note(self, msg: impl Display) -> Self {
-        self.footer(Severity::Note, msg)
+    /// Since [Error](crate::Error) must implement `From<T: Diagnostic>` to
+    /// be used with the `?` operator, it cannot implement the [Diagnostic]
+    /// trait (as that would conflict with the implementation of `From<T> for T`
+    /// in the standard library). The [AsDiagnostic] exists as an internal
+    /// implementation detail to bridge this gap and allow various types and
+    /// functions in `rome_diagnostics` to be generic over all diagnostics +
+    /// `Error`.
+    pub trait AsDiagnostic: Debug {
+        type Diagnostic: Diagnostic + ?Sized;
+        fn as_diagnostic(&self) -> &Self::Diagnostic;
+        fn as_dyn(&self) -> &dyn Diagnostic;
     }
 
-    /// Checks if the severity of the current diagnostic is [Severity::Error] or higher
-    pub fn is_error(&self) -> bool {
-        self.severity >= Severity::Error
-    }
-}
+    impl<D: Diagnostic> AsDiagnostic for D {
+        type Diagnostic = D;
 
-/// A severity level for diagnostic messages.
-///
-/// These are ordered in the following way:
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub enum Severity {
-    /// A help message.
-    Help,
-    /// A note.
-    Note,
-    /// A warning.
-    Warning,
-    /// An error.
-    Error,
-    /// An unexpected bug.
-    Bug,
-}
+        fn as_diagnostic(&self) -> &Self::Diagnostic {
+            self
+        }
 
-impl From<Severity> for &'static str {
-    fn from(level: Severity) -> Self {
-        match level {
-            Severity::Bug => "bug",
-            Severity::Error => "error",
-            Severity::Warning => "warning",
-            Severity::Help => "help",
-            Severity::Note => "note",
+        fn as_dyn(&self) -> &dyn Diagnostic {
+            self
         }
     }
 }
-
-/// Everything that can be added to a diagnostic, like
-/// a suggestion that will be displayed under the actual error.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub struct SubDiagnostic {
-    pub severity: Severity,
-    pub msg: MarkupBuf,
-    pub span: FileSpan,
-}
-
-/// A note or help that is displayed under the diagnostic.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub struct Footer {
-    pub msg: MarkupBuf,
-    pub severity: Severity,
-}
diff --git a/crates/rome_diagnostics/src/v2/display.rs b/crates/rome_diagnostics/src/display.rs
similarity index 99%
rename from crates/rome_diagnostics/src/v2/display.rs
rename to crates/rome_diagnostics/src/display.rs
index 11c29b67ab9..2e26d9b8f53 100644
--- a/crates/rome_diagnostics/src/v2/display.rs
+++ b/crates/rome_diagnostics/src/display.rs
@@ -9,9 +9,8 @@ mod diff;
 mod frame;
 mod message;
 
-use crate::v2::display::frame::SourceFile;
-
-use super::{
+use crate::display::frame::SourceFile;
+use crate::{
     diagnostic::internal::AsDiagnostic, Advices, Diagnostic, DiagnosticTags, Location, LogCategory,
     Resource, Severity, Visit,
 };
@@ -546,17 +545,17 @@ mod tests {
     use std::io;
 
     use rome_console::{fmt, markup};
-    use rome_diagnostics::v2::{DiagnosticTags, Severity};
+    use rome_diagnostics::{DiagnosticTags, Severity};
     use rome_diagnostics_categories::{category, Category};
     use rome_text_edit::TextEdit;
     use rome_text_size::{TextRange, TextSize};
     use serde_json::{from_value, json};
 
-    use crate::v2::{
+    use crate::{self as rome_diagnostics};
+    use crate::{
         Advices, Diagnostic, FilePath, Location, LogCategory, PrintDiagnostic, Resource,
         SourceCode, Visit,
     };
-    use crate::{self as rome_diagnostics};
 
     #[derive(Debug)]
     struct TestDiagnostic<A> {
diff --git a/crates/rome_diagnostics/src/v2/display/backtrace.rs b/crates/rome_diagnostics/src/display/backtrace.rs
similarity index 99%
rename from crates/rome_diagnostics/src/v2/display/backtrace.rs
rename to crates/rome_diagnostics/src/display/backtrace.rs
index 9ba928d69d2..3abe1f04b3a 100644
--- a/crates/rome_diagnostics/src/v2/display/backtrace.rs
+++ b/crates/rome_diagnostics/src/display/backtrace.rs
@@ -208,7 +208,7 @@ thread_local! {
 ///
 /// On the main thread:
 /// ```
-/// # use rome_diagnostics::v2::set_bottom_frame;
+/// # use rome_diagnostics::set_bottom_frame;
 /// # #[allow(clippy::needless_doctest_main)]
 /// pub fn main() {
 ///     set_bottom_frame(main as usize);
@@ -219,7 +219,7 @@ thread_local! {
 ///
 /// On worker threads:
 /// ```
-/// # use rome_diagnostics::v2::set_bottom_frame;
+/// # use rome_diagnostics::set_bottom_frame;
 /// fn worker_thread() {
 ///     set_bottom_frame(worker_thread as usize);
 ///
diff --git a/crates/rome_diagnostics/src/v2/display/diff.rs b/crates/rome_diagnostics/src/display/diff.rs
similarity index 100%
rename from crates/rome_diagnostics/src/v2/display/diff.rs
rename to crates/rome_diagnostics/src/display/diff.rs
diff --git a/crates/rome_diagnostics/src/v2/display/frame.rs b/crates/rome_diagnostics/src/display/frame.rs
similarity index 99%
rename from crates/rome_diagnostics/src/v2/display/frame.rs
rename to crates/rome_diagnostics/src/display/frame.rs
index 789e6e3d0db..9645a04da2d 100644
--- a/crates/rome_diagnostics/src/v2/display/frame.rs
+++ b/crates/rome_diagnostics/src/display/frame.rs
@@ -10,7 +10,7 @@ use rome_console::{fmt, markup};
 use rome_text_size::{TextLen, TextRange, TextSize};
 use unicode_width::UnicodeWidthChar;
 
-use crate::v2::{
+use crate::{
     location::{BorrowedSourceCode, LineIndex},
     LineIndexBuf, Location,
 };
diff --git a/crates/rome_diagnostics/src/v2/display/message.rs b/crates/rome_diagnostics/src/display/message.rs
similarity index 97%
rename from crates/rome_diagnostics/src/v2/display/message.rs
rename to crates/rome_diagnostics/src/display/message.rs
index 315c21a59c8..c8b66fec62f 100644
--- a/crates/rome_diagnostics/src/v2/display/message.rs
+++ b/crates/rome_diagnostics/src/display/message.rs
@@ -8,7 +8,7 @@ use termcolor::NoColor;
 /// ## Examples
 ///
 /// ```
-/// use rome_diagnostics::v2::{Diagnostic, MessageAndDescription};
+/// use rome_diagnostics::{Diagnostic, MessageAndDescription};
 ///
 /// #[derive(Debug, Diagnostic)]
 /// struct TestDiagnostic {
diff --git a/crates/rome_diagnostics/src/emit.rs b/crates/rome_diagnostics/src/emit.rs
deleted file mode 100644
index ac4c620d3cf..00000000000
--- a/crates/rome_diagnostics/src/emit.rs
+++ /dev/null
@@ -1,335 +0,0 @@
-//! Implementation of converting, and emitting diagnostics
-//! into the console
-
-use crate::file::FileSpan;
-use crate::v2::advice::{LogCategory, Visit};
-use crate::v2::{
-    self, advice, Category, DiagnosticTags, FilePath, Location, PrintDiagnostic, Resource,
-};
-use crate::{file::Files, Diagnostic};
-use crate::{Applicability, Severity, SubDiagnostic};
-use rome_console::{
-    fmt::{Display, Formatter, Termcolor},
-    markup,
-};
-use std::fmt::Debug;
-use std::io;
-use termcolor::{ColorChoice, NoColor, StandardStream, WriteColor};
-
-/// The emitter is responsible for emitting
-/// diagnostics to a given output.
-pub struct Emitter<'files> {
-    files: &'files dyn Files,
-}
-
-impl<'files> Emitter<'files> {
-    /// Creates a new `Emitter`.
-    pub fn new(files: &'files dyn Files) -> Self {
-        Self { files }
-    }
-}
-
-impl Emitter<'_> {
-    /// Render and emit the diagnostic to stderr
-    ///
-    /// This method will lock stderr for the entire time it takes to emit the diagnostic.
-    pub fn emit_stderr(&mut self, d: &Diagnostic, color: bool) -> io::Result<()> {
-        let out = StandardStream::stderr(if color {
-            ColorChoice::Always
-        } else {
-            ColorChoice::Never
-        });
-        let mut out = out.lock();
-        self.emit_with_writer(d, &mut out)
-    }
-
-    pub fn emit_with_writer(
-        &mut self,
-        d: &Diagnostic,
-        writer: &mut dyn WriteColor,
-    ) -> io::Result<()> {
-        Formatter::new(&mut Termcolor(writer)).write_markup(markup! {
-            {d.display(self.files)}
-        })
-    }
-}
-
-impl Diagnostic {
-    pub fn as_diagnostic<'a>(&'a self, files: &'a dyn Files) -> impl v2::Diagnostic + 'a {
-        DiagnosticPrinter {
-            files,
-            d: self,
-            include_source: false,
-        }
-    }
-
-    pub fn display<'a>(&'a self, files: &'a dyn Files) -> impl Display + 'a {
-        DiagnosticPrinter {
-            files,
-            d: self,
-            include_source: true,
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-struct DiagnosticPrinter<'a> {
-    files: &'a dyn Files,
-    d: &'a Diagnostic,
-    include_source: bool,
-}
-
-impl DiagnosticPrinter<'_> {
-    fn lookup_location(&self, span: FileSpan) -> Option<Location<'_>> {
-        let path = self.files.name(span.file)?;
-
-        Some(Location {
-            resource: Resource::File(FilePath::PathAndId {
-                path,
-                file_id: span.file,
-            }),
-            span: Some(span.range),
-            source_code: if self.include_source {
-                self.files.source(span.file)
-            } else {
-                None
-            },
-        })
-    }
-
-    fn record_label(&self, visitor: &mut dyn Visit, label: &SubDiagnostic) -> io::Result<()> {
-        if !label.msg.is_empty() {
-            visitor.record_log(map_severity_to_log_category(label.severity), &label.msg)?;
-        }
-
-        if let Some(location) = self.lookup_location(label.span) {
-            visitor.record_frame(location)?;
-        }
-
-        Ok(())
-    }
-}
-
-fn map_severity_to_log_category(severity: Severity) -> LogCategory {
-    match severity {
-        Severity::Help => LogCategory::Info,
-        Severity::Note => LogCategory::Info,
-        Severity::Warning => LogCategory::Warn,
-        Severity::Error => LogCategory::Error,
-        Severity::Bug => LogCategory::Error,
-    }
-}
-
-impl Debug for DiagnosticPrinter<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("DiagnosticPrinter")
-            .field("d", &self.d)
-            .finish()
-    }
-}
-
-impl<'a> Display for DiagnosticPrinter<'a> {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> io::Result<()> {
-        PrintDiagnostic(self).fmt(fmt)?;
-        Ok(())
-    }
-}
-
-impl v2::Diagnostic for DiagnosticPrinter<'_> {
-    fn category(&self) -> Option<&'static Category> {
-        self.d.code
-    }
-
-    fn severity(&self) -> v2::Severity {
-        match self.d.severity {
-            Severity::Help => v2::Severity::Hint,
-            Severity::Note => v2::Severity::Information,
-            Severity::Warning => v2::Severity::Warning,
-            Severity::Error | Severity::Bug => v2::Severity::Error,
-        }
-    }
-
-    fn description(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if let Some(summary) = &self.d.summary {
-            fmt.write_str(summary)
-        } else {
-            let mut message = Termcolor(NoColor::new(Vec::new()));
-            Display::fmt(&self.d.title, &mut Formatter::new(&mut message))
-                .map_err(|_| std::fmt::Error)?;
-
-            let message = message.0.into_inner();
-            let message: String = String::from_utf8(message).map_err(|_| std::fmt::Error)?;
-            fmt.write_str(&message)
-        }
-    }
-
-    fn message(&self, fmt: &mut Formatter<'_>) -> io::Result<()> {
-        fmt.write_markup(markup! {
-            {self.d.title}
-        })
-    }
-
-    fn advices(&self, visitor: &mut dyn advice::Visit) -> io::Result<()> {
-        if let Some(label) = &self.d.primary {
-            self.record_label(visitor, label)?;
-        }
-
-        for label in &self.d.children {
-            self.record_label(visitor, label)?;
-        }
-
-        for footer in &self.d.footers {
-            visitor.record_log(map_severity_to_log_category(footer.severity), &footer.msg)?;
-        }
-
-        for suggestion in &self.d.suggestions {
-            let applicability = match suggestion.applicability {
-                Applicability::Always => "Safe fix",
-                Applicability::MaybeIncorrect => "Suggested fix",
-            };
-
-            visitor.record_log(
-                LogCategory::Info,
-                &markup! {
-                    {applicability}": "{suggestion.msg}
-                },
-            )?;
-
-            visitor.record_diff(&suggestion.suggestion)?;
-        }
-
-        Ok(())
-    }
-
-    fn location(&self) -> Option<Location<'_>> {
-        let path = self.files.name(self.d.file_id)?;
-
-        Some(Location {
-            resource: Resource::File(FilePath::PathAndId {
-                path,
-                file_id: self.d.file_id,
-            }),
-            span: self.d.primary.as_ref().map(|label| label.span.range),
-            source_code: if self.include_source {
-                self.files.source(self.d.file_id)
-            } else {
-                None
-            },
-        })
-    }
-
-    fn tags(&self) -> DiagnosticTags {
-        let mut tags = DiagnosticTags::empty();
-
-        if !self.d.suggestions.is_empty() {
-            tags |= DiagnosticTags::FIXABLE;
-        }
-
-        if self.d.severity == Severity::Bug {
-            tags |= DiagnosticTags::INTERNAL;
-        }
-
-        if self.d.tag.map_or(false, |tag| tag.is_deprecated()) {
-            tags |= DiagnosticTags::DEPRECATED_CODE;
-        }
-
-        if self.d.tag.map_or(false, |tag| tag.is_unnecessary()) {
-            tags |= DiagnosticTags::UNNECESSARY_CODE;
-        }
-
-        tags
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rome_console::{markup, BufferConsole, ConsoleExt};
-    use rome_text_edit::TextEdit;
-    use rome_text_size::{TextRange, TextSize};
-
-    use crate::{
-        file::SimpleFile,
-        v2::{category, FileId},
-        Applicability, Diagnostic, Severity,
-    };
-
-    #[test]
-    fn test_error_diagnostic() {
-        const SOURCE: &str = "Lorem ipsum dolor sit amet,
-consectetur adipiscing elit,
-sed do eiusmod tempor incididunt ut
-labore et dolore magna aliqua";
-
-        let expected = markup! {
-            "file_name "<Hyperlink href="https://docs.rome.tools/lint/rules/noArguments">"lint/correctness/noArguments"</Hyperlink>" "<Inverse>" FIXABLE "</Inverse>" ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
-            "\n"
-            <Emphasis><Error>"  ✖"</Error></Emphasis>" "<Error>"message"</Error>"\n"
-            "  \n"
-            <Emphasis><Error>"  ✖"</Error></Emphasis>" "<Error>"label"</Error>"\n"
-            "  \n"
-            "    "<Emphasis>"1 │ "</Emphasis>"Lorem ipsum dolor sit amet,\n"
-            <Emphasis><Error>"  >"</Error></Emphasis>" "<Emphasis>"2 │ "</Emphasis>"consectetur adipiscing elit,\n"
-            "   "<Emphasis>"   │ "</Emphasis>"            "<Emphasis><Error>"^^^^^^^^^^^^^^^"</Error></Emphasis>"\n"
-            "    "<Emphasis>"3 │ "</Emphasis>"sed do eiusmod tempor incididunt ut\n"
-            "    "<Emphasis>"4 │ "</Emphasis>"labore et dolore magna aliqua\n"
-            "  \n"
-            <Emphasis><Info>"  ℹ"</Info></Emphasis>" "<Info>"footer note"</Info>"\n"
-            "  \n"
-            <Emphasis><Info>"  ℹ"</Info></Emphasis>" "<Info>"footer help"</Info>"\n"
-            "  \n"
-            <Emphasis><Info>"  ℹ"</Info></Emphasis>" "<Info>"Safe fix: suggestion"</Info>"\n"
-            "  \n"
-            "    "<Emphasis>"1"</Emphasis>" "<Emphasis>"1 │ "</Emphasis>"  Lorem ipsum dolor sit amet,\n"
-            "    "<Emphasis>"2"</Emphasis>"  "<Emphasis>" │ "</Emphasis><Error>"-"</Error>" "<Error>"consectetur"</Error><Error><Dim>"·"</Dim></Error><Error><Emphasis>"adipiscing"</Emphasis></Error><Error><Dim>"·"</Dim></Error><Error><Emphasis>"elit"</Emphasis></Error><Error>","</Error>"\n"
-            "      "<Emphasis>"2 │ "</Emphasis><Success>"+"</Success>" "<Success>"consectetur"</Success><Success><Dim>"·"</Dim></Success><Success><Emphasis>"completely"</Emphasis></Success><Success><Dim>"·"</Dim></Success><Success><Emphasis>"different"</Emphasis></Success>"\n"
-            "      "<Emphasis>"3 │ "</Emphasis><Success>"+"</Success>" "<Success><Emphasis>"text"</Emphasis></Success><Success>","</Success>"\n"
-            "    "<Emphasis>"3"</Emphasis>" "<Emphasis>"4 │ "</Emphasis>"  sed do eiusmod tempor incididunt ut\n"
-            "    "<Emphasis>"4"</Emphasis>" "<Emphasis>"5 │ "</Emphasis>"  labore et dolore magna aliqua\n"
-            "  \n"
-        }.to_owned();
-
-        let files = SimpleFile::new(String::from("file_name"), SOURCE.into());
-
-        let mut fixed_code = SOURCE.to_string();
-        fixed_code.replace_range(40..55, "completely different\ntext");
-
-        let diag = Diagnostic::error(
-            FileId::zero(),
-            category!("lint/correctness/noArguments"),
-            "message",
-        )
-        .label(
-            Severity::Error,
-            TextRange::new(TextSize::from(40u32), TextSize::from(55u32)),
-            "label",
-        )
-        .suggestion_full(
-            TextRange::new(TextSize::from(40u32), TextSize::from(55u32)),
-            "suggestion",
-            TextEdit::from_unicode_words(SOURCE, &fixed_code),
-            Applicability::Always,
-        )
-        .footer_note("footer note")
-        .footer_help("footer help");
-
-        let mut console = BufferConsole::default();
-        console.log(markup! {
-            {diag.display(&files)}
-        });
-
-        let mut iter = console.out_buffer.into_iter();
-
-        let message = match iter.next() {
-            Some(msg) => msg,
-            other => panic!("unexpected message {other:?}"),
-        };
-
-        assert_eq!(
-            message.content, expected,
-            "\nactual:\n{:#?}\nexpected:\n{expected:#?}",
-            message.content
-        );
-
-        assert!(iter.next().is_none());
-    }
-}
diff --git a/crates/rome_diagnostics/src/v2/error.rs b/crates/rome_diagnostics/src/error.rs
similarity index 99%
rename from crates/rome_diagnostics/src/v2/error.rs
rename to crates/rome_diagnostics/src/error.rs
index fe63cb8cf89..f9b2eca2b88 100644
--- a/crates/rome_diagnostics/src/v2/error.rs
+++ b/crates/rome_diagnostics/src/error.rs
@@ -25,7 +25,7 @@ use std::{
 
 use rome_console::fmt;
 
-use super::{
+use crate::{
     diagnostic::internal::AsDiagnostic, Category, Diagnostic, DiagnosticTags, Location, Severity,
     Visit,
 };
@@ -234,7 +234,7 @@ mod tests {
         },
     };
 
-    use crate::v2::{Diagnostic, Error, Result};
+    use crate::{Diagnostic, Error, Result};
 
     #[derive(Debug)]
     struct TestDiagnostic(Arc<AtomicBool>);
diff --git a/crates/rome_diagnostics/src/file.rs b/crates/rome_diagnostics/src/file.rs
deleted file mode 100644
index f5f1ec6ccc3..00000000000
--- a/crates/rome_diagnostics/src/file.rs
+++ /dev/null
@@ -1,212 +0,0 @@
-use rome_rowan::{Language, SyntaxElement, SyntaxNode, SyntaxToken, TextRange, TextSize};
-use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, fmt::Debug, ops::Range};
-
-pub use crate::v2::FileId;
-use crate::v2::{LineIndex, LineIndexBuf, SourceCode};
-
-/// A value which can be used as the range inside of a diagnostic.
-///
-/// This is essentially a hack to allow us to use SyntaxElement, SyntaxNode, etc directly
-pub trait Span {
-    fn as_range(&self) -> TextRange;
-
-    /// Make a new span which extends to another span
-    ///
-    /// ```text
-    /// from      to
-    /// ^^^^^^^^^^^^
-    /// ```
-    fn join<T: Span>(&self, other: T) -> TextRange {
-        TextRange::new(self.as_range().start(), other.as_range().end())
-    }
-
-    /// Make a new span which is between another span
-    ///
-    /// ```text
-    /// from      to
-    ///     ^^^^^^
-    /// ```
-    fn between<T: Span>(&self, other: T) -> TextRange {
-        TextRange::new(self.as_range().end(), other.as_range().start())
-    }
-
-    /// Make a new span which extends until another span
-    ///
-    /// ```text
-    /// from      to
-    /// ^^^^^^^^^^
-    /// ```
-    fn until<T: Span>(&self, other: T) -> TextRange {
-        TextRange::new(self.as_range().start(), other.as_range().start())
-    }
-
-    fn sub_start(&self, amount: TextSize) -> TextRange {
-        self.as_range().sub_start(amount)
-    }
-
-    fn add_start(&self, amount: TextSize) -> TextRange {
-        self.as_range().add_start(amount)
-    }
-
-    fn sub_end(&self, amount: TextSize) -> TextRange {
-        self.as_range().sub_end(amount)
-    }
-
-    fn add_end(&self, amount: TextSize) -> TextRange {
-        self.as_range().add_end(amount)
-    }
-}
-
-impl<T: Span> Span for &T {
-    fn as_range(&self) -> TextRange {
-        (*self).as_range()
-    }
-}
-
-impl<T: Span> Span for &mut T {
-    fn as_range(&self) -> TextRange {
-        (**self).as_range()
-    }
-}
-
-impl<T: Copy> Span for Range<T>
-where
-    TextSize: TryFrom<T>,
-    <TextSize as TryFrom<T>>::Error: Debug,
-{
-    fn as_range(&self) -> TextRange {
-        TextRange::new(
-            TextSize::try_from(self.start).expect("integer overflow"),
-            TextSize::try_from(self.end).expect("integer overflow"),
-        )
-    }
-}
-
-impl<T: Language> Span for SyntaxNode<T> {
-    fn as_range(&self) -> TextRange {
-        self.text_range()
-    }
-}
-
-impl<T: Language> Span for SyntaxToken<T> {
-    fn as_range(&self) -> TextRange {
-        self.text_range()
-    }
-}
-
-impl<T: Language> Span for SyntaxElement<T> {
-    fn as_range(&self) -> TextRange {
-        match self {
-            SyntaxElement::Node(n) => n.text_range(),
-            SyntaxElement::Token(t) => t.text_range(),
-        }
-    }
-}
-
-impl Span for TextRange {
-    fn as_range(&self) -> TextRange {
-        *self
-    }
-}
-
-/// A range that is indexed in a specific file.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub struct FileSpan {
-    pub file: FileId,
-    pub range: TextRange,
-}
-
-impl FileSpan {
-    pub fn new(file: FileId, span: impl Span) -> Self {
-        let range = span.as_range();
-        Self { file, range }
-    }
-}
-
-/// Interface for interacting with source files
-/// that are identified by a unique identifier.
-pub trait Files {
-    /// Returns the name of the file identified by the id.
-    fn name(&self, id: FileId) -> Option<&str>;
-
-    /// Returns the source of the file identified by the id.
-    fn source(&self, id: FileId) -> Option<SourceCode<&'_ str, &'_ LineIndex>>;
-}
-
-/// A file database that contains only one file.
-#[derive(Clone, Debug)]
-pub struct SimpleFile {
-    name: String,
-    source: String,
-    line_starts: LineIndexBuf,
-}
-
-impl SimpleFile {
-    /// Create a new file with the name and source.
-    pub fn new(name: String, source: String) -> Self {
-        Self {
-            line_starts: LineIndexBuf::from_source_text(&source),
-            name,
-            source,
-        }
-    }
-
-    /// Returns a `SimpleFile` that has no name and no source.
-    pub fn empty() -> SimpleFile {
-        SimpleFile::new(String::new(), String::new())
-    }
-
-    pub fn source_code(&self) -> SourceCode<&'_ str, &'_ LineIndex> {
-        SourceCode {
-            text: &self.source,
-            line_starts: Some(&self.line_starts),
-        }
-    }
-}
-
-impl Files for SimpleFile {
-    fn name(&self, _id: FileId) -> Option<&str> {
-        Some(&self.name)
-    }
-
-    fn source(&self, _id: FileId) -> Option<SourceCode<&'_ str, &'_ LineIndex>> {
-        Some(self.source_code())
-    }
-}
-
-/// A file database that stores multiple files.
-#[derive(Clone, Debug, Default)]
-pub struct SimpleFiles {
-    files: HashMap<FileId, SimpleFile>,
-    id: usize,
-}
-
-impl SimpleFiles {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Adds a file to this database and returns the id for the new file.
-    pub fn add(&mut self, name: String, source: String) -> FileId {
-        let id = FileId::from(self.id);
-        self.id += 1;
-        self.files.insert(id, SimpleFile::new(name, source));
-        id
-    }
-
-    pub fn get(&self, id: FileId) -> Option<&SimpleFile> {
-        self.files.get(&id)
-    }
-}
-
-impl Files for SimpleFiles {
-    fn name(&self, id: FileId) -> Option<&str> {
-        self.files.get(&id)?.name(id)
-    }
-
-    fn source(&self, id: FileId) -> Option<SourceCode<&'_ str, &'_ LineIndex>> {
-        self.files.get(&id)?.source(id)
-    }
-}
diff --git a/crates/rome_diagnostics/src/lib.rs b/crates/rome_diagnostics/src/lib.rs
index c6b649e797e..f100aa0f721 100644
--- a/crates/rome_diagnostics/src/lib.rs
+++ b/crates/rome_diagnostics/src/lib.rs
@@ -1,21 +1,52 @@
 #![deny(rust_2018_idioms)]
 
-use serde::{Deserialize, Serialize};
+use ::serde::{Deserialize, Serialize};
 
-pub mod file;
-pub mod v2;
+pub mod adapters;
+pub mod advice;
+pub mod context;
+pub mod diagnostic;
+pub mod display;
+pub mod error;
+pub mod location;
+pub mod serde;
 
-mod diagnostic;
-mod emit;
 mod suggestion;
 
-pub use diagnostic::{Diagnostic, Footer, Severity, SubDiagnostic};
-pub use emit::Emitter;
-pub use file::Span;
-pub use suggestion::*;
-
+pub use self::suggestion::{Applicability, CodeSuggestion, FileSpan};
 pub use termcolor;
 
+#[doc(hidden)]
+// Convenience re-export for procedural macro
+pub use rome_console as console;
+
+// Re-export macros from utility crates
+pub use rome_diagnostics_categories::{category, category_concat, Category};
+pub use rome_diagnostics_macros::Diagnostic;
+
+pub use crate::advice::{
+    Advices, CodeFrameAdvice, CommandAdvice, DiffAdvice, LogAdvice, LogCategory, Visit,
+};
+pub use crate::context::{Context, DiagnosticExt};
+pub use crate::diagnostic::{Diagnostic, DiagnosticTags, Severity};
+pub use crate::display::{
+    set_bottom_frame, Backtrace, MessageAndDescription, PrintDescription, PrintDiagnostic,
+};
+pub use crate::error::{Error, Result};
+pub use crate::location::{
+    FileId, FilePath, LineIndex, LineIndexBuf, Location, Resource, SourceCode,
+};
+
+pub mod prelude {
+    //! Anonymously re-exports all the traits declared by this module, this is
+    //! intended to be imported as `use rome_diagnostics::prelude::*;` to
+    //! automatically bring all these traits into the ambient context
+
+    pub use crate::advice::{Advices as _, Visit as _};
+    pub use crate::context::{Context as _, DiagnosticExt as _};
+    pub use crate::diagnostic::Diagnostic as _;
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum DiagnosticTag {
@@ -34,16 +65,4 @@ impl DiagnosticTag {
     }
 }
 
-/// Indicates how a tool should manage this suggestion.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub enum Applicability {
-    /// The suggestion is definitely what the user intended.
-    /// This suggestion should be automatically applied.
-    Always,
-    /// The suggestion may be what the user intended, but it is uncertain.
-    /// The suggestion should result in valid JavaScript/TypeScript code if it is applied.
-    MaybeIncorrect,
-}
-
 pub const MAXIMUM_DISPLAYABLE_DIAGNOSTICS: u16 = 200;
diff --git a/crates/rome_diagnostics/src/v2/location.rs b/crates/rome_diagnostics/src/location.rs
similarity index 100%
rename from crates/rome_diagnostics/src/v2/location.rs
rename to crates/rome_diagnostics/src/location.rs
diff --git a/crates/rome_diagnostics/src/v2/serde.rs b/crates/rome_diagnostics/src/serde.rs
similarity index 99%
rename from crates/rome_diagnostics/src/v2/serde.rs
rename to crates/rome_diagnostics/src/serde.rs
index 73a7308a811..e743b59f898 100644
--- a/crates/rome_diagnostics/src/v2/serde.rs
+++ b/crates/rome_diagnostics/src/serde.rs
@@ -8,7 +8,7 @@ use serde::{
     Deserialize, Deserializer, Serialize, Serializer,
 };
 
-use super::{
+use crate::{
     diagnostic::internal::AsDiagnostic, diagnostic::DiagnosticTag, Advices as _, Backtrace,
     Category, DiagnosticTags, LogCategory, Resource, Severity, SourceCode, Visit,
 };
@@ -366,8 +366,7 @@ mod tests {
     use serde_json::{from_value, json, to_value, Value};
 
     use crate::{
-        self as rome_diagnostics,
-        v2::{Advices, LogCategory, Visit},
+        self as rome_diagnostics, {Advices, LogCategory, Visit},
     };
     use rome_diagnostics_macros::Diagnostic;
 
diff --git a/crates/rome_diagnostics/src/suggestion.rs b/crates/rome_diagnostics/src/suggestion.rs
index 401ef23d628..2791e5630d1 100644
--- a/crates/rome_diagnostics/src/suggestion.rs
+++ b/crates/rome_diagnostics/src/suggestion.rs
@@ -1,8 +1,29 @@
-use crate::{file::FileSpan, *};
+use ::serde::{Deserialize, Serialize};
 use rome_console::MarkupBuf;
 use rome_rowan::TextRange;
 use rome_text_edit::TextEdit;
-use serde::{Deserialize, Serialize};
+
+use crate::FileId;
+
+/// A range that is indexed in a specific file.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub struct FileSpan {
+    pub file: FileId,
+    pub range: TextRange,
+}
+
+/// Indicates how a tool should manage this suggestion.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub enum Applicability {
+    /// The suggestion is definitely what the user intended.
+    /// This suggestion should be automatically applied.
+    Always,
+    /// The suggestion may be what the user intended, but it is uncertain.
+    /// The suggestion should result in valid JavaScript/TypeScript code if it is applied.
+    MaybeIncorrect,
+}
 
 /// A Suggestion that is provided by rslint, and
 /// can be reported to the user, and can be automatically
diff --git a/crates/rome_diagnostics/src/v2/diagnostic.rs b/crates/rome_diagnostics/src/v2/diagnostic.rs
deleted file mode 100644
index a1355fc803d..00000000000
--- a/crates/rome_diagnostics/src/v2/diagnostic.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-use std::{fmt::Debug, io};
-
-use bitflags::bitflags;
-use serde::{Deserialize, Serialize};
-
-use rome_console::fmt;
-
-use super::{Category, Location, Visit};
-
-/// The `Diagnostic` trait defines the metadata that can be exposed by error
-/// types in order to print details diagnostics in the console of the editor
-///
-/// ## Implementation
-///
-/// Most types should not have to implement this trait manually, and should
-/// instead rely on the `Diagnostic` derive macro also provided by this crate:
-///
-/// ```
-/// # use rome_diagnostics::v2::Diagnostic;
-/// #[derive(Debug, Diagnostic)]
-/// #[diagnostic(category = "lint/style/noShoutyConstants", tags(FIXABLE))]
-/// struct ExampleDiagnostic {
-///     #[message]
-///     #[description]
-///     message: String,
-/// }
-/// ```
-pub trait Diagnostic: Debug {
-    /// The category of a diagnostic uniquely identifying this
-    /// diagnostic type, such as `lint/correctness/noArguments`, `args/invalid`
-    /// or `format/disabled`.
-    fn category(&self) -> Option<&'static Category> {
-        None
-    }
-
-    /// The severity defines whether this diagnostic reports an error, a
-    /// warning, an information or a hint to the user.
-    fn severity(&self) -> Severity {
-        Severity::Error
-    }
-
-    /// The description is a text-only explanation of the issue this diagnostic
-    /// is reporting, intended for display contexts that do not support rich
-    /// markup such as in-editor popovers
-    ///
-    /// The description should generally be as exhaustive as possible, since
-    /// the clients that do not support rendering markup will not render the
-    /// advices for the diagnostic either.
-    fn description(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let _ = fmt;
-        Ok(())
-    }
-
-    /// An explanation of the issue this diagnostic is reporting
-    ///
-    /// In general it's better to keep this message as short as possible, and
-    /// instead rely on advices to better convey contextual explanations to the
-    /// user.
-    fn message(&self, fmt: &mut fmt::Formatter<'_>) -> io::Result<()> {
-        let _ = fmt;
-        Ok(())
-    }
-
-    /// Advices are the main building blocks used compose rich errors. They are
-    /// implemented using a visitor pattern, where consumers of a diagnostic
-    /// can visit the object and collect the advices that make it up for the
-    /// purpose of display or introspection.
-    fn advices(&self, visitor: &mut dyn Visit) -> io::Result<()> {
-        let _ = visitor;
-        Ok(())
-    }
-
-    /// Diagnostics can defines additional advices to be printed if the user
-    /// requires more detail about the diagnostic.
-    fn verbose_advices(&self, visitor: &mut dyn Visit) -> io::Result<()> {
-        let _ = visitor;
-        Ok(())
-    }
-
-    /// A diagnostic can be tied to a specific "location": this can be a file,
-    /// memory buffer, command line argument, etc. It may also be tied to a
-    /// specific text range within the content of that location. Finally, it
-    /// may also provide the source string for that location (this is required
-    /// in order to display a code frame advice for the diagnostic).
-    fn location(&self) -> Option<Location<'_>> {
-        None
-    }
-
-    /// Tags convey additional boolean metadata about the nature of a diagnostic:
-    /// - If the diagnostic can be automatically fixed
-    /// - If the diagnostic resulted from and internal error
-    /// - If the diagnostic is being emitted as part of a crash / fatal error
-    /// - If the diagnostic is a warning about a piece of unused or unnecessary code
-    /// - If the diagnostic is a warning about a piece of deprecated or obsolete code.
-    fn tags(&self) -> DiagnosticTags {
-        DiagnosticTags::empty()
-    }
-
-    /// Similarly to the `source` method of the [std::error::Error] trait, this
-    /// returns another diagnostic that's the logical "cause" for this issue.
-    /// For instance, a "request failed" diagnostic may have been cause by a
-    /// "deserialization error". This allows low-level error to be wrapped in
-    /// higher level concepts, while retaining enough information to display
-    /// and fix the underlying issue.
-    fn source(&self) -> Option<&dyn Diagnostic> {
-        None
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-/// The severity to associate to a diagnostic.
-pub enum Severity {
-    /// Reports a crash.
-    Fatal,
-    /// Reports an error.
-    Error,
-    /// Reports a warning.
-    Warning,
-    /// Reports an information.
-    Information,
-    /// Reports a hint.
-    Hint,
-}
-
-/// Internal enum used to automatically generate bit offsets for [DiagnosticTags]
-/// and help with the implementation of `serde` and `schemars` for tags.
-#[derive(Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-pub(super) enum DiagnosticTag {
-    Fixable,
-    Internal,
-    UnnecessaryCode,
-    DeprecatedCode,
-}
-
-bitflags! {
-    pub struct DiagnosticTags: u8 {
-        /// This diagnostic has a fix suggestion.
-        const FIXABLE = 1 << DiagnosticTag::Fixable as u8;
-        /// This diagnostic results from an internal error.
-        const INTERNAL = 1 << DiagnosticTag::Internal as u8;
-        /// This diagnostic tags unused or unnecessary code, this may change
-        /// how the diagnostic is render in editors.
-        const UNNECESSARY_CODE = 1 << DiagnosticTag::UnnecessaryCode as u8;
-        /// This diagnostic tags deprecated or obsolete code, this may change
-        /// how the diagnostic is render in editors.
-        const DEPRECATED_CODE = 1 << DiagnosticTag::DeprecatedCode as u8;
-    }
-}
-
-pub(crate) mod internal {
-    //! The `AsDiagnostic` trait needs to be declared as public as its referred
-    //! to in the `where` clause of other public items, but as it's not part of
-    //! the public API it's declared in a private module so it's not accessible
-    //! outside of the crate
-
-    use std::fmt::Debug;
-
-    use crate::v2::Diagnostic;
-
-    /// Since [Error](crate::v2::Error) must implement `From<T: Diagnostic>` to
-    /// be used with the `?` operator, it cannot implement the [Diagnostic]
-    /// trait (as that would conflict with the implementation of `From<T> for T`
-    /// in the standard library). The [AsDiagnostic] exists as an internal
-    /// implementation detail to bridge this gap and allow various types and
-    /// functions in `rome_diagnostics` to be generic over all diagnostics +
-    /// `Error`.
-    pub trait AsDiagnostic: Debug {
-        type Diagnostic: Diagnostic + ?Sized;
-        fn as_diagnostic(&self) -> &Self::Diagnostic;
-        fn as_dyn(&self) -> &dyn Diagnostic;
-    }
-
-    impl<D: Diagnostic> AsDiagnostic for D {
-        type Diagnostic = D;
-
-        fn as_diagnostic(&self) -> &Self::Diagnostic {
-            self
-        }
-
-        fn as_dyn(&self) -> &dyn Diagnostic {
-            self
-        }
-    }
-}
diff --git a/crates/rome_diagnostics/src/v2/mod.rs b/crates/rome_diagnostics/src/v2/mod.rs
deleted file mode 100644
index a61988f1acf..00000000000
--- a/crates/rome_diagnostics/src/v2/mod.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-pub mod adapters;
-pub mod advice;
-pub mod context;
-pub mod diagnostic;
-pub mod display;
-pub mod error;
-pub mod location;
-pub mod serde;
-
-#[doc(hidden)]
-// Convenience re-export for procedural macro
-pub use rome_console as console;
-
-// Re-export macros from utility crates
-pub use rome_diagnostics_categories::{category, category_concat, Category};
-pub use rome_diagnostics_macros::Diagnostic;
-
-pub use advice::{
-    Advices, CodeFrameAdvice, CommandAdvice, DiffAdvice, LogAdvice, LogCategory, Visit,
-};
-pub use context::{Context, DiagnosticExt};
-pub use diagnostic::{Diagnostic, DiagnosticTags, Severity};
-pub use display::{
-    set_bottom_frame, Backtrace, MessageAndDescription, PrintDescription, PrintDiagnostic,
-};
-pub use error::{Error, Result};
-pub use location::{FileId, FilePath, LineIndex, LineIndexBuf, Location, Resource, SourceCode};
-
-pub mod prelude {
-    //! Anonymously re-exports all the traits declared by this module, this is
-    //! intended to be imported as `use rome_diagnostics::v2::prelude::*;` to
-    //! automatically bring all these traits into the ambient context
-
-    pub use super::advice::{Advices as _, Visit as _};
-    pub use super::context::{Context as _, DiagnosticExt as _};
-    pub use super::diagnostic::Diagnostic as _;
-}
diff --git a/crates/rome_diagnostics/tests/macros/category_ident.rs b/crates/rome_diagnostics/tests/macros/category_ident.rs
index 03acbbde752..d2cd4f5a0cb 100644
--- a/crates/rome_diagnostics/tests/macros/category_ident.rs
+++ b/crates/rome_diagnostics/tests/macros/category_ident.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(category = Identifier)]
diff --git a/crates/rome_diagnostics/tests/macros/category_paren.rs b/crates/rome_diagnostics/tests/macros/category_paren.rs
index ef6daa57011..652cecde6ee 100644
--- a/crates/rome_diagnostics/tests/macros/category_paren.rs
+++ b/crates/rome_diagnostics/tests/macros/category_paren.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(message(description = Ident))]
diff --git a/crates/rome_diagnostics/tests/macros/description_ident.rs b/crates/rome_diagnostics/tests/macros/description_ident.rs
index 03acbbde752..d2cd4f5a0cb 100644
--- a/crates/rome_diagnostics/tests/macros/description_ident.rs
+++ b/crates/rome_diagnostics/tests/macros/description_ident.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(category = Identifier)]
diff --git a/crates/rome_diagnostics/tests/macros/description_paren.rs b/crates/rome_diagnostics/tests/macros/description_paren.rs
index 17a44904efe..faebc9396bd 100644
--- a/crates/rome_diagnostics/tests/macros/description_paren.rs
+++ b/crates/rome_diagnostics/tests/macros/description_paren.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(message(description("description")))]
diff --git a/crates/rome_diagnostics/tests/macros/description_syntax_error.rs b/crates/rome_diagnostics/tests/macros/description_syntax_error.rs
index 3a36371330f..3d984942c30 100644
--- a/crates/rome_diagnostics/tests/macros/description_syntax_error.rs
+++ b/crates/rome_diagnostics/tests/macros/description_syntax_error.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(message(description = "text {unclosed"))]
diff --git a/crates/rome_diagnostics/tests/macros/error_enum.rs b/crates/rome_diagnostics/tests/macros/error_enum.rs
index a989491d855..a82ef3bd0d3 100644
--- a/crates/rome_diagnostics/tests/macros/error_enum.rs
+++ b/crates/rome_diagnostics/tests/macros/error_enum.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 enum ErrorEnum {
diff --git a/crates/rome_diagnostics/tests/macros/error_union.rs b/crates/rome_diagnostics/tests/macros/error_union.rs
index f277ede86d6..b6a9a85889d 100644
--- a/crates/rome_diagnostics/tests/macros/error_union.rs
+++ b/crates/rome_diagnostics/tests/macros/error_union.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Diagnostic)]
 union ErrorUnion {
diff --git a/crates/rome_diagnostics/tests/macros/location_eq.rs b/crates/rome_diagnostics/tests/macros/location_eq.rs
index 034d74888b1..1b16d054bcc 100644
--- a/crates/rome_diagnostics/tests/macros/location_eq.rs
+++ b/crates/rome_diagnostics/tests/macros/location_eq.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 struct TestDiagnostic {
diff --git a/crates/rome_diagnostics/tests/macros/severity_lit_str.rs b/crates/rome_diagnostics/tests/macros/severity_lit_str.rs
index 5fcc67649ea..e8ade3321e6 100644
--- a/crates/rome_diagnostics/tests/macros/severity_lit_str.rs
+++ b/crates/rome_diagnostics/tests/macros/severity_lit_str.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(severity = "Error")]
diff --git a/crates/rome_diagnostics/tests/macros/severity_paren.rs b/crates/rome_diagnostics/tests/macros/severity_paren.rs
index a6f42d55e54..f7f10473a4f 100644
--- a/crates/rome_diagnostics/tests/macros/severity_paren.rs
+++ b/crates/rome_diagnostics/tests/macros/severity_paren.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(severity(Error))]
diff --git a/crates/rome_diagnostics/tests/macros/tags_comma.rs b/crates/rome_diagnostics/tests/macros/tags_comma.rs
index c04ea2323b6..70c827c9760 100644
--- a/crates/rome_diagnostics/tests/macros/tags_comma.rs
+++ b/crates/rome_diagnostics/tests/macros/tags_comma.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(tags(Identifier, Identifier))]
diff --git a/crates/rome_diagnostics/tests/macros/tags_eq.rs b/crates/rome_diagnostics/tests/macros/tags_eq.rs
index 0d8f2a0f059..4258ed24473 100644
--- a/crates/rome_diagnostics/tests/macros/tags_eq.rs
+++ b/crates/rome_diagnostics/tests/macros/tags_eq.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(tags = Identifier)]
diff --git a/crates/rome_diagnostics/tests/macros/unknown_container_attr.rs b/crates/rome_diagnostics/tests/macros/unknown_container_attr.rs
index c784a954485..f6238aaafd4 100644
--- a/crates/rome_diagnostics/tests/macros/unknown_container_attr.rs
+++ b/crates/rome_diagnostics/tests/macros/unknown_container_attr.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(unknown_attr)]
diff --git a/crates/rome_diagnostics/tests/macros/unknown_field_attr.rs b/crates/rome_diagnostics/tests/macros/unknown_field_attr.rs
index 3936483e927..e89a4bc28c3 100644
--- a/crates/rome_diagnostics/tests/macros/unknown_field_attr.rs
+++ b/crates/rome_diagnostics/tests/macros/unknown_field_attr.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 struct TestDiagnostic {
diff --git a/crates/rome_diagnostics/tests/macros/unknown_location_attr.rs b/crates/rome_diagnostics/tests/macros/unknown_location_attr.rs
index 4f816a81e41..33344e80d9b 100644
--- a/crates/rome_diagnostics/tests/macros/unknown_location_attr.rs
+++ b/crates/rome_diagnostics/tests/macros/unknown_location_attr.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 struct TestDiagnostic {
diff --git a/crates/rome_diagnostics/tests/macros/unknown_message_attr.rs b/crates/rome_diagnostics/tests/macros/unknown_message_attr.rs
index 30073091b26..0a3c3fe4819 100644
--- a/crates/rome_diagnostics/tests/macros/unknown_message_attr.rs
+++ b/crates/rome_diagnostics/tests/macros/unknown_message_attr.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::v2::Diagnostic;
+use rome_diagnostics::Diagnostic;
 
 #[derive(Debug, Diagnostic)]
 #[diagnostic(message(unknown))]
diff --git a/crates/rome_diagnostics_macros/src/generate.rs b/crates/rome_diagnostics_macros/src/generate.rs
index ec0a46cc4c7..76740e47ca2 100644
--- a/crates/rome_diagnostics_macros/src/generate.rs
+++ b/crates/rome_diagnostics_macros/src/generate.rs
@@ -28,7 +28,7 @@ pub(crate) fn generate_diagnostic(input: DeriveInput) -> TokenStream {
     let generics = input.generics;
 
     quote! {
-        impl #generic_params rome_diagnostics::v2::Diagnostic for #ident #generics {
+        impl #generic_params rome_diagnostics::Diagnostic for #ident #generics {
             #category
             #severity
             #description
@@ -45,7 +45,7 @@ pub(crate) fn generate_diagnostic(input: DeriveInput) -> TokenStream {
 fn generate_category(input: &DeriveInput) -> TokenStream {
     let category = match &input.category {
         Some(StaticOrDynamic::Static(value)) => quote! {
-            rome_diagnostics::v2::category!(#value)
+            rome_diagnostics::category!(#value)
         },
         Some(StaticOrDynamic::Dynamic(value)) => quote! {
             self.#value
@@ -54,7 +54,7 @@ fn generate_category(input: &DeriveInput) -> TokenStream {
     };
 
     quote! {
-        fn category(&self) -> Option<&'static rome_diagnostics::v2::Category> {
+        fn category(&self) -> Option<&'static rome_diagnostics::Category> {
             Some(#category)
         }
     }
@@ -63,7 +63,7 @@ fn generate_category(input: &DeriveInput) -> TokenStream {
 fn generate_severity(input: &DeriveInput) -> TokenStream {
     let severity = match &input.severity {
         Some(StaticOrDynamic::Static(value)) => quote! {
-            rome_diagnostics::v2::Severity::#value
+            rome_diagnostics::Severity::#value
         },
         Some(StaticOrDynamic::Dynamic(value)) => quote! {
             self.#value
@@ -72,7 +72,7 @@ fn generate_severity(input: &DeriveInput) -> TokenStream {
     };
 
     quote! {
-        fn severity(&self) -> rome_diagnostics::v2::Severity {
+        fn severity(&self) -> rome_diagnostics::Severity {
             #severity
         }
     }
@@ -129,11 +129,11 @@ fn generate_description(input: &DeriveInput) -> TokenStream {
             let mut buffer = Vec::new();
 
             let write = rome_diagnostics::termcolor::NoColor::new(&mut buffer);
-            let mut write = rome_diagnostics::v2::console::fmt::Termcolor(write);
-            let mut write = rome_diagnostics::v2::console::fmt::Formatter::new(&mut write);
+            let mut write = rome_diagnostics::console::fmt::Termcolor(write);
+            let mut write = rome_diagnostics::console::fmt::Formatter::new(&mut write);
 
-            use rome_diagnostics::v2::console as rome_console;
-            write.write_markup(&rome_diagnostics::v2::console::markup!{ #markup })
+            use rome_diagnostics::console as rome_console;
+            write.write_markup(&rome_diagnostics::console::markup!{ #markup })
                 .map_err(|_| ::std::fmt::Error)?;
 
             fmt.write_str(::std::str::from_utf8(&buffer).map_err(|_| ::std::fmt::Error)?)
@@ -157,17 +157,17 @@ fn generate_message(input: &DeriveInput) -> TokenStream {
             fmt.write_str(#value)
         },
         Some(StaticOrDynamic::Static(StringOrMarkup::Markup(markup))) => quote! {
-            use rome_diagnostics::v2::console as rome_console;
-            fmt.write_markup(rome_diagnostics::v2::console::markup!{ #markup })
+            use rome_diagnostics::console as rome_console;
+            fmt.write_markup(rome_diagnostics::console::markup!{ #markup })
         },
         Some(StaticOrDynamic::Dynamic(value)) => quote! {
-            rome_diagnostics::v2::console::fmt::Display::fmt(&self.#value, fmt)
+            rome_diagnostics::console::fmt::Display::fmt(&self.#value, fmt)
         },
         None => return quote!(),
     };
 
     quote! {
-        fn message(&self, fmt: &mut rome_diagnostics::v2::console::fmt::Formatter<'_>) -> ::std::io::Result<()> {
+        fn message(&self, fmt: &mut rome_diagnostics::console::fmt::Formatter<'_>) -> ::std::io::Result<()> {
             #message
         }
     }
@@ -181,8 +181,8 @@ fn generate_advices(input: &DeriveInput) -> TokenStream {
     let advices = input.advices.iter();
 
     quote! {
-        fn advices(&self, visitor: &mut dyn rome_diagnostics::v2::Visit) -> ::std::io::Result<()> {
-            #( rome_diagnostics::v2::Advices::record(&self.#advices, visitor)?; )*
+        fn advices(&self, visitor: &mut dyn rome_diagnostics::Visit) -> ::std::io::Result<()> {
+            #( rome_diagnostics::Advices::record(&self.#advices, visitor)?; )*
             Ok(())
         }
     }
@@ -196,8 +196,8 @@ fn generate_verbose_advices(input: &DeriveInput) -> TokenStream {
     let verbose_advices = input.verbose_advices.iter();
 
     quote! {
-        fn verbose_advices(&self, visitor: &mut dyn rome_diagnostics::v2::Visit) -> ::std::io::Result<()> {
-            #( rome_diagnostics::v2::Advices::record(&self.#verbose_advices, visitor)?; )*
+        fn verbose_advices(&self, visitor: &mut dyn rome_diagnostics::Visit) -> ::std::io::Result<()> {
+            #( rome_diagnostics::Advices::record(&self.#verbose_advices, visitor)?; )*
             Ok(())
         }
     }
@@ -212,8 +212,8 @@ fn generate_location(input: &DeriveInput) -> TokenStream {
     let method = input.location.iter().map(|(_, method)| method);
 
     quote! {
-        fn location(&self) -> Option<rome_diagnostics::v2::Location<'_>> {
-            rome_diagnostics::v2::Location::builder()
+        fn location(&self) -> Option<rome_diagnostics::Location<'_>> {
+            rome_diagnostics::Location::builder()
                 #( .#method(&self.#field) )*
                 .build()
         }
@@ -225,7 +225,7 @@ fn generate_tags(input: &DeriveInput) -> TokenStream {
         Some(StaticOrDynamic::Static(value)) => {
             let values = value.iter();
             quote! {
-                #( rome_diagnostics::v2::DiagnosticTags::#values )|*
+                #( rome_diagnostics::DiagnosticTags::#values )|*
             }
         }
         Some(StaticOrDynamic::Dynamic(value)) => quote! {
@@ -235,7 +235,7 @@ fn generate_tags(input: &DeriveInput) -> TokenStream {
     };
 
     quote! {
-        fn tags(&self) -> rome_diagnostics::v2::DiagnosticTags {
+        fn tags(&self) -> rome_diagnostics::DiagnosticTags {
             #tags
         }
     }
@@ -244,7 +244,7 @@ fn generate_tags(input: &DeriveInput) -> TokenStream {
 fn generate_source(input: &DeriveInput) -> TokenStream {
     match &input.source {
         Some(value) => quote! {
-            fn source(&self) -> Option<&dyn rome_diagnostics::v2::Diagnostic> {
+            fn source(&self) -> Option<&dyn rome_diagnostics::Diagnostic> {
                 self.#value.as_deref()
             }
         },
diff --git a/crates/rome_formatter/src/comments/builder.rs b/crates/rome_formatter/src/comments/builder.rs
index dc197522939..ea30a196b3c 100644
--- a/crates/rome_formatter/src/comments/builder.rs
+++ b/crates/rome_formatter/src/comments/builder.rs
@@ -639,7 +639,7 @@ mod tests {
         DecoratedComment, SourceComment,
     };
     use crate::{TextSize, TransformSourceMap, TransformSourceMapBuilder};
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_js_parser::parse_module;
     use rome_js_syntax::{
         JsIdentifierExpression, JsLanguage, JsParameters, JsParenthesizedExpression,
diff --git a/crates/rome_fs/src/fs.rs b/crates/rome_fs/src/fs.rs
index 4e04de36ef0..42ce74fa974 100644
--- a/crates/rome_fs/src/fs.rs
+++ b/crates/rome_fs/src/fs.rs
@@ -5,8 +5,8 @@ use std::sync::Arc;
 
 use crate::{PathInterner, RomePath};
 use rome_diagnostics::{
-    file::FileId,
-    v2::{console, Advices, Diagnostic, LogCategory, Visit},
+    location::FileId,
+    {console, Advices, Diagnostic, LogCategory, Visit},
 };
 
 mod memory;
@@ -14,7 +14,7 @@ mod os;
 
 pub use memory::{ErrorEntry, MemoryFileSystem};
 pub use os::OsFileSystem;
-use rome_diagnostics::v2::Error;
+use rome_diagnostics::Error;
 pub const CONFIG_NAME: &str = "rome.json";
 
 pub trait FileSystem: Send + Sync + RefUnwindSafe {
diff --git a/crates/rome_fs/src/fs/memory.rs b/crates/rome_fs/src/fs/memory.rs
index 1237e1b989c..0cb268cbf83 100644
--- a/crates/rome_fs/src/fs/memory.rs
+++ b/crates/rome_fs/src/fs/memory.rs
@@ -6,7 +6,7 @@ use std::str;
 use std::sync::Arc;
 
 use parking_lot::{lock_api::ArcMutexGuard, Mutex, RawMutex, RwLock};
-use rome_diagnostics::v2::Error;
+use rome_diagnostics::Error;
 
 use crate::fs::{FileSystemExt, OpenOptions};
 use crate::{FileSystem, RomePath, TraversalContext, TraversalScope};
@@ -207,11 +207,11 @@ mod tests {
     };
 
     use parking_lot::Mutex;
-    use rome_diagnostics::v2::Error;
+    use rome_diagnostics::Error;
 
     use crate::fs::FileSystemExt;
     use crate::{FileSystem, MemoryFileSystem, PathInterner, RomePath, TraversalContext};
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
 
     #[test]
     fn file_read_write() {
diff --git a/crates/rome_fs/src/fs/os.rs b/crates/rome_fs/src/fs/os.rs
index ee5631ab08e..db09daaf2ba 100644
--- a/crates/rome_fs/src/fs/os.rs
+++ b/crates/rome_fs/src/fs/os.rs
@@ -6,7 +6,7 @@ use crate::{
     FileSystem, RomePath,
 };
 use rayon::{scope, Scope};
-use rome_diagnostics::v2::{adapters::IoError, DiagnosticExt, Error, FileId};
+use rome_diagnostics::{adapters::IoError, DiagnosticExt, Error, FileId};
 use std::fs::DirEntry;
 use std::{
     ffi::OsStr,
diff --git a/crates/rome_fs/src/interner.rs b/crates/rome_fs/src/interner.rs
index 874899914dc..0e2634ac24a 100644
--- a/crates/rome_fs/src/interner.rs
+++ b/crates/rome_fs/src/interner.rs
@@ -3,7 +3,7 @@ use std::sync::RwLock;
 
 use crossbeam::channel::{unbounded, Receiver, Sender};
 use indexmap::IndexSet;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 
 /// File paths interner cache
 ///
diff --git a/crates/rome_fs/src/path.rs b/crates/rome_fs/src/path.rs
index 97b3d70b600..827395e8f1b 100644
--- a/crates/rome_fs/src/path.rs
+++ b/crates/rome_fs/src/path.rs
@@ -7,7 +7,7 @@ use std::fs::read_to_string;
 use std::io::Read;
 use std::{fs::File, io, io::Write, ops::Deref, path::PathBuf};
 
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 
 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
 #[cfg_attr(
diff --git a/crates/rome_js_analyze/src/lib.rs b/crates/rome_js_analyze/src/lib.rs
index df082d690d7..8048d55d5a5 100644
--- a/crates/rome_js_analyze/src/lib.rs
+++ b/crates/rome_js_analyze/src/lib.rs
@@ -4,7 +4,7 @@ use rome_analyze::{
     InspectMatcher, LanguageRoot, MatchQueryParams, MetadataRegistry, Phases, RuleAction,
     RuleRegistry, ServiceBag, SyntaxVisitor,
 };
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_syntax::{
     suppression::{parse_suppression_comment, SuppressionCategory},
     JsLanguage,
@@ -123,8 +123,8 @@ mod tests {
     use rome_console::fmt::{Formatter, Termcolor};
     use rome_console::{markup, Markup};
     use rome_diagnostics::termcolor::NoColor;
-    use rome_diagnostics::v2::{Diagnostic, DiagnosticExt, PrintDiagnostic, Severity};
-    use rome_diagnostics::{file::FileId, v2::category};
+    use rome_diagnostics::{category, location::FileId};
+    use rome_diagnostics::{Diagnostic, DiagnosticExt, PrintDiagnostic, Severity};
     use rome_js_parser::parse;
     use rome_js_syntax::{SourceType, TextRange, TextSize};
 
diff --git a/crates/rome_js_analyze/src/react/hooks.rs b/crates/rome_js_analyze/src/react/hooks.rs
index 62d2f9596ed..6bbad22c195 100644
--- a/crates/rome_js_analyze/src/react/hooks.rs
+++ b/crates/rome_js_analyze/src/react/hooks.rs
@@ -189,7 +189,7 @@ pub fn is_binding_react_stable(
 #[cfg(test)]
 mod test {
     use super::*;
-    use rome_diagnostics::v2::FileId;
+    use rome_diagnostics::FileId;
     use rome_js_syntax::SourceType;
     use rome_rowan::SyntaxNodeCast;
 
diff --git a/crates/rome_js_analyze/src/syntax/nursery/no_super_without_extends.rs b/crates/rome_js_analyze/src/syntax/nursery/no_super_without_extends.rs
index ac754dba65e..c8bd7ebf80a 100644
--- a/crates/rome_js_analyze/src/syntax/nursery/no_super_without_extends.rs
+++ b/crates/rome_js_analyze/src/syntax/nursery/no_super_without_extends.rs
@@ -1,7 +1,7 @@
 use rome_analyze::context::RuleContext;
 use rome_analyze::{declare_rule, Ast, Rule, RuleDiagnostic};
 use rome_console::markup;
-use rome_diagnostics::v2::category;
+use rome_diagnostics::category;
 use rome_js_syntax::{JsClassDeclaration, JsSuperExpression};
 use rome_rowan::AstNode;
 
diff --git a/crates/rome_js_analyze/src/utils/tests.rs b/crates/rome_js_analyze/src/utils/tests.rs
index 921353d7c05..208332effbf 100644
--- a/crates/rome_js_analyze/src/utils/tests.rs
+++ b/crates/rome_js_analyze/src/utils/tests.rs
@@ -3,7 +3,7 @@ use std::{any::type_name, fmt::Debug};
 
 use super::rename::*;
 use crate::utils::batch::JsBatchMutation;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_semantic::{semantic_model, SemanticModelOptions};
 use rome_js_syntax::{
     JsAnyObjectMember, JsFormalParameter, JsIdentifierBinding, JsLanguage, JsVariableDeclarator,
diff --git a/crates/rome_js_analyze/tests/spec_tests.rs b/crates/rome_js_analyze/tests/spec_tests.rs
index 3611f705365..109ae280d3f 100644
--- a/crates/rome_js_analyze/tests/spec_tests.rs
+++ b/crates/rome_js_analyze/tests/spec_tests.rs
@@ -7,9 +7,9 @@ use rome_console::{
     fmt::{Formatter, Termcolor},
     markup, Markup,
 };
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_diagnostics::termcolor::NoColor;
-use rome_diagnostics::v2::{DiagnosticExt, PrintDiagnostic, Severity};
+use rome_diagnostics::{DiagnosticExt, PrintDiagnostic, Severity};
 use rome_js_parser::{
     parse,
     test_utils::{assert_errors_are_absent, has_unknown_nodes_or_empty_slots},
diff --git a/crates/rome_js_formatter/src/check_reformat.rs b/crates/rome_js_formatter/src/check_reformat.rs
index 19d8a4a6846..2533f0a82c3 100644
--- a/crates/rome_js_formatter/src/check_reformat.rs
+++ b/crates/rome_js_formatter/src/check_reformat.rs
@@ -1,8 +1,8 @@
 use crate::{format_node, JsFormatOptions};
-use rome_diagnostics::v2::console::fmt::{Formatter, Termcolor};
-use rome_diagnostics::v2::console::markup;
-use rome_diagnostics::v2::{DiagnosticExt, PrintDiagnostic};
-use rome_diagnostics::{file::FileId, termcolor};
+use rome_diagnostics::console::fmt::{Formatter, Termcolor};
+use rome_diagnostics::console::markup;
+use rome_diagnostics::{location::FileId, termcolor};
+use rome_diagnostics::{DiagnosticExt, PrintDiagnostic};
 use rome_js_parser::parse;
 use rome_js_syntax::{JsSyntaxNode, SourceType};
 
diff --git a/crates/rome_js_formatter/src/comments.rs b/crates/rome_js_formatter/src/comments.rs
index 321875ba40c..ea4c12f7ec6 100644
--- a/crates/rome_js_formatter/src/comments.rs
+++ b/crates/rome_js_formatter/src/comments.rs
@@ -73,7 +73,7 @@ impl FormatRule<SourceComment<JsLanguage>> for FormatJsLeadingComment {
 /// # use rome_js_parser::parse_module;
 /// # use rome_js_syntax::JsLanguage;
 /// # use rome_rowan::{Direction, SyntaxTriviaPieceComments};
-/// # use rome_diagnostics::file::FileId;
+/// # use rome_diagnostics::location::FileId;
 ///  use rome_js_formatter::comments::is_doc_comment;
 ///
 /// # fn parse_comment(source: &str) -> SyntaxTriviaPieceComments<JsLanguage> {
diff --git a/crates/rome_js_formatter/src/lib.rs b/crates/rome_js_formatter/src/lib.rs
index e6819bd2f23..077413392c9 100644
--- a/crates/rome_js_formatter/src/lib.rs
+++ b/crates/rome_js_formatter/src/lib.rs
@@ -566,7 +566,7 @@ mod tests {
     use super::{format_node, format_range};
 
     use crate::context::{JsFormatOptions, Semicolons};
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_formatter::IndentStyle;
     use rome_js_parser::{parse, parse_script};
     use rome_js_syntax::SourceType;
diff --git a/crates/rome_js_formatter/src/parentheses.rs b/crates/rome_js_formatter/src/parentheses.rs
index 6d0d67153a1..64c79f9550c 100644
--- a/crates/rome_js_formatter/src/parentheses.rs
+++ b/crates/rome_js_formatter/src/parentheses.rs
@@ -957,7 +957,7 @@ pub(crate) fn debug_assert_is_parent(node: &JsSyntaxNode, parent: &JsSyntaxNode)
 pub(crate) mod tests {
     use super::NeedsParentheses;
     use crate::transform;
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_js_syntax::{JsLanguage, SourceType};
     use rome_rowan::AstNode;
 
diff --git a/crates/rome_js_formatter/src/syntax_rewriter.rs b/crates/rome_js_formatter/src/syntax_rewriter.rs
index c547eca32aa..a5fd2f21f39 100644
--- a/crates/rome_js_formatter/src/syntax_rewriter.rs
+++ b/crates/rome_js_formatter/src/syntax_rewriter.rs
@@ -531,7 +531,7 @@ where
 mod tests {
     use super::JsFormatSyntaxRewriter;
     use crate::{format_node, JsFormatOptions, TextRange};
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_formatter::{SourceMarker, TransformSourceMap};
     use rome_js_parser::{parse, parse_module};
     use rome_js_syntax::{
diff --git a/crates/rome_js_formatter/src/utils/binary_like_expression.rs b/crates/rome_js_formatter/src/utils/binary_like_expression.rs
index db04a762fb0..d28dc6f8a7e 100644
--- a/crates/rome_js_formatter/src/utils/binary_like_expression.rs
+++ b/crates/rome_js_formatter/src/utils/binary_like_expression.rs
@@ -895,7 +895,7 @@ impl FusedIterator for BinaryLikePreorder {}
 mod tests {
     use crate::utils::binary_like_expression::{BinaryLikePreorder, VisitEvent};
     use crate::utils::JsAnyBinaryLikeExpression;
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_js_parser::parse_module;
     use rome_js_syntax::JsLogicalExpression;
     use rome_rowan::AstNode;
diff --git a/crates/rome_js_formatter/src/utils/jsx.rs b/crates/rome_js_formatter/src/utils/jsx.rs
index b0ac9df07a8..c71ed4b9e42 100644
--- a/crates/rome_js_formatter/src/utils/jsx.rs
+++ b/crates/rome_js_formatter/src/utils/jsx.rs
@@ -490,7 +490,7 @@ impl FusedIterator for JsxSplitChunksIterator<'_> {}
 #[cfg(test)]
 mod tests {
     use crate::utils::jsx::{jsx_split_children, JsxChild, JsxSplitChunksIterator, JsxTextChunk};
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_formatter::comments::Comments;
     use rome_js_parser::parse;
     use rome_js_syntax::{JsxChildList, JsxText, SourceType};
diff --git a/crates/rome_js_formatter/src/utils/test_call.rs b/crates/rome_js_formatter/src/utils/test_call.rs
index 0e772b77a50..0325e269f0a 100644
--- a/crates/rome_js_formatter/src/utils/test_call.rs
+++ b/crates/rome_js_formatter/src/utils/test_call.rs
@@ -429,7 +429,7 @@ impl Iterator for CalleeNamesIterator {
 #[cfg(test)]
 mod test {
     use super::{contains_a_test_pattern, is_test_each_pattern_callee};
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_js_parser::parse;
     use rome_js_syntax::{JsCallExpression, JsTemplate, SourceType};
     use rome_rowan::AstNodeList;
diff --git a/crates/rome_js_formatter/tests/check_reformat.rs b/crates/rome_js_formatter/tests/check_reformat.rs
index 43edd7bcfd3..0098a080500 100644
--- a/crates/rome_js_formatter/tests/check_reformat.rs
+++ b/crates/rome_js_formatter/tests/check_reformat.rs
@@ -1,7 +1,7 @@
-use rome_diagnostics::v2::console::fmt::{Formatter, Termcolor};
-use rome_diagnostics::v2::console::markup;
-use rome_diagnostics::v2::{DiagnosticExt, PrintDiagnostic};
-use rome_diagnostics::{file::FileId, file::SimpleFiles, termcolor};
+use rome_diagnostics::console::fmt::{Formatter, Termcolor};
+use rome_diagnostics::console::markup;
+use rome_diagnostics::{location::FileId, termcolor};
+use rome_diagnostics::{DiagnosticExt, PrintDiagnostic};
 use rome_js_formatter::context::JsFormatOptions;
 use rome_js_formatter::format_node;
 use rome_js_parser::parse;
@@ -30,9 +30,6 @@ pub fn check_reformat(params: CheckReformatParams) {
 
     // Panic if the result from the formatter has syntax errors
     if re_parse.has_errors() {
-        let mut files = SimpleFiles::new();
-        files.add(file_name.into(), text.into());
-
         let mut buffer = termcolor::Buffer::ansi();
 
         for diagnostic in re_parse.diagnostics() {
diff --git a/crates/rome_js_formatter/tests/prettier_tests.rs b/crates/rome_js_formatter/tests/prettier_tests.rs
index 3eba1a0c81b..a4f2698bb7a 100644
--- a/crates/rome_js_formatter/tests/prettier_tests.rs
+++ b/crates/rome_js_formatter/tests/prettier_tests.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_rowan::{TextRange, TextSize};
 use similar::{utils::diff_lines, Algorithm, ChangeTag, TextDiff};
 use std::fs::remove_file;
@@ -15,11 +15,11 @@ use std::{
     sync::Once,
 };
 
+use rome_diagnostics::console::fmt::{Formatter, Termcolor};
+use rome_diagnostics::console::markup;
 use rome_diagnostics::termcolor;
-use rome_diagnostics::v2::console::fmt::{Formatter, Termcolor};
-use rome_diagnostics::v2::console::markup;
-use rome_diagnostics::v2::DiagnosticExt;
-use rome_diagnostics::v2::PrintDiagnostic;
+use rome_diagnostics::DiagnosticExt;
+use rome_diagnostics::PrintDiagnostic;
 use rome_formatter::{FormatOptions, IndentStyle};
 use rome_js_formatter::context::JsFormatOptions;
 use rome_js_parser::parse;
diff --git a/crates/rome_js_formatter/tests/spec_test.rs b/crates/rome_js_formatter/tests/spec_test.rs
index ed109b91027..c512b994200 100644
--- a/crates/rome_js_formatter/tests/spec_test.rs
+++ b/crates/rome_js_formatter/tests/spec_test.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_formatter::{FormatOptions, LineWidth};
 use rome_formatter::{IndentStyle, Printed};
 use rome_fs::RomePath;
diff --git a/crates/rome_js_parser/src/lexer/buffered_lexer.rs b/crates/rome_js_parser/src/lexer/buffered_lexer.rs
index 25cbf531aa8..88eddfac447 100644
--- a/crates/rome_js_parser/src/lexer/buffered_lexer.rs
+++ b/crates/rome_js_parser/src/lexer/buffered_lexer.rs
@@ -283,7 +283,7 @@ impl From<&LexerCheckpoint> for LookaheadToken {
 mod tests {
     use super::BufferedLexer;
     use crate::lexer::{LexContext, Lexer, TextRange, TextSize};
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_js_syntax::JsSyntaxKind::{JS_NUMBER_LITERAL, NEWLINE, WHITESPACE};
     use rome_js_syntax::T;
 
diff --git a/crates/rome_js_parser/src/lexer/errors.rs b/crates/rome_js_parser/src/lexer/errors.rs
index c9a269f3f27..e17381b93db 100644
--- a/crates/rome_js_parser/src/lexer/errors.rs
+++ b/crates/rome_js_parser/src/lexer/errors.rs
@@ -1,5 +1,5 @@
 use crate::ParseDiagnostic;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 
 pub fn invalid_digits_after_unicode_escape_sequence(
     file_id: FileId,
diff --git a/crates/rome_js_parser/src/lexer/mod.rs b/crates/rome_js_parser/src/lexer/mod.rs
index ebed5bef87a..ed1603f8df8 100644
--- a/crates/rome_js_parser/src/lexer/mod.rs
+++ b/crates/rome_js_parser/src/lexer/mod.rs
@@ -39,7 +39,7 @@ use self::bytes::{
     Dispatch::{self, *},
 };
 use crate::ParseDiagnostic;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_syntax::JsSyntaxKind::*;
 
 use self::errors::invalid_digits_after_unicode_escape_sequence;
diff --git a/crates/rome_js_parser/src/lexer/tests.rs b/crates/rome_js_parser/src/lexer/tests.rs
index d623d9df377..c2e60f731b4 100644
--- a/crates/rome_js_parser/src/lexer/tests.rs
+++ b/crates/rome_js_parser/src/lexer/tests.rs
@@ -2,9 +2,9 @@
 #![allow(unused_mut, unused_variables, unused_assignments)]
 
 use super::{LexContext, Lexer, TextSize};
+use crate::span::Span;
 use quickcheck_macros::quickcheck;
-use rome_diagnostics::file::FileId;
-use rome_diagnostics::Span;
+use rome_diagnostics::location::FileId;
 use rome_js_syntax::JsSyntaxKind::{self, EOF};
 use std::sync::mpsc::channel;
 use std::thread;
diff --git a/crates/rome_js_parser/src/lib.rs b/crates/rome_js_parser/src/lib.rs
index 3eb6b235b8f..12e87656346 100644
--- a/crates/rome_js_parser/src/lib.rs
+++ b/crates/rome_js_parser/src/lib.rs
@@ -358,6 +358,7 @@ mod event;
 mod lexer;
 mod lossless_tree_sink;
 mod parse;
+mod span;
 mod state;
 
 #[cfg(any(test, feature = "tests"))]
@@ -381,9 +382,9 @@ pub use crate::{
 pub(crate) use parser::{Checkpoint, CompletedMarker, Marker, ParseRecovery, Parser};
 use rome_console::fmt::Display;
 use rome_console::MarkupBuf;
-use rome_diagnostics::v2::console::markup;
-use rome_diagnostics::v2::location::AsSpan;
-use rome_diagnostics::v2::{
+use rome_diagnostics::console::markup;
+use rome_diagnostics::location::AsSpan;
+use rome_diagnostics::{
     Advices, Diagnostic, FileId, Location, LogCategory, MessageAndDescription, Visit,
 };
 use rome_js_syntax::{JsSyntaxKind, LanguageVariant};
@@ -498,7 +499,7 @@ impl ParseDiagnostic {
     /// ```
     /// use rome_console::fmt::{Termcolor};
     /// use rome_console::markup;
-    /// use rome_diagnostics::v2::{DiagnosticExt, FileId, PrintDiagnostic, console::fmt::Formatter};
+    /// use rome_diagnostics::{DiagnosticExt, FileId, PrintDiagnostic, console::fmt::Formatter};
     /// use rome_js_parser::ParseDiagnostic;
     /// use rome_js_syntax::TextRange;
     /// use rome_rowan::TextSize;
@@ -556,7 +557,7 @@ impl ParseDiagnostic {
     /// ```
     /// use rome_console::fmt::{Termcolor};
     /// use rome_console::markup;
-    /// use rome_diagnostics::v2::{DiagnosticExt, FileId, PrintDiagnostic, console::fmt::Formatter};
+    /// use rome_diagnostics::{DiagnosticExt, FileId, PrintDiagnostic, console::fmt::Formatter};
     /// use rome_js_parser::ParseDiagnostic;
     /// use rome_js_syntax::TextRange;
     /// use rome_rowan::TextSize;
diff --git a/crates/rome_js_parser/src/parse.rs b/crates/rome_js_parser/src/parse.rs
index 1e42091a303..9f7f8766886 100644
--- a/crates/rome_js_parser/src/parse.rs
+++ b/crates/rome_js_parser/src/parse.rs
@@ -2,7 +2,7 @@
 
 use crate::token_source::Trivia;
 use crate::*;
-pub use rome_diagnostics::file::FileId;
+pub use rome_diagnostics::location::FileId;
 use rome_js_syntax::{
     JsAnyRoot, JsExpressionSnipped, JsLanguage, JsModule, JsScript, JsSyntaxNode, ModuleKind,
     SourceType,
@@ -49,7 +49,7 @@ impl<T> Parse<T> {
     /// use rome_js_parser::parse_script;
     /// use rome_js_syntax::{JsIfStatement, JsSyntaxKind};
     /// use rome_rowan::{AstNode, AstNodeList};
-    /// use rome_diagnostics::file::FileId;
+    /// use rome_diagnostics::location::FileId;
     ///
     /// let parse = parse_script(
     ///     "
@@ -135,7 +135,7 @@ pub fn parse_common(
 /// use rome_js_parser::parse_script;
 /// use rome_js_syntax::{JsSyntaxToken, SourceType, JsSyntaxList, JsComputedMemberExpression};
 /// use rome_rowan::{AstNode, Direction};
-/// use rome_diagnostics::file::FileId;
+/// use rome_diagnostics::location::FileId;
 ///
 /// let parse = parse_script("foo.bar[2]", FileId::zero());
 /// // Parse returns a JS Root which contains two lists, the directives and the statements, let's get the statements
diff --git a/crates/rome_js_parser/src/parser.rs b/crates/rome_js_parser/src/parser.rs
index cc2797abd4b..0489cd9da83 100644
--- a/crates/rome_js_parser/src/parser.rs
+++ b/crates/rome_js_parser/src/parser.rs
@@ -21,7 +21,7 @@ use drop_bomb::DebugDropBomb;
 pub(crate) use parse_error::*;
 pub(crate) use parse_lists::{ParseNodeList, ParseSeparatedList};
 pub(crate) use parsed_syntax::ParsedSyntax;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_syntax::{
     JsSyntaxKind::{self},
     SourceType, TextRange,
@@ -605,7 +605,7 @@ pub struct Checkpoint {
 #[cfg(test)]
 mod tests {
     use crate::Parser;
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_js_syntax::{JsSyntaxKind, SourceType};
     use rome_rowan::AstNode;
 
diff --git a/crates/rome_js_parser/src/parser/parse_error.rs b/crates/rome_js_parser/src/parser/parse_error.rs
index 6f32f726d00..cdd9127abdf 100644
--- a/crates/rome_js_parser/src/parser/parse_error.rs
+++ b/crates/rome_js_parser/src/parser/parse_error.rs
@@ -1,5 +1,5 @@
+use crate::span::Span;
 use crate::{ParseDiagnostic, Parser};
-use rome_diagnostics::Span;
 use rome_js_syntax::{JsSyntaxKind, TextRange};
 use std::ops::Range;
 
diff --git a/crates/rome_js_parser/src/parser/rewrite_parser.rs b/crates/rome_js_parser/src/parser/rewrite_parser.rs
index 2d643f7979e..21e0e33da08 100644
--- a/crates/rome_js_parser/src/parser/rewrite_parser.rs
+++ b/crates/rome_js_parser/src/parser/rewrite_parser.rs
@@ -1,7 +1,7 @@
 use crate::token_source::TokenSourceCheckpoint;
 use crate::{CompletedMarker, Event, Marker, ParseDiagnostic, Parser, TextSize, ToDiagnostic};
 use rome_console::fmt::Display;
-use rome_diagnostics::v2::location::AsSpan;
+use rome_diagnostics::location::AsSpan;
 use rome_js_syntax::{JsSyntaxKind, TextRange};
 
 /// Simplified parser API for when rewriting the AST structure with `rewrite_events`.
diff --git a/crates/rome_js_parser/src/span.rs b/crates/rome_js_parser/src/span.rs
new file mode 100644
index 00000000000..08032a9304a
--- /dev/null
+++ b/crates/rome_js_parser/src/span.rs
@@ -0,0 +1,107 @@
+use rome_rowan::{Language, SyntaxElement, SyntaxNode, SyntaxToken, TextRange, TextSize};
+use std::{fmt::Debug, ops::Range};
+
+/// A value which can be used as the range inside of a diagnostic.
+///
+/// This is essentially a hack to allow us to use SyntaxElement, SyntaxNode, etc directly
+pub trait Span {
+    fn as_range(&self) -> TextRange;
+
+    /// Make a new span which extends to another span
+    ///
+    /// ```text
+    /// from      to
+    /// ^^^^^^^^^^^^
+    /// ```
+    fn join<T: Span>(&self, other: T) -> TextRange {
+        TextRange::new(self.as_range().start(), other.as_range().end())
+    }
+
+    /// Make a new span which is between another span
+    ///
+    /// ```text
+    /// from      to
+    ///     ^^^^^^
+    /// ```
+    fn between<T: Span>(&self, other: T) -> TextRange {
+        TextRange::new(self.as_range().end(), other.as_range().start())
+    }
+
+    /// Make a new span which extends until another span
+    ///
+    /// ```text
+    /// from      to
+    /// ^^^^^^^^^^
+    /// ```
+    fn until<T: Span>(&self, other: T) -> TextRange {
+        TextRange::new(self.as_range().start(), other.as_range().start())
+    }
+
+    fn sub_start(&self, amount: TextSize) -> TextRange {
+        self.as_range().sub_start(amount)
+    }
+
+    fn add_start(&self, amount: TextSize) -> TextRange {
+        self.as_range().add_start(amount)
+    }
+
+    fn sub_end(&self, amount: TextSize) -> TextRange {
+        self.as_range().sub_end(amount)
+    }
+
+    fn add_end(&self, amount: TextSize) -> TextRange {
+        self.as_range().add_end(amount)
+    }
+}
+
+impl<T: Span> Span for &T {
+    fn as_range(&self) -> TextRange {
+        (*self).as_range()
+    }
+}
+
+impl<T: Span> Span for &mut T {
+    fn as_range(&self) -> TextRange {
+        (**self).as_range()
+    }
+}
+
+impl<T: Copy> Span for Range<T>
+where
+    TextSize: TryFrom<T>,
+    <TextSize as TryFrom<T>>::Error: Debug,
+{
+    fn as_range(&self) -> TextRange {
+        TextRange::new(
+            TextSize::try_from(self.start).expect("integer overflow"),
+            TextSize::try_from(self.end).expect("integer overflow"),
+        )
+    }
+}
+
+impl<T: Language> Span for SyntaxNode<T> {
+    fn as_range(&self) -> TextRange {
+        self.text_range()
+    }
+}
+
+impl<T: Language> Span for SyntaxToken<T> {
+    fn as_range(&self) -> TextRange {
+        self.text_range()
+    }
+}
+
+impl<T: Language> Span for SyntaxElement<T> {
+    fn as_range(&self) -> TextRange {
+        match self {
+            SyntaxElement::Node(n) => n.text_range(),
+            SyntaxElement::Token(t) => t.text_range(),
+        }
+    }
+}
+
+impl Span for TextRange {
+    fn as_range(&self) -> TextRange {
+        *self
+    }
+}
diff --git a/crates/rome_js_parser/src/syntax/binding.rs b/crates/rome_js_parser/src/syntax/binding.rs
index 3ec965d35ab..eeec6a00b99 100644
--- a/crates/rome_js_parser/src/syntax/binding.rs
+++ b/crates/rome_js_parser/src/syntax/binding.rs
@@ -1,4 +1,5 @@
 use crate::parser::expected_any;
+use crate::span::Span;
 use crate::syntax::class::parse_initializer_clause;
 use crate::syntax::expr::{is_nth_at_identifier, parse_identifier, ExpressionContext};
 use crate::syntax::js_parse_error::{
@@ -9,7 +10,6 @@ use crate::syntax::pattern::{ParseArrayPattern, ParseObjectPattern, ParseWithDef
 use crate::JsSyntaxFeature::StrictMode;
 use crate::ParsedSyntax::{Absent, Present};
 use crate::{ParseDiagnostic, ParsedSyntax, Parser, SyntaxFeature, ToDiagnostic};
-use rome_diagnostics::Span;
 use rome_js_syntax::{JsSyntaxKind::*, *};
 use rome_rowan::SyntaxKind as SyntaxKindTrait;
 
diff --git a/crates/rome_js_parser/src/syntax/js_parse_error.rs b/crates/rome_js_parser/src/syntax/js_parse_error.rs
index 7f473ea2a19..e96b43dd3a0 100644
--- a/crates/rome_js_parser/src/syntax/js_parse_error.rs
+++ b/crates/rome_js_parser/src/syntax/js_parse_error.rs
@@ -1,6 +1,6 @@
 use crate::parser::{expected_any, expected_node, ToDiagnostic};
+use crate::span::Span;
 use crate::{ParseDiagnostic, Parser};
-use rome_diagnostics::Span;
 use rome_js_syntax::TextRange;
 
 ///! Provides factory function to create common diagnostics for the JavaScript syntax
diff --git a/crates/rome_js_parser/src/syntax/stmt.rs b/crates/rome_js_parser/src/syntax/stmt.rs
index 6bb5a8ca82f..c9b4d5b7f36 100644
--- a/crates/rome_js_parser/src/syntax/stmt.rs
+++ b/crates/rome_js_parser/src/syntax/stmt.rs
@@ -26,13 +26,13 @@ use crate::syntax::js_parse_error::{expected_binding, expected_statement};
 use crate::syntax::module::parse_import_or_import_equals_declaration;
 use crate::syntax::typescript::ts_parse_error::{expected_ts_type, ts_only_syntax_error};
 
+use crate::span::Span;
 use crate::JsSyntaxFeature::{StrictMode, TypeScript};
 use crate::ParsedSyntax::{Absent, Present};
 use crate::{
     parser, CompletedMarker, JsSyntaxFeature, Marker, ParseRecovery, ParseSeparatedList, Parser,
     SyntaxFeature, TokenSet,
 };
-use rome_diagnostics::Span;
 use rome_js_syntax::{JsSyntaxKind::*, *};
 use rome_rowan::SyntaxKind;
 
diff --git a/crates/rome_js_parser/src/syntax/typescript/ts_parse_error.rs b/crates/rome_js_parser/src/syntax/typescript/ts_parse_error.rs
index 024a5dc5196..1faeb310e9c 100644
--- a/crates/rome_js_parser/src/syntax/typescript/ts_parse_error.rs
+++ b/crates/rome_js_parser/src/syntax/typescript/ts_parse_error.rs
@@ -3,7 +3,7 @@ use crate::{
     parser::{expected_any, ToDiagnostic},
     CompletedMarker, ParseDiagnostic, Parser,
 };
-use rome_diagnostics::v2::location::AsSpan;
+use rome_diagnostics::location::AsSpan;
 use rome_rowan::TextRange;
 
 pub(crate) fn expected_ts_enum_member(p: &Parser, range: TextRange) -> ParseDiagnostic {
diff --git a/crates/rome_js_parser/src/syntax/typescript/types.rs b/crates/rome_js_parser/src/syntax/typescript/types.rs
index 756cb498614..97fd49db457 100644
--- a/crates/rome_js_parser/src/syntax/typescript/types.rs
+++ b/crates/rome_js_parser/src/syntax/typescript/types.rs
@@ -21,12 +21,12 @@ use crate::syntax::typescript::try_parse;
 use crate::syntax::typescript::ts_parse_error::{expected_ts_type, expected_ts_type_parameter};
 
 use crate::lexer::{LexContext, ReLexContext};
+use crate::span::Span;
 use crate::JsSyntaxFeature::TypeScript;
 use crate::{
     Absent, CompletedMarker, ParseNodeList, ParseRecovery, ParseSeparatedList, ParsedSyntax,
     Parser, Present, SyntaxFeature,
 };
-use rome_diagnostics::Span;
 use rome_js_syntax::JsSyntaxKind::TS_TYPE_ANNOTATION;
 use rome_js_syntax::T;
 use rome_js_syntax::{JsSyntaxKind::*, *};
diff --git a/crates/rome_js_parser/src/test_utils.rs b/crates/rome_js_parser/src/test_utils.rs
index 2a6a23e61da..5cf3f2993f3 100644
--- a/crates/rome_js_parser/src/test_utils.rs
+++ b/crates/rome_js_parser/src/test_utils.rs
@@ -1,6 +1,6 @@
 use rome_console::fmt::{Formatter, Termcolor};
-use rome_diagnostics::v2::DiagnosticExt;
-use rome_diagnostics::{termcolor::Buffer, v2::PrintDiagnostic};
+use rome_diagnostics::DiagnosticExt;
+use rome_diagnostics::{termcolor::Buffer, PrintDiagnostic};
 use rome_js_syntax::{JsLanguage, JsSyntaxNode};
 use rome_rowan::{AstNode, SyntaxKind, SyntaxSlot};
 use std::{fmt::Debug, path::Path};
diff --git a/crates/rome_js_parser/src/tests.rs b/crates/rome_js_parser/src/tests.rs
index ef172b84d6d..40c47f0ae18 100644
--- a/crates/rome_js_parser/src/tests.rs
+++ b/crates/rome_js_parser/src/tests.rs
@@ -1,9 +1,9 @@
 use crate::{markup, parse, parse_module, test_utils::assert_errors_are_absent, Parse};
 use expect_test::expect_file;
 use rome_console::fmt::{Formatter, Termcolor};
-use rome_diagnostics::file::FileId;
-use rome_diagnostics::v2::DiagnosticExt;
-use rome_diagnostics::{file::SimpleFiles, v2::PrintDiagnostic};
+use rome_diagnostics::location::FileId;
+use rome_diagnostics::DiagnosticExt;
+use rome_diagnostics::PrintDiagnostic;
 use rome_js_syntax::{JsAnyRoot, JsSyntaxKind, SourceType};
 use rome_js_syntax::{JsCallArguments, JsLogicalExpression, JsSyntaxToken};
 use rome_rowan::{AstNode, Direction, TextSize};
@@ -116,11 +116,6 @@ fn run_and_expect_errors(path: &str, _: &str, _: &str, _: &str) {
 
     let (parse, ast) = try_parse_with_printed_ast(path.to_str().unwrap(), &text);
     assert_errors_are_present(&parse, &path);
-    let mut files = SimpleFiles::new();
-    files.add(
-        path.file_name().unwrap().to_string_lossy().to_string(),
-        text.to_string(),
-    );
     let mut actual = format!("{}\n\n{:#?}", ast, parse.syntax());
     for diag in parse.diagnostics() {
         let mut write = rome_diagnostics::termcolor::Buffer::no_color();
diff --git a/crates/rome_js_parser/src/token_source.rs b/crates/rome_js_parser/src/token_source.rs
index 105ab154f75..cbb24294918 100644
--- a/crates/rome_js_parser/src/token_source.rs
+++ b/crates/rome_js_parser/src/token_source.rs
@@ -1,6 +1,6 @@
 use crate::lexer::{BufferedLexer, LexContext, Lexer, LexerCheckpoint, ReLexContext, TextRange};
 use crate::ParseDiagnostic;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_syntax::JsSyntaxKind;
 use rome_js_syntax::JsSyntaxKind::EOF;
 use rome_rowan::{TextSize, TriviaPieceKind};
diff --git a/crates/rome_js_semantic/src/events.rs b/crates/rome_js_semantic/src/events.rs
index 79603afdccb..5b90ce1aada 100644
--- a/crates/rome_js_semantic/src/events.rs
+++ b/crates/rome_js_semantic/src/events.rs
@@ -139,7 +139,7 @@ impl SemanticEvent {
 /// use rome_js_parser::*;
 /// use rome_js_syntax::*;
 /// use rome_js_semantic::*;
-/// use rome_diagnostics::file::FileId;
+/// use rome_diagnostics::location::FileId;
 /// let tree = parse("let a = 1", FileId::zero(), SourceType::js_script());
 /// let mut extractor = SemanticEventExtractor::new();
 /// for e in tree.syntax().preorder() {
@@ -1004,7 +1004,7 @@ impl Iterator for SemanticEventIterator {
 /// use rome_js_parser::*;
 /// use rome_js_syntax::*;
 /// use rome_js_semantic::*;
-/// use rome_diagnostics::file::FileId;
+/// use rome_diagnostics::location::FileId;
 /// let tree = parse("let a = 1", FileId::zero(), SourceType::js_script());
 /// for e in semantic_events(tree.syntax()) {
 ///     dbg!(e);
diff --git a/crates/rome_js_semantic/src/semantic_model.rs b/crates/rome_js_semantic/src/semantic_model.rs
index 5e4242c4d88..492776bdb66 100644
--- a/crates/rome_js_semantic/src/semantic_model.rs
+++ b/crates/rome_js_semantic/src/semantic_model.rs
@@ -616,7 +616,7 @@ impl SemanticModel {
     /// use rome_rowan::{AstNode, SyntaxNodeCast};
     /// use rome_js_syntax::{SourceType, JsReferenceIdentifier};
     /// use rome_js_semantic::{semantic_model, SemanticModelOptions, SemanticScopeExtensions};
-    /// use rome_diagnostics::file::FileId;
+    /// use rome_diagnostics::location::FileId;
     ///
     /// let r = rome_js_parser::parse("function f(){let a = arguments[0]; let b = a + 1;}", FileId::zero(), SourceType::js_module());
     /// let model = semantic_model(&r.tree(), SemanticModelOptions::default());
@@ -659,7 +659,7 @@ impl SemanticModel {
     /// use rome_rowan::{AstNode, SyntaxNodeCast};
     /// use rome_js_syntax::{SourceType, JsReferenceIdentifier};
     /// use rome_js_semantic::{semantic_model, DeclarationExtensions, SemanticModelOptions};
-    /// use rome_diagnostics::file::FileId;
+    /// use rome_diagnostics::location::FileId;
     ///
     /// let r = rome_js_parser::parse("function f(){let a = arguments[0]; let b = a + 1;}", FileId::zero(), SourceType::js_module());
     /// let model = semantic_model(&r.tree(), SemanticModelOptions::default());
@@ -693,7 +693,7 @@ impl SemanticModel {
     /// use rome_rowan::{AstNode, SyntaxNodeCast};
     /// use rome_js_syntax::{SourceType, JsIdentifierBinding};
     /// use rome_js_semantic::{semantic_model, AllReferencesExtensions, SemanticModelOptions};
-    /// use rome_diagnostics::file::FileId;
+    /// use rome_diagnostics::location::FileId;
     ///
     /// let r = rome_js_parser::parse("function f(){let a = arguments[0]; let b = a + 1;}", FileId::zero(), SourceType::js_module());
     /// let model = semantic_model(&r.tree(), SemanticModelOptions::default());
@@ -1147,7 +1147,7 @@ pub fn semantic_model(root: &JsAnyRoot, options: SemanticModelOptions) -> Semant
 #[cfg(test)]
 mod test {
     use super::*;
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_js_syntax::{JsReferenceIdentifier, JsSyntaxKind, SourceType, TsIdentifierBinding};
     use rome_rowan::SyntaxNodeCast;
 
diff --git a/crates/rome_js_semantic/src/semantic_model/closure.rs b/crates/rome_js_semantic/src/semantic_model/closure.rs
index e58e7c18f75..2441f4d1002 100644
--- a/crates/rome_js_semantic/src/semantic_model/closure.rs
+++ b/crates/rome_js_semantic/src/semantic_model/closure.rs
@@ -353,7 +353,7 @@ impl Closure {
 #[cfg(test)]
 mod test {
     use super::*;
-    use rome_diagnostics::file::FileId;
+    use rome_diagnostics::location::FileId;
     use rome_js_syntax::{JsArrowFunctionExpression, JsSyntaxKind, SourceType};
     use rome_rowan::SyntaxNodeCast;
 
diff --git a/crates/rome_js_semantic/src/semantic_model/is_constant.rs b/crates/rome_js_semantic/src/semantic_model/is_constant.rs
index acb5628964c..a7bfb4e3788 100644
--- a/crates/rome_js_semantic/src/semantic_model/is_constant.rs
+++ b/crates/rome_js_semantic/src/semantic_model/is_constant.rs
@@ -12,7 +12,7 @@ pub fn is_constant(expr: &JsAnyExpression) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use rome_diagnostics::v2::FileId;
+    use rome_diagnostics::FileId;
     use rome_js_syntax::{JsIdentifierBinding, JsVariableDeclarator, SourceType};
 
     use crate::{semantic_model, SemanticModelOptions};
diff --git a/crates/rome_js_semantic/src/tests/assertions.rs b/crates/rome_js_semantic/src/tests/assertions.rs
index e1a8e6969ad..a63360394b9 100644
--- a/crates/rome_js_semantic/src/tests/assertions.rs
+++ b/crates/rome_js_semantic/src/tests/assertions.rs
@@ -1,8 +1,8 @@
 use crate::{semantic_events, SemanticEvent};
 use rome_console::{markup, ConsoleExt, EnvConsole};
-use rome_diagnostics::file::FileId;
-use rome_diagnostics::v2::location::AsSpan;
-use rome_diagnostics::v2::{
+use rome_diagnostics::location::AsSpan;
+use rome_diagnostics::location::FileId;
+use rome_diagnostics::{
     Advices, Diagnostic, DiagnosticExt, Location, LogCategory, PrintDiagnostic, Visit,
 };
 use rome_js_syntax::{JsAnyRoot, JsSyntaxToken, SourceType, TextRange, TextSize, WalkEvent};
diff --git a/crates/rome_lsp/src/session.rs b/crates/rome_lsp/src/session.rs
index ad4106c8e2e..826839ebb58 100644
--- a/crates/rome_lsp/src/session.rs
+++ b/crates/rome_lsp/src/session.rs
@@ -7,7 +7,7 @@ use futures::stream::futures_unordered::FuturesUnordered;
 use futures::StreamExt;
 use rome_analyze::RuleCategories;
 use rome_console::markup;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_fs::{FileSystem, OsFileSystem, RomePath};
 use rome_service::configuration::Configuration;
 use rome_service::workspace::{FeatureName, PullDiagnosticsParams, SupportsFeatureParams};
diff --git a/crates/rome_lsp/src/url_interner.rs b/crates/rome_lsp/src/url_interner.rs
index 90199a688fe..8a39b26412c 100644
--- a/crates/rome_lsp/src/url_interner.rs
+++ b/crates/rome_lsp/src/url_interner.rs
@@ -3,7 +3,7 @@
 //! Based on `path_interner` from `rust-analyzer`
 
 use indexmap::IndexSet;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use tower_lsp::lsp_types::Url;
 
 /// Structure to map between [`Url`] and [`FileId`].
diff --git a/crates/rome_lsp/src/utils.rs b/crates/rome_lsp/src/utils.rs
index da771f0624f..e960727d0fd 100644
--- a/crates/rome_lsp/src/utils.rs
+++ b/crates/rome_lsp/src/utils.rs
@@ -11,8 +11,7 @@ use rome_console::fmt::{self, Formatter};
 use rome_console::MarkupBuf;
 use rome_diagnostics::termcolor::NoColor;
 use rome_diagnostics::{
-    v2::{Diagnostic, DiagnosticTags, Location, PrintDescription, Severity, Visit},
-    Applicability,
+    Applicability, {Diagnostic, DiagnosticTags, Location, PrintDescription, Severity, Visit},
 };
 use rome_rowan::{TextRange, TextSize};
 use rome_service::workspace::CodeAction;
diff --git a/crates/rome_lsp/tests/server.rs b/crates/rome_lsp/tests/server.rs
index 7ffd30576e1..ae571212fef 100644
--- a/crates/rome_lsp/tests/server.rs
+++ b/crates/rome_lsp/tests/server.rs
@@ -7,7 +7,7 @@ use futures::Sink;
 use futures::SinkExt;
 use futures::Stream;
 use futures::StreamExt;
-use rome_diagnostics::v2::FileId;
+use rome_diagnostics::FileId;
 use rome_fs::RomePath;
 use rome_lsp::LSPServer;
 use rome_lsp::ServerFactory;
diff --git a/crates/rome_service/src/configuration/linter/mod.rs b/crates/rome_service/src/configuration/linter/mod.rs
index 3b2b91a25c8..3f492db2ed4 100644
--- a/crates/rome_service/src/configuration/linter/mod.rs
+++ b/crates/rome_service/src/configuration/linter/mod.rs
@@ -5,7 +5,7 @@ pub use crate::configuration::linter::rules::Rules;
 use crate::settings::LinterSettings;
 use crate::{ConfigurationError, MatchOptions, Matcher, RomeError};
 use indexmap::IndexSet;
-use rome_diagnostics::v2::Severity;
+use rome_diagnostics::Severity;
 pub use rules::*;
 #[cfg(feature = "schemars")]
 use schemars::{gen::SchemaGenerator, schema::Schema, JsonSchema};
diff --git a/crates/rome_service/src/configuration/linter/rules.rs b/crates/rome_service/src/configuration/linter/rules.rs
index 70fd51d4c8c..c0324218607 100644
--- a/crates/rome_service/src/configuration/linter/rules.rs
+++ b/crates/rome_service/src/configuration/linter/rules.rs
@@ -3,7 +3,7 @@
 use crate::{ConfigurationError, RomeError, RuleConfiguration};
 use indexmap::{IndexMap, IndexSet};
 use rome_analyze::RuleFilter;
-use rome_diagnostics::v2::{Category, Severity};
+use rome_diagnostics::{Category, Severity};
 #[cfg(feature = "schemars")]
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
diff --git a/crates/rome_service/src/file_handlers/javascript.rs b/crates/rome_service/src/file_handlers/javascript.rs
index f2fd4443d5d..464847ebcbb 100644
--- a/crates/rome_service/src/file_handlers/javascript.rs
+++ b/crates/rome_service/src/file_handlers/javascript.rs
@@ -10,7 +10,7 @@ use rome_analyze::{
     AnalysisFilter, AnalyzerOptions, ControlFlow, GroupCategory, Never, QueryMatch,
     RegistryVisitor, RuleCategories, RuleCategory, RuleFilter, RuleGroup,
 };
-use rome_diagnostics::{v2::category, Applicability, CodeSuggestion};
+use rome_diagnostics::{category, Applicability, CodeSuggestion, Severity};
 use rome_formatter::{FormatError, Printed};
 use rome_fs::RomePath;
 use rome_js_analyze::{analyze, analyze_with_inspect_matcher, visit_registry, RuleError};
@@ -32,7 +32,7 @@ use super::{
 use crate::configuration::to_analyzer_configuration;
 use crate::file_handlers::{FixAllParams, Language as LanguageId};
 use indexmap::IndexSet;
-use rome_diagnostics::{v2, v2::Diagnostic};
+use rome_diagnostics::Diagnostic;
 use rome_js_analyze::utils::rename::{RenameError, RenameSymbolExtensions};
 use std::borrow::Cow;
 use std::fmt::Debug;
@@ -223,7 +223,7 @@ fn lint(params: LintParams) -> LintResults {
     let mut diagnostic_count = diagnostics.len() as u64;
     let mut errors = diagnostics
         .iter()
-        .filter(|diag| diag.severity() <= v2::Severity::Error)
+        .filter(|diag| diag.severity() <= Severity::Error)
         .count();
 
     let has_lint = params.filter.categories.contains(RuleCategories::LINT);
@@ -243,9 +243,9 @@ fn lint(params: LintParams) -> LintResults {
                 .category()
                 .filter(|category| category.name().starts_with("lint/"))
                 .and_then(|category| params.rules.as_ref()?.get_severity_from_code(category))
-                .unwrap_or(v2::Severity::Error);
+                .unwrap_or(Severity::Error);
 
-            if severity <= v2::Severity::Error {
+            if severity <= Severity::Error {
                 errors += 1;
             }
 
@@ -256,7 +256,7 @@ fn lint(params: LintParams) -> LintResults {
                     diagnostic.add_code_suggestion(action.into());
                 }
 
-                diagnostics.push(v2::serde::Diagnostic::new(diagnostic));
+                diagnostics.push(rome_diagnostics::serde::Diagnostic::new(diagnostic));
             }
         }
 
diff --git a/crates/rome_service/src/file_handlers/mod.rs b/crates/rome_service/src/file_handlers/mod.rs
index ff7fcaa68df..8e5a094ad1a 100644
--- a/crates/rome_service/src/file_handlers/mod.rs
+++ b/crates/rome_service/src/file_handlers/mod.rs
@@ -167,7 +167,7 @@ pub(crate) struct LintParams<'a> {
 }
 
 pub(crate) struct LintResults {
-    pub(crate) diagnostics: Vec<rome_diagnostics::v2::serde::Diagnostic>,
+    pub(crate) diagnostics: Vec<rome_diagnostics::serde::Diagnostic>,
     pub(crate) errors: usize,
     pub(crate) skipped_diagnostics: u64,
 }
diff --git a/crates/rome_service/src/settings.rs b/crates/rome_service/src/settings.rs
index cf829a473c4..9a472de4c3d 100644
--- a/crates/rome_service/src/settings.rs
+++ b/crates/rome_service/src/settings.rs
@@ -3,7 +3,7 @@ use crate::{
     RomeError, Rules,
 };
 use indexmap::IndexSet;
-use rome_diagnostics::v2::Category;
+use rome_diagnostics::Category;
 use rome_formatter::{IndentStyle, LineWidth};
 use rome_fs::RomePath;
 use rome_js_syntax::JsLanguage;
@@ -81,7 +81,7 @@ impl WorkspaceSettings {
     pub fn get_severity_from_rule_code(
         &self,
         code: &Category,
-    ) -> Option<rome_diagnostics::v2::Severity> {
+    ) -> Option<rome_diagnostics::Severity> {
         let rules = self.linter.rules.as_ref();
         if let Some(rules) = rules {
             rules.get_severity_from_code(code)
diff --git a/crates/rome_service/src/workspace.rs b/crates/rome_service/src/workspace.rs
index 20fe1aa6910..50afeeac44a 100644
--- a/crates/rome_service/src/workspace.rs
+++ b/crates/rome_service/src/workspace.rs
@@ -55,7 +55,7 @@ use crate::{Configuration, Deserialize, RomeError, Serialize};
 use rome_analyze::ActionCategory;
 pub use rome_analyze::RuleCategories;
 use rome_console::{markup, Markup, MarkupBuf};
-use rome_diagnostics::{v2, CodeSuggestion};
+use rome_diagnostics::CodeSuggestion;
 use rome_formatter::Printed;
 use rome_fs::RomePath;
 use rome_js_syntax::{TextRange, TextSize};
@@ -183,7 +183,7 @@ pub struct PullDiagnosticsParams {
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct PullDiagnosticsResult {
-    pub diagnostics: Vec<v2::serde::Diagnostic>,
+    pub diagnostics: Vec<rome_diagnostics::serde::Diagnostic>,
     pub errors: usize,
     pub skipped_diagnostics: u64,
 }
diff --git a/crates/rome_service/src/workspace/server.rs b/crates/rome_service/src/workspace/server.rs
index 525ee8905fd..3cea4698c66 100644
--- a/crates/rome_service/src/workspace/server.rs
+++ b/crates/rome_service/src/workspace/server.rs
@@ -15,7 +15,7 @@ use crate::{
 use dashmap::{mapref::entry::Entry, DashMap};
 use indexmap::IndexSet;
 use rome_analyze::{AnalysisFilter, RuleFilter};
-use rome_diagnostics::v2::{serde::Diagnostic, DiagnosticExt};
+use rome_diagnostics::{serde::Diagnostic, DiagnosticExt};
 use rome_formatter::Printed;
 use rome_fs::RomePath;
 use rome_js_parser::ParseDiagnostic;
diff --git a/crates/rome_wasm/src/utils.rs b/crates/rome_wasm/src/utils.rs
index a5f170c5eb1..99aaabd2d6d 100644
--- a/crates/rome_wasm/src/utils.rs
+++ b/crates/rome_wasm/src/utils.rs
@@ -5,9 +5,8 @@ use wasm_bindgen::prelude::*;
 
 use rome_console::fmt::HTML;
 use rome_console::{fmt::Formatter, markup};
-use rome_diagnostics::file::SimpleFile;
-use rome_diagnostics::v2::serde::Diagnostic;
-use rome_diagnostics::v2::{DiagnosticExt, PrintDiagnostic};
+use rome_diagnostics::serde::Diagnostic;
+use rome_diagnostics::{DiagnosticExt, LineIndexBuf, PrintDiagnostic, SourceCode};
 
 use super::IDiagnostic;
 
@@ -24,7 +23,8 @@ pub(crate) fn set_panic_hook() {
 
 #[wasm_bindgen]
 pub struct DiagnosticPrinter {
-    file: SimpleFile,
+    file_name: String,
+    file_source: SourceCode<String, LineIndexBuf>,
     buffer: Vec<u8>,
 }
 
@@ -32,15 +32,22 @@ pub struct DiagnosticPrinter {
 impl DiagnosticPrinter {
     #[wasm_bindgen(constructor)]
     pub fn new(file_name: String, file_source: String) -> Self {
+        let line_starts = LineIndexBuf::from_source_text(&file_source);
         Self {
-            file: SimpleFile::new(file_name, file_source),
+            file_name,
+            file_source: SourceCode {
+                text: file_source,
+                line_starts: Some(line_starts),
+            },
             buffer: Vec::new(),
         }
     }
 
     pub fn print(&mut self, diagnostic: IDiagnostic) -> Result<(), Error> {
         let diag: Diagnostic = diagnostic.into_serde().map_err(into_error)?;
-        let err = diag.with_file_source_code(self.file.source_code());
+        let err = diag
+            .with_file_path(&self.file_name)
+            .with_file_source_code(&self.file_source);
 
         let mut html = HTML(&mut self.buffer);
         Formatter::new(&mut html)
diff --git a/xtask/bench/src/features/analyzer.rs b/xtask/bench/src/features/analyzer.rs
index 61803b84119..907a14d0f9b 100644
--- a/xtask/bench/src/features/analyzer.rs
+++ b/xtask/bench/src/features/analyzer.rs
@@ -1,7 +1,7 @@
 use crate::BenchmarkSummary;
 use criterion::black_box;
 use rome_analyze::{AnalysisFilter, AnalyzerOptions, ControlFlow, Never, RuleCategories};
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_analyze::analyze;
 use rome_js_syntax::JsAnyRoot;
 use std::fmt::{Display, Formatter};
diff --git a/xtask/bench/src/features/parser.rs b/xtask/bench/src/features/parser.rs
index c51d40e62c2..aefc4d6c354 100644
--- a/xtask/bench/src/features/parser.rs
+++ b/xtask/bench/src/features/parser.rs
@@ -2,12 +2,12 @@
 use crate::features::print_diff;
 use crate::BenchmarkSummary;
 use itertools::Itertools;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::console::fmt::Termcolor;
+use rome_diagnostics::console::markup;
+use rome_diagnostics::location::FileId;
 use rome_diagnostics::termcolor::Buffer;
-use rome_diagnostics::v2::console::fmt::Termcolor;
-use rome_diagnostics::v2::console::markup;
-use rome_diagnostics::v2::DiagnosticExt;
-use rome_diagnostics::v2::PrintDiagnostic;
+use rome_diagnostics::DiagnosticExt;
+use rome_diagnostics::PrintDiagnostic;
 use rome_js_parser::{parse_common, Parse, ParseDiagnostic};
 use rome_js_syntax::{JsAnyRoot, SourceType};
 use std::fmt::{Display, Formatter};
@@ -91,7 +91,7 @@ impl Display for ParseMeasurement {
         let diagnostics = &self
             .diagnostics
             .iter()
-            .map(|diagnostic| rome_diagnostics::v2::Error::from(diagnostic.clone()))
+            .map(|diagnostic| rome_diagnostics::Error::from(diagnostic.clone()))
             .group_by(|x| x.severity());
         for (severity, items) in diagnostics {
             let _ = writeln!(f, "\t\t{:?}: {}", severity, items.count());
@@ -104,7 +104,7 @@ impl Display for ParseMeasurement {
                 .clone()
                 .with_file_path(self.id.to_string())
                 .with_file_source_code(self.code.clone());
-            rome_diagnostics::v2::console::fmt::Formatter::new(&mut Termcolor(&mut buffer))
+            rome_diagnostics::console::fmt::Formatter::new(&mut Termcolor(&mut buffer))
                 .write_markup(markup! {
                     {PrintDiagnostic(&error)}
                 })
diff --git a/xtask/bench/src/lib.rs b/xtask/bench/src/lib.rs
index 149ab2d4bad..e6f51fe044c 100644
--- a/xtask/bench/src/lib.rs
+++ b/xtask/bench/src/lib.rs
@@ -1,7 +1,7 @@
 mod features;
 mod utils;
 
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_parser::parse;
 use rome_js_syntax::SourceType;
 use std::collections::HashMap;
diff --git a/xtask/codegen/src/generate_configuration.rs b/xtask/codegen/src/generate_configuration.rs
index 95b41fba2d5..d4232841d76 100644
--- a/xtask/codegen/src/generate_configuration.rs
+++ b/xtask/codegen/src/generate_configuration.rs
@@ -242,7 +242,7 @@ pub(crate) fn generate_rules_configuration(mode: Mode) -> Result<()> {
         use crate::{ConfigurationError, RomeError, RuleConfiguration};
         use rome_analyze::RuleFilter;
         use indexmap::{IndexMap, IndexSet};
-        use rome_diagnostics::v2::{Category, Severity};
+        use rome_diagnostics::{Category, Severity};
 
         #[derive(Deserialize, Serialize, Debug, Clone)]
         #[cfg_attr(feature = "schemars", derive(JsonSchema))]
diff --git a/xtask/coverage/src/js/test262.rs b/xtask/coverage/src/js/test262.rs
index d39b77161eb..f101985bcac 100644
--- a/xtask/coverage/src/js/test262.rs
+++ b/xtask/coverage/src/js/test262.rs
@@ -2,7 +2,7 @@ use crate::runner::{
     create_unknown_node_in_tree_diagnostic, TestCase, TestCaseFiles, TestRunOutcome, TestSuite,
 };
 use regex::Regex;
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_parser::parse;
 use rome_js_syntax::SourceType;
 use rome_rowan::syntax::SyntaxKind;
diff --git a/xtask/coverage/src/jsx/jsx_babel.rs b/xtask/coverage/src/jsx/jsx_babel.rs
index 60ff76c5387..a1c36bc86f6 100644
--- a/xtask/coverage/src/jsx/jsx_babel.rs
+++ b/xtask/coverage/src/jsx/jsx_babel.rs
@@ -3,7 +3,7 @@ use crate::{
     check_file_encoding,
     runner::{TestCase, TestCaseFiles, TestRunOutcome, TestSuite},
 };
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_parser::parse;
 use rome_js_syntax::{ModuleKind, SourceType};
 use rome_rowan::SyntaxKind;
diff --git a/xtask/coverage/src/reporters.rs b/xtask/coverage/src/reporters.rs
index 004fa8d7026..072f9aa749a 100644
--- a/xtask/coverage/src/reporters.rs
+++ b/xtask/coverage/src/reporters.rs
@@ -5,7 +5,7 @@ use atty::Stream;
 use colored::Colorize;
 use indicatif::ProgressBar;
 use rome_diagnostics::termcolor::Buffer;
-use rome_diagnostics::v2::{DiagnosticExt, Error};
+use rome_diagnostics::{DiagnosticExt, Error};
 use serde_json::Value;
 use std::collections::HashMap;
 use std::io::Write;
diff --git a/xtask/coverage/src/runner.rs b/xtask/coverage/src/runner.rs
index 7bff9c1eb45..019db627b1a 100644
--- a/xtask/coverage/src/runner.rs
+++ b/xtask/coverage/src/runner.rs
@@ -1,11 +1,10 @@
 use super::*;
 use crate::reporters::TestReporter;
-use rome_diagnostics::file::{FileId, SimpleFiles};
+use rome_diagnostics::console::fmt::{Formatter, Termcolor};
+use rome_diagnostics::console::markup;
 use rome_diagnostics::termcolor::Buffer;
-use rome_diagnostics::v2::console::fmt::{Formatter, Termcolor};
-use rome_diagnostics::v2::console::markup;
-use rome_diagnostics::v2::Error;
-use rome_diagnostics::v2::PrintDiagnostic;
+use rome_diagnostics::PrintDiagnostic;
+use rome_diagnostics::{Error, FileId};
 use rome_js_parser::{parse, Parse};
 use rome_js_syntax::{JsAnyRoot, JsSyntaxNode, SourceType};
 use rome_rowan::SyntaxKind;
@@ -149,12 +148,6 @@ impl TestCaseFiles {
     }
 
     pub(crate) fn emit_errors(&self, errors: &[Error], buffer: &mut Buffer) {
-        let mut diag_files = SimpleFiles::new();
-
-        for file in &self.files {
-            diag_files.add(file.name.clone(), file.code.clone());
-        }
-
         for error in errors {
             if let Err(err) = Formatter::new(&mut Termcolor(&mut *buffer)).write_markup(markup! {
                 {PrintDiagnostic(error)}
@@ -174,18 +167,6 @@ impl<'a> IntoIterator for &'a TestCaseFiles {
     }
 }
 
-impl From<TestCaseFiles> for SimpleFiles {
-    fn from(files: TestCaseFiles) -> Self {
-        let mut result = SimpleFiles::new();
-
-        for file in files.files {
-            result.add(file.name, file.code);
-        }
-
-        result
-    }
-}
-
 pub(crate) trait TestCase: RefUnwindSafe + Send + Sync {
     /// Returns the (display) name of the test case. Used to uniquely identify the test case
     fn name(&self) -> &str;
diff --git a/xtask/coverage/src/symbols/msts.rs b/xtask/coverage/src/symbols/msts.rs
index f4ce2e66474..b223187a2ef 100644
--- a/xtask/coverage/src/symbols/msts.rs
+++ b/xtask/coverage/src/symbols/msts.rs
@@ -1,4 +1,4 @@
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_semantic::SemanticEvent;
 use rome_js_syntax::SourceType;
 
diff --git a/xtask/coverage/src/ts/ts_babel.rs b/xtask/coverage/src/ts/ts_babel.rs
index 3ffae808c9c..fccff180d52 100644
--- a/xtask/coverage/src/ts/ts_babel.rs
+++ b/xtask/coverage/src/ts/ts_babel.rs
@@ -3,7 +3,7 @@ use crate::{
     check_file_encoding,
     runner::{TestCase, TestCaseFiles, TestRunOutcome, TestSuite},
 };
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_js_syntax::{LanguageVariant, SourceType};
 use rome_rowan::SyntaxKind;
 use std::path::Path;
diff --git a/xtask/lintdoc/src/main.rs b/xtask/lintdoc/src/main.rs
index 48d3fe92fdb..ad2e1c607f8 100644
--- a/xtask/lintdoc/src/main.rs
+++ b/xtask/lintdoc/src/main.rs
@@ -8,9 +8,9 @@ use rome_console::{
     fmt::{Formatter, HTML},
     markup, Console, Markup, MarkupBuf,
 };
-use rome_diagnostics::file::FileId;
+use rome_diagnostics::location::FileId;
 use rome_diagnostics::termcolor::NoColor;
-use rome_diagnostics::v2::{Diagnostic, DiagnosticExt, PrintDiagnostic};
+use rome_diagnostics::{Diagnostic, DiagnosticExt, PrintDiagnostic};
 use rome_js_analyze::{analyze, visit_registry};
 use rome_js_syntax::{JsLanguage, Language, LanguageVariant, ModuleKind, SourceType};
 use rome_service::settings::WorkspaceSettings;
@@ -463,7 +463,7 @@ fn assert_lint(
 
     let mut all_diagnostics = vec![];
 
-    let mut write_diagnostic = |code: &str, diag: rome_diagnostics::v2::Error| {
+    let mut write_diagnostic = |code: &str, diag: rome_diagnostics::Error| {
         let category = diag.category().map_or("", |code| code.name());
         Formatter::new(&mut write).write_markup(markup! {
             {PrintDiagnostic(&diag)}