Merge pull request #262 from 1Password/darrell/use-span-for-line-column-nums-errors

Use Span to capture line and column numbers for parsing rejections.

Author: charlespierce

Cargo.lock

@@ -35,4 +35,4 @@ inherits = "release"
 
 [workspace.dependencies]
 log = "0.4"
-flexi_logger = "0.30"
+flexi_logger = "0.31"

Cargo.toml

@@ -17,15 +17,15 @@ python = []
 
 [dependencies]
 clap = { version = "4.5", features = [
-  "cargo",
-  "derive",
-  "unicode",
-  "wrap_help",
+    "cargo",
+    "derive",
+    "unicode",
+    "wrap_help",
 ] }
 ignore = "0.4"
 once_cell = "1"
 serde = { version = "1", features = ["derive"] }
-toml = "0.8"
+toml = "0.9"
 typeshare-core = { path = "../core", version = "=1.13.3" }
 log.workspace = true
 flexi_logger.workspace = true

cli/Cargo.toml

@@ -138,7 +138,10 @@ fn generate_types(config_file: Option<&Path>, options: &Args) -> anyhow::Result<
 
     check_parse_errors(&parsed_data)?;
 
-    info!("typeshare started writing generated types");
+    info!(
+        "typeshare started writing {} generated types",
+        parsed_data.len()
+    );
 
     write_generated(destination, lang.as_mut(), parsed_data, import_candidates)?;
 

cli/src/main.rs

@@ -1,4 +1,5 @@
 //! Source file parsing.
+use anyhow::anyhow;
 use anyhow::Context;
 use crossbeam::channel::bounded;
 use ignore::{DirEntry, WalkBuilder, WalkState};
@@ -8,8 +9,9 @@ use std::{
 };
 use typeshare_core::{
     context::{ParseContext, ParseFileContext},
+    error::ParseErrorWithSpan,
     language::{CrateName, CrateTypes, SupportedLanguage, SINGLE_FILE_CRATE_NAME},
-    parser::{ParseError, ParsedData},
+    parser::ParsedData,
     RenameExt,
 };
 
@@ -80,23 +82,48 @@ pub fn all_types(file_mappings: &mut BTreeMap<CrateName, ParsedData>) -> CrateTy
         )
 }
 
+#[derive(Debug)]
+enum ParseDirError {
+    IO(String),
+    ParseError(ParseErrorWithSpan),
+}
+
+impl From<ParseErrorWithSpan> for ParseDirError {
+    fn from(value: ParseErrorWithSpan) -> Self {
+        Self::ParseError(value)
+    }
+}
+
+impl std::error::Error for ParseDirError {}
+
+impl std::fmt::Display for ParseDirError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            ParseDirError::IO(s) => f.write_str(s),
+            ParseDirError::ParseError(parse_error_with_span) => {
+                write!(f, "{parse_error_with_span}")
+            }
+        }
+    }
+}
+
 fn parse_dir_entry(
     parse_context: &ParseContext,
     language_type: SupportedLanguage,
     dir_entry: &DirEntry,
-) -> Result<Option<ParsedData>, ParseError> {
+) -> Result<Option<ParsedData>, ParseDirError> {
     if dir_entry.path().is_dir() {
         return Ok(None);
     }
 
     let Some(parse_file_context) =
         parse_file_context(parse_context.multi_file, language_type, dir_entry)
-            .map_err(|err| ParseError::IOError(err.to_string()))?
+            .map_err(|err| ParseDirError::IO(err.to_string()))?
     else {
         return Ok(None);
     };
 
-    typeshare_core::parser::parse(parse_context, parse_file_context)
+    typeshare_core::parser::parse(parse_context, parse_file_context).map_err(Into::into)
 }
 
 /// Use parallel builder to walk all source directories concurrently.
