remove panic. fix typos.

Author: darrell-roberts

app/engine/src/iter_util.rs

@@ -0,0 +1,22 @@
+//! Some extra iterator methods.
+
+/// Iterator extension trait.
+pub trait IterExt: Iterator {
+    /// Fallible version of `any()`. Short circuits
+    /// on true or error.
+    #[inline]
+    fn try_any<F, E>(&mut self, mut f: F) -> Result<bool, E>
+    where
+        Self: Sized,
+        F: FnMut(Self::Item) -> Result<bool, E>,
+    {
+        for x in self.by_ref() {
+            if f(x)? {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+}
+
+impl<T> IterExt for std::slice::Iter<'_, T> {}

app/engine/src/lib.rs

@@ -2,6 +2,7 @@
 pub mod args;
 pub mod config;
 pub mod driver;
+mod iter_util;
 pub mod parser;
 mod rename;
 mod serde;
@@ -63,7 +64,7 @@ impl Display for FileParseErrors {
 #[non_exhaustive]
 pub enum FileErrorKind {
     /// We couldn't figure which crate this file belongs to, which we need in
-    /// mutli-file mode
+    /// multi-file mode
     UnknownCrate,
 
     /// There were parse errors
@@ -76,13 +77,13 @@ pub enum FileErrorKind {
 impl Display for FileErrorKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            FileErrorKind::UnknownCrate => f.write_str("unknown crate in mutli-file mode"),
+            FileErrorKind::UnknownCrate => f.write_str("unknown crate in multi-file mode"),
             FileErrorKind::ParseErrors(parse_error_set) => parse_error_set.fmt(f),
             FileErrorKind::ReadError(error) => write!(f, "i/o error: {error}"),
         }
     }
 }
-/// A group of parse errors from a single file. Guaranteed to be non-emtpy.
+/// A group of parse errors from a single file. Guaranteed to be non-empty.
 #[derive(Debug)]
 pub struct ParseErrorSet {
     errors: Vec<ParseError>,

app/engine/src/parser.rs

@@ -1,5 +1,6 @@
 //! Source file parsing.
 use crate::{
+    iter_util::IterExt as _,
     rename::RenameExt,
     target_os,
     type_parser::{parse_rust_type, parse_rust_type_from_string, type_name},
@@ -278,7 +279,7 @@ pub fn parse_input(
         )
 }
 
-/// Check if we have not parsed any relavent typehsared types.
+/// Check if we have not parsed any relevant typehsared types.
 fn is_parsed_data_empty(parsed_data: &ParsedData) -> bool {
     parsed_data.enums.is_empty()
         && parsed_data.aliases.is_empty()
@@ -474,14 +475,21 @@ pub(crate) fn parse_enum(e: &ItemEnum, valid_os: Option<&[&str]>) -> Result<Rust
         .collect::<Result<Vec<_>, _>>()?;
 
     // Check if the enum references itself recursively in any of its variants
-    let is_recursive = variants.iter().any(|v| match v {
-        RustEnumVariant::Unit(_) => false,
-        RustEnumVariant::Tuple { ty, .. } => ty.contains_type(&original_enum_ident),
-        RustEnumVariant::AnonymousStruct { fields, .. } => fields
-            .iter()
-            .any(|f| f.ty.contains_type(&original_enum_ident)),
-        _ => panic!("unrecgonized enum type"),
-    });
+    let is_recursive = variants.iter().try_any(|v| {
+        Ok(match v {
+            RustEnumVariant::Unit(_) => false,
+            RustEnumVariant::Tuple { ty, .. } => ty.contains_type(&original_enum_ident),
+            RustEnumVariant::AnonymousStruct { fields, .. } => fields
+                .iter()
+                .any(|f| f.ty.contains_type(&original_enum_ident)),
+            _ => {
+                return Err(ParseError::new(
+                    &e,
+                    ParseErrorKind::UnsupportedType("Unsupported enum type".into()),
+                ))
+            }
+        })
+    })?;
 
     let shared = RustEnumShared {
         id: get_ident(Some(&e.ident), &e.attrs, None),

app/engine/src/serde/args.rs

@@ -1,11 +1,10 @@
 //! Command line argument parsing.
+use serde::ser;
 use std::{
     collections::HashMap,
     fmt::{self, Display, Write},
 };
 
-use serde::ser;
-
 #[derive(Debug, Clone, Copy)]
 pub enum ArgType {
     Bool,

app/engine/src/serde/config.rs

@@ -1,13 +1,12 @@
+//! Deserialization for configuration.
+use super::args::{ArgSpec, ArgType, CliArgsSet};
+use itertools::Itertools;
+use serde::de::{self, value::BorrowedStrDeserializer};
 use std::{
     ffi::{OsStr, OsString},
     str::FromStr,
 };
 
-use itertools::Itertools;
-use serde::de::{self, value::BorrowedStrDeserializer};
-
-use super::args::{ArgSpec, ArgType, CliArgsSet};
-
 #[derive(Debug, thiserror::Error)]
 pub enum ConfigDeserializeError {
     #[error("error from Deserialize type: {0}")]

app/engine/src/serde/empty.rs

@@ -1,3 +1,4 @@
+//! Deserialization for empty
 use serde::de;
 use thiserror::Error;
 

app/engine/src/serde/mod.rs

@@ -1,3 +1,4 @@
+//! Various serde deserializers
 pub mod args;
 pub mod config;
 pub mod empty;

app/engine/src/serde/toml.rs

@@ -1,6 +1,6 @@
-use std::{marker::PhantomData, str};
-
+//! Toml deserialization.
 use serde::de;
+use std::{marker::PhantomData, str};
 
 /// Borrowing deserializer for a `toml::Value`
 pub struct ValueDeserializer<'a, E> {

app/engine/src/target_os.rs

@@ -1,3 +1,4 @@
+//! Parsing of `target_os` attributes
 use proc_macro2::{Delimiter, Group, TokenStream};
 use syn::{parse::Parser, punctuated::Punctuated, Ident, LitStr, Token};
 

app/engine/src/topsort.rs

@@ -1,9 +1,8 @@
+//! Top sort of rust types.
+use crate::writer::BorrowedRustItem;
 use std::collections::{HashMap, HashSet};
-
 use typeshare_model::prelude::*;
 
-use crate::writer::BorrowedRustItem;
-
 fn get_dependencies_from_type<'a>(
     tp: &'a RustType,
     types: &HashMap<&'a TypeName, BorrowedRustItem<'a>>,