Render error (#2560)

* Add render_error and rename highlight to render

* Shorten docstrings

Author: PhoebeSzmucer

crates/wit-component/tests/components.rs

@@ -178,7 +178,7 @@ fn run_test(path: &Path) -> Result<()> {
     assert_output(&wit, &component_wit_path)?;
 
     UnresolvedPackageGroup::parse(&component_wit_path, &wit)
-        .map_err(|(map, e)| anyhow::anyhow!("{}", e.highlight(&map)))
+        .map_err(|(map, e)| anyhow::anyhow!("{}", e.render(&map)))
         .context("failed to parse printed WIT")?;
 
     // Check that the producer data got piped through properly

crates/wit-component/tests/interfaces.rs

@@ -99,7 +99,7 @@ fn assert_print(resolve: &Resolve, pkg_id: PackageId, path: &Path, is_dir: bool)
     assert_output(&expected, &output)?;
 
     UnresolvedPackageGroup::parse("foo.wit", &output)
-        .map_err(|(map, e)| anyhow::anyhow!("{}", e.highlight(&map)))
+        .map_err(|(map, e)| anyhow::anyhow!("{}", e.render(&map)))
         .context("failed to parse printed output")?;
     Ok(())
 }

crates/wit-parser/src/ast/error.rs

@@ -90,8 +90,10 @@ impl ParseError {
         &mut self.0
     }
 
-    /// Format this error with source context (file:line:col + snippet)
-    pub fn highlight(&self, source_map: &SourceMap) -> String {
+    /// Renders this error with source context (file:line:col + snippet).
+    ///
+    /// `source_map` must be the map this error's spans are valid in.
+    pub fn render(&self, source_map: &SourceMap) -> String {
         let e = self.kind();
         source_map
             .highlight_span(e.span(), e)

crates/wit-parser/src/lib.rs

@@ -70,22 +70,23 @@ pub fn validate_id(s: &str) -> anyhow::Result<()> {
 /// Renders an [`anyhow::Error`] chain produced by this crate, substituting
 /// snippet-bearing output for any [`ResolveError`] or [`ParseError`] layers.
 ///
-/// For each layer in the chain, this calls [`ResolveError::highlight`] or
-/// [`ParseError::highlight`] to format typed errors with file/line/column and
+/// For each layer in the chain, this calls [`ResolveError::render`] or
+/// [`ParseError::render`] to format typed errors with file/line/column and
 /// a source snippet. Other layers are formatted via their [`fmt::Display`]
 /// impl. Layers are joined with `": "`, matching `format!("{err:#}")`.
 ///
 /// `source_map` must be the [`SourceMap`] in which every typed error's spans
 /// are valid; combining typed errors from different source maps in one chain
-/// is unsupported.
+/// is unsupported. For errors from [`Resolve`] methods, prefer
+/// [`Resolve::render_error`].
 #[cfg(feature = "std")]
 pub fn render_anyhow_error(err: &anyhow::Error, source_map: &SourceMap) -> String {
     err.chain()
         .map(|layer| {
             if let Some(re) = layer.downcast_ref::<ResolveError>() {
-                re.highlight(source_map)
+                re.render(source_map)
             } else if let Some(pe) = layer.downcast_ref::<ParseError>() {
-                pe.highlight(source_map)
+                pe.render(source_map)
             } else {
                 layer.to_string()
             }
@@ -328,7 +329,7 @@ impl UnresolvedPackageGroup {
     ///
     /// On failure the constructed [`SourceMap`] is returned alongside the
     /// typed [`ParseError`] so the caller can render a snippet via
-    /// [`ParseError::highlight`] or merge the source map elsewhere.
+    /// [`ParseError::render`] or merge the source map elsewhere.
     #[cfg(feature = "std")]
     pub fn parse(
         path: impl AsRef<Path>,
@@ -350,7 +351,7 @@ impl UnresolvedPackageGroup {
         let mut map = SourceMap::default();
         map.push_dir(path.as_ref())?;
         map.parse().map_err(|(map, e)| {
-            let rendered = e.highlight(&map);
+            let rendered = e.render(&map);
             anyhow::Error::from(e).context(rendered)
         })
     }

crates/wit-parser/src/resolve/error.rs

@@ -129,8 +129,10 @@ impl ResolveError {
         &mut self.0
     }
 
-    /// Format this error with source context (file:line:col + snippet).
-    pub fn highlight(&self, source_map: &SourceMap) -> String {
+    /// Renders this error with source context (file:line:col + snippet).
+    ///
+    /// `source_map` must be the map this error's spans are valid in.
+    pub fn render(&self, source_map: &SourceMap) -> String {
         let e = self.kind();
         let msg = e.to_string();
         match e {

crates/wit-parser/src/resolve/mod.rs

@@ -441,6 +441,13 @@ impl Resolve {
         self.source_map.render_location(span)
     }
 
+    /// Renders an error returned by this [`Resolve`]'s `push_*` methods with
+    /// source context (file:line:col + snippet).
+    #[cfg(feature = "std")]
+    pub fn render_error(&self, err: &anyhow::Error) -> String {
+        crate::render_anyhow_error(err, &self.source_map)
+    }
+
     pub fn all_bits_valid(&self, ty: &Type) -> bool {
         match ty {
             Type::U8
@@ -5928,7 +5935,7 @@ interface iface {
         };
         let mut resolve = Resolve::default();
         let err = resolve.push_groups(a, Vec::from([b])).unwrap_err();
-        let msg = err.highlight(&resolve.source_map);
+        let msg = err.render(&resolve.source_map);
         assert!(
             msg.contains("file:///"),
             "cycle error should contain a file URI, got: {msg}"

crates/wit-parser/tests/all.rs

@@ -87,7 +87,7 @@ impl Runner {
                             "some generic platform-agnostic error message",
                         );
                     }
-                    render_anyhow_error(&e, &resolve.source_map)
+                    resolve.render_error(&e)
                 }
             }
         } else {

crates/wit-parser/tests/downcast.rs

@@ -69,12 +69,12 @@ fn push_str_parse_error_is_downcastable() {
         .expect_err("expected parse to fail");
     let pe = parse_error(&err);
     // Spans must be valid against `resolve.source_map` after the failure-path
-    // merge, so highlighting against it should not panic and should include
+    // merge, so rendering against it should not panic and should include
     // the file and line.
-    let rendered = pe.highlight(&resolve.source_map);
+    let rendered = pe.render(&resolve.source_map);
     assert!(
         rendered.contains("test.wit:2:"),
-        "expected highlighted error to reference test.wit:2:..., got:\n{rendered}"
+        "expected rendered error to reference test.wit:2:..., got:\n{rendered}"
     );
     assert!(
         matches!(pe.kind(), ParseErrorKind::Syntax { .. }),
@@ -103,10 +103,10 @@ fn parse_error_spans_are_adjusted_after_earlier_pushes() {
     // `resolve.source_map` because `first.wit` was merged before it, so this
     // only points at the right file and line if the error's spans were
     // adjusted during the failure-path merge.
-    let rendered = pe.highlight(&resolve.source_map);
+    let rendered = pe.render(&resolve.source_map);
     assert!(
         rendered.contains("second.wit:2:"),
-        "expected highlighted error to reference second.wit:2:..., got:\n{rendered}"
+        "expected rendered error to reference second.wit:2:..., got:\n{rendered}"
     );
     assert!(
         rendered.contains("not-a-keyword"),

src/bin/wasm-tools/component.rs

@@ -967,12 +967,9 @@ impl WitOpts {
             if input.is_dir() {
                 let mut resolve =
                     WitResolve::resolve_with_features(&self.features, self.all_features);
-                let (pkg_id, _) = resolve.push_dir(&input).map_err(|e| {
-                    anyhow::anyhow!(
-                        "{}",
-                        wit_parser::render_anyhow_error(&e, &resolve.source_map)
-                    )
-                })?;
+                let (pkg_id, _) = resolve
+                    .push_dir(&input)
+                    .map_err(|e| anyhow::anyhow!("{}", resolve.render_error(&e)))?;
                 return Ok(DecodedWasm::WitPackage(resolve, pkg_id));
             }
         }
@@ -1029,12 +1026,9 @@ impl WitOpts {
                 };
                 let mut resolve =
                     WitResolve::resolve_with_features(&self.features, self.all_features);
-                let id = resolve.push_str(path, input).map_err(|e| {
-                    anyhow::anyhow!(
-                        "{}",
-                        wit_parser::render_anyhow_error(&e, &resolve.source_map)
-                    )
-                })?;
+                let id = resolve
+                    .push_str(path, input)
+                    .map_err(|e| anyhow::anyhow!("{}", resolve.render_error(&e)))?;
                 Ok(DecodedWasm::WitPackage(resolve, id))
             }
         }

src/wit.rs

@@ -42,12 +42,9 @@ impl WitResolve {
 
     pub fn load(&self) -> Result<(Resolve, PackageId)> {
         let mut resolve = Self::resolve_with_features(&self.features, self.all_features);
-        let (pkg_id, _) = resolve.push_path(&self.wit).map_err(|e| {
-            anyhow::anyhow!(
-                "{}",
-                wit_parser::render_anyhow_error(&e, &resolve.source_map)
-            )
-        })?;
+        let (pkg_id, _) = resolve
+            .push_path(&self.wit)
+            .map_err(|e| anyhow::anyhow!("{}", resolve.render_error(&e)))?;
         Ok((resolve, pkg_id))
     }
 }