Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 196 insertions, 0 deletions

diff --git a/third_party/rust/wast/src/error.rs b/third_party/rust/wast/src/error.rs
new file mode 100644
index 0000000000..214e678338
--- /dev/null
+++ b/third_party/rust/wast/src/error.rs
@@ -0,0 +1,196 @@
+use crate::lexer::LexError;
+use crate::token::Span;
+use std::fmt;
+use std::path::{Path, PathBuf};
+use unicode_width::UnicodeWidthStr;
+
+/// A convenience error type to tie together all the detailed errors produced by
+/// this crate.
+///
+/// This type can be created from a [`LexError`]. This also contains
+/// storage for file/text information so a nice error can be rendered along the
+/// same lines of rustc's own error messages (minus the color).
+///
+/// This type is typically suitable for use in public APIs for consumers of this
+/// crate.
+#[derive(Debug)]
+pub struct Error {
+    inner: Box<ErrorInner>,
+}
+
+#[derive(Debug)]
+struct ErrorInner {
+    text: Option<Text>,
+    file: Option<PathBuf>,
+    span: Span,
+    kind: ErrorKind,
+}
+
+#[derive(Debug)]
+struct Text {
+    line: usize,
+    col: usize,
+    snippet: String,
+}
+
+#[derive(Debug)]
+enum ErrorKind {
+    Lex(LexError),
+    Custom(String),
+}
+
+impl Error {
+    pub(crate) fn lex(span: Span, content: &str, kind: LexError) -> Error {
+        let mut ret = Error {
+            inner: Box::new(ErrorInner {
+                text: None,
+                file: None,
+                span,
+                kind: ErrorKind::Lex(kind),
+            }),
+        };
+        ret.set_text(content);
+        ret
+    }
+
+    pub(crate) fn parse(span: Span, content: &str, message: String) -> Error {
+        let mut ret = Error {
+            inner: Box::new(ErrorInner {
+                text: None,
+                file: None,
+                span,
+                kind: ErrorKind::Custom(message),
+            }),
+        };
+        ret.set_text(content);
+        ret
+    }
+
+    /// Creates a new error with the given `message` which is targeted at the
+    /// given `span`
+    ///
+    /// Note that you'll want to ensure that `set_text` or `set_path` is called
+    /// on the resulting error to improve the rendering of the error message.
+    pub fn new(span: Span, message: String) -> Error {
+        Error {
+            inner: Box::new(ErrorInner {
+                text: None,
+                file: None,
+                span,
+                kind: ErrorKind::Custom(message),
+            }),
+        }
+    }
+
+    /// Return the `Span` for this error.
+    pub fn span(&self) -> Span {
+        self.inner.span
+    }
+
+    /// To provide a more useful error this function can be used to extract
+    /// relevant textual information about this error into the error itself.
+    ///
+    /// The `contents` here should be the full text of the original file being
+    /// parsed, and this will extract a sub-slice as necessary to render in the
+    /// `Display` implementation later on.
+    pub fn set_text(&mut self, contents: &str) {
+        if self.inner.text.is_some() {
+            return;
+        }
+        self.inner.text = Some(Text::new(contents, self.inner.span));
+    }
+
+    /// To provide a more useful error this function can be used to set
+    /// the file name that this error is associated with.
+    ///
+    /// The `path` here will be stored in this error and later rendered in the
+    /// `Display` implementation.
+    pub fn set_path(&mut self, path: &Path) {
+        if self.inner.file.is_some() {
+            return;
+        }
+        self.inner.file = Some(path.to_path_buf());
+    }
+
+    /// Returns the underlying `LexError`, if any, that describes this error.
+    pub fn lex_error(&self) -> Option<&LexError> {
+        match &self.inner.kind {
+            ErrorKind::Lex(e) => Some(e),
+            _ => None,
+        }
+    }
+
+    /// Returns the underlying message, if any, that describes this error.
+    pub fn message(&self) -> String {
+        match &self.inner.kind {
+            ErrorKind::Lex(e) => e.to_string(),
+            ErrorKind::Custom(e) => e.clone(),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let err = match &self.inner.kind {
+            ErrorKind::Lex(e) => e as &dyn fmt::Display,
+            ErrorKind::Custom(e) => e as &dyn fmt::Display,
+        };
+        let text = match &self.inner.text {
+            Some(text) => text,
+            None => {
+                return write!(f, "{} at byte offset {}", err, self.inner.span.offset);
+            }
+        };
+        let file = self
+            .inner
+            .file
+            .as_ref()
+            .and_then(|p| p.to_str())
+            .unwrap_or("<anon>");
+        write!(
+            f,
+            "\
+{err}
+     --> {file}:{line}:{col}
+      |
+ {line:4} | {text}
+      | {marker:>0$}",
+            text.col + 1,
+            file = file,
+            line = text.line + 1,
+            col = text.col + 1,
+            err = err,
+            text = text.snippet,
+            marker = "^",
+        )
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl Text {
+    fn new(content: &str, span: Span) -> Text {
+        let (line, col) = span.linecol_in(content);
+        let contents = content.lines().nth(line).unwrap_or("");
+        let mut snippet = String::new();
+        for ch in contents.chars() {
+            match ch {
+                // Replace tabs with spaces to render consistently
+                '\t' => {
+                    snippet.push_str("    ");
+                }
+                // these codepoints change how text is rendered so for clarity
+                // in error messages they're dropped.
+                '\u{202a}' | '\u{202b}' | '\u{202d}' | '\u{202e}' | '\u{2066}' | '\u{2067}'
+                | '\u{2068}' | '\u{206c}' | '\u{2069}' => {}
+
+                c => snippet.push(c),
+            }
+        }
+        // Use the `unicode-width` crate to figure out how wide the snippet, up
+        // to our "column", actually is. That'll tell us how many spaces to
+        // place before the `^` character that points at the problem
+        let col = snippet.get(..col).map(|s| s.width()).unwrap_or(col);
+        Text { line, col, snippet }
+    }
+}