@@ -126,7 +153,7 @@ pub fn parallel_parse(
         Box::new(move |result| {
             let result = result.context("Failed traversing").and_then(|dir_entry| {
                 parse_dir_entry(parse_context, language_type, &dir_entry)
-                    .with_context(|| format!("Parsing failed: {:?}", dir_entry.path()))
+                    .map_err(|err| anyhow!("Parsing failed: {:?},  {err}", dir_entry.path()))
             });
             match result {
                 Ok(Some(parsed_data)) => {

cli/src/parse.rs

@@ -7,7 +7,7 @@ description = "The code generator used by Typeshare's command line tool"
 repository = "https://github.com/1Password/typeshare"
 
 [dependencies]
-proc-macro2 = "1"
+proc-macro2 = { version = "1", features = ["span-locations"] }
 quote = "1"
 syn = { version = "2", features = ["full", "visit"] }
 thiserror = "2"

core/Cargo.toml

@@ -0,0 +1,101 @@
+//! Error types for parsing.
+use itertools::Itertools as _;
+use proc_macro2::Span;
+use thiserror::Error;
+
+#[derive(Debug)]
+/// Wrapper for a parse error which includes a span.
+pub struct ParseErrorWithSpan {
+    /// Parse error
+    error: ParseError,
+    /// Span
+    span: Span,
+}
+
+impl std::error::Error for ParseErrorWithSpan {}
+
+impl std::fmt::Display for ParseErrorWithSpan {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}, on line {} and column {}",
+            self.error,
+            self.span.start().line,
+            self.span.start().column
+        )
+    }
+}
+
+/// Errors that can occur while parsing Rust source input.
+#[derive(Debug, Error)]
+#[allow(missing_docs)]
+pub enum ParseError {
+    #[error("{0}")]
+    SynError(#[from] syn::Error),
+    #[error("Failed to parse a Rust type: {0}")]
+    RustTypeParseError(#[from] RustTypeParseError),
+    #[error("Unsupported language encountered: {0}")]
+    UnsupportedLanguage(String),
+    #[error("Unsupported type encountered: {0}")]
+    UnsupportedType(String),
+    #[error("Tuple structs with more than one field are currently unsupported")]
+    ComplexTupleStruct,
+    #[error("Multiple unnamed associated types are not currently supported")]
+    MultipleUnnamedAssociatedTypes,
+    #[error("The serde tag attribute is not supported for non-algebraic enums: {enum_ident}")]
+    SerdeTagNotAllowed { enum_ident: String },
+    #[error("The serde content attribute is not supported for non-algebraic enums: {enum_ident}")]
+    SerdeContentNotAllowed { enum_ident: String },
+    #[error("Serde tag attribute needs to be specified for algebraic enum {enum_ident}. e.g. #[serde(tag = \"type\", content = \"content\")]")]
+    SerdeTagRequired { enum_ident: String },
+    #[error("Serde content attribute needs to be specified for algebraic enum {enum_ident}. e.g. #[serde(tag = \"type\", content = \"content\")]")]
+    SerdeContentRequired { enum_ident: String },
+    #[error("The expression assigned to this constant variable is not a numeric literal")]
+    RustConstExprInvalid,
+    #[error("You cannot use typeshare on a constant that is not a numeric literal")]
+    RustConstTypeInvalid,
+    #[error("The serde flatten attribute is not currently supported")]
+    SerdeFlattenNotAllowed,
+    #[error("IO error: {0}")]
+    IOError(String),
+}
+
+/// Parse error types that can capture a span and convert
+/// into the top level [ParseErrorWithSpan] type.
+pub trait WithSpan {
+    /// Convert [Self] into a [`ParserErrorWithSpan`].
+    fn with_span(self, span: Span) -> ParseErrorWithSpan;
+}
+
+impl WithSpan for RustTypeParseError {
+    fn with_span(self, span: Span) -> ParseErrorWithSpan {
+        ParseError::RustTypeParseError(self).with_span(span)
+    }
+}
+
+impl WithSpan for ParseError {
+    fn with_span(self, span: Span) -> ParseErrorWithSpan {
+        ParseErrorWithSpan { error: self, span }
+    }
+}
+
+#[derive(Debug, Error)]
+/// Errors during file generation.
+pub enum GenerationError {
+    /// The post generation step failed.
+    #[error("Post generation failed: {0}")]
+    PostGeneration(String),
+}
+
+#[derive(Debug, Error)]
+#[allow(missing_docs)]
+pub enum RustTypeParseError {
+    #[error("Unsupported type: \"{}\"", .0.iter().join(","))]
+    UnsupportedType(Vec<String>),
+    #[error("Unexpected token when parsing type: `{0}`. This is an internal error, please ping a typeshare developer to resolve this problem.")]
+    UnexpectedToken(String),
+    #[error("Tuples are not allowed in typeshare types")]
+    UnexpectedParameterizedTuple,
+    #[error("Could not parse numeric literal")]
+    NumericLiteral(syn::parse::Error),
+}

core/src/error.rs

@@ -1,12 +1,12 @@
 use crate::{
-    parser::{ParseError, ParsedData},
+    error::{GenerationError, ParseError},
+    parser::ParsedData,
     rust_types::{
         Id, RustConst, RustEnum, RustEnumVariant, RustItem, RustStruct, RustType, RustTypeAlias,
         RustTypeFormatError, SpecialRustType,
     },
     topsort::topsort,
     visitors::ImportedType,
-    GenerationError,
 };
 use itertools::Itertools;
 use log::warn;

core/src/language/mod.rs

@@ -1,12 +1,12 @@
 use crate::{
+    error::GenerationError,
     language::{Language, SupportedLanguage},
     parser::{remove_dash_from_identifier, DecoratorKind, ParsedData},
     rename::RenameExt,
     rust_types::{
         DecoratorMap, RustConst, RustEnum, RustEnumVariant, RustStruct, RustTypeAlias,
         RustTypeFormatError, SpecialRustType,
     },
-    GenerationError,
 };
 use itertools::{Either, Itertools};
 use joinery::JoinableIterator;

core/src/language/swift.rs

@@ -1,8 +1,7 @@
 //! The core library for typeshare.
 //! Contains the parser and language converters.
-use thiserror::Error;
-
 pub mod context;
+pub mod error;
 /// Implementations for each language converter
 pub mod language;
 /// Parsing Rust code into a format the `language` modules can understand
@@ -16,20 +15,3 @@ mod topsort;
 mod visitors;
 
 pub use rename::RenameExt;
-
-#[derive(Debug, Error)]
-#[allow(missing_docs)]
-pub enum ProcessInputError {
-    #[error("a parsing error occurred: {0}")]
-    ParseError(#[from] parser::ParseError),
-    #[error("a type generation error occurred: {0}")]
-    IoError(#[from] std::io::Error),
-}
-
-#[derive(Debug, Error)]
-/// Errors during file generation.
-pub enum GenerationError {
-    /// The post generation step failed.
-    #[error("Post generation failed: {0}")]
-    PostGeneration(String),
-}