Convert MDX errors into issues

Cargo.toml

@@ -110,6 +110,7 @@ async-recursion = "1.0.2"
 # Keep consistent with preset_env_base through swc_core
 browserslist-rs = { version = "0.16.0" }
 miette = { version = "5.10.0", features = ["fancy"] }
+markdown = "1.0.0-alpha.18"
 mdxjs = "0.2.5"
 modularize_imports = { version = "0.68.7" }
 styled_components = { version = "0.96.6" }

crates/turbopack-core/src/issue/mod.rs

@@ -431,6 +431,7 @@ pub struct IssueSource {
  range: Option<Vc<SourceRange>>,
 }
 
+/// The end position is the first character after the range
 #[turbo_tasks::value]
 #[derive(Clone, Debug)]
 enum SourceRange {

crates/turbopack-mdx/Cargo.toml

@@ -16,6 +16,7 @@ workspace = true
 anyhow = { workspace = true }
 serde = { workspace = true }
 
+markdown = { workspace = true }
 mdxjs = { workspace = true }
 
 turbo-tasks = { workspace = true }

crates/turbopack-mdx/src/lib.rs

@@ -1,15 +1,19 @@
 #![feature(min_specialization)]
 #![feature(arbitrary_self_types)]
 
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use mdxjs::{compile, MdxParseOptions, Options};
 use turbo_tasks::{RcStr, ValueDefault, Vc};
-use turbo_tasks_fs::{rope::Rope, File, FileContent};
+use turbo_tasks_fs::{rope::Rope, File, FileContent, FileSystemPath};
 use turbopack_core::{
  asset::{Asset, AssetContent},
  ident::AssetIdent,
- issue::IssueDescriptionExt,
+ issue::{
+ Issue, IssueDescriptionExt, IssueExt, IssueSource, IssueStage, OptionIssueSource,
+ OptionStyledString, StyledString,
+ },
  source::Source,
+ source_pos::SourcePos,
  source_transform::SourceTransform,
 };
 
@@ -175,14 +179,56 @@ impl MdxTransformedAsset {
  ..Default::default()
  };
 
- // TODO: upstream mdx currently bubbles error as string
- let mdx_jsx_component =
- compile(&file.content().to_str()?, &options).map_err(|e| anyhow!("{}", e))?;
+ let result = compile(&file.content().to_str()?, &options);
 
- Ok(MdxTransformResult {
- content: AssetContent::file(File::from(Rope::from(mdx_jsx_component)).into()),
+ match result {
+ Ok(mdx_jsx_component) => Ok(MdxTransformResult {
+ content: AssetContent::file(File::from(Rope::from(mdx_jsx_component)).into()),
+ }
+ .cell()),
+ Err(err) => {
+ let loc = Vc::cell(err.place.map(|p| {
+ let (start, end) = match *p {
+ // markdown's positions are 1-indexed, SourcePos is 0-indexed.
+ // Both end positions point to the first character after the range
+ markdown::message::Place::Position(p) => (
+ SourcePos {
+ line: p.start.line - 1,
+ column: p.start.column - 1,
+ },
+ SourcePos {
+ line: p.end.line - 1,
+ column: p.end.column - 1,
+ },
+ ),
+ markdown::message::Place::Point(p) => {
+ let p = SourcePos {
+ line: p.line - 1,
+ column: p.column - 1,
+ };
+ (p, p)
+ }
+ };
+
+ IssueSource::from_line_col(this.source, start, end)
+ }));
+
+ MdxIssue {
+ path: this.source.ident().path(),
+ loc,
+ reason: err.reason,
+ mdx_rule_id: *err.rule_id,
+ mdx_source: *err.source,
+ }
+ .cell()
+ .emit();
+
+ Ok(MdxTransformResult {
+ content: AssetContent::File(FileContent::NotFound.cell()).cell(),
+ }
+ .cell())
+ }
  }
- .cell())
  }
 }
 
@@ -191,6 +237,47 @@ struct MdxTransformResult {
  content: Vc<AssetContent>,
 }
 
+#[turbo_tasks::value]
+struct MdxIssue {
+ /// Place of message.
+ path: Vc<FileSystemPath>,
+ loc: Vc<OptionIssueSource>,
+ /// Reason for message (should use markdown).
+ reason: String,
+ /// Category of message.
+ mdx_rule_id: String,
+ /// Namespace of message.
+ mdx_source: String,
+}
+
+#[turbo_tasks::value_impl]
+impl Issue for MdxIssue {
+ #[turbo_tasks::function]
+ fn file_path(&self) -> Vc<FileSystemPath> {
+ self.path
+ }
+
+ #[turbo_tasks::function]
+ fn source(&self) -> Vc<OptionIssueSource> {
+ self.loc
+ }
+
+ #[turbo_tasks::function]
+ fn stage(self: Vc<Self>) -> Vc<IssueStage> {
+ IssueStage::Parse.cell()
+ }
+
+ #[turbo_tasks::function]
+ fn title(self: Vc<Self>) -> Vc<StyledString> {
+ StyledString::Text("MDX Parse Error".into()).cell()
+ }
+
+ #[turbo_tasks::function]
+ fn description(&self) -> Vc<OptionStyledString> {
+ Vc::cell(Some(StyledString::Text(self.reason.clone().into()).cell()))
+ }
+}
+
 pub fn register() {
  turbo_tasks::register();
  turbo_tasks_fs::register();