Refactor InvalidSchemaError to support multiple errors (#246)

* Move result.rs -> result/mod.rs
* Refactor InvalidSchemaError

Author: popematt

ion-schema/src/constraint.rs

@@ -11,11 +11,8 @@ use crate::isl::util::{
     Annotation, Ieee754InterchangeFormat, TimestampOffset, TimestampPrecision, ValidValue,
 };
 use crate::isl::IslVersion;
-use crate::isl_require;
 use crate::ordered_elements_nfa::OrderedElementsNfa;
-use crate::result::{
-    invalid_schema_error, invalid_schema_error_raw, IonSchemaResult, ValidationResult,
-};
+use crate::result::{invalid_schema, isl_require, IonSchemaResult, ValidationResult};
 use crate::system::{PendingTypes, TypeId, TypeStore};
 use crate::type_reference::{TypeReference, VariablyOccurringTypeRef};
 use crate::types::TypeValidator;
@@ -1916,9 +1913,7 @@ impl RegexConstraint {
             .case_insensitive(isl_regex.case_insensitive())
             .multi_line(isl_regex.multi_line())
             .build()
-            .map_err(|e| {
-                invalid_schema_error_raw(format!("Invalid regex {}", isl_regex.expression()))
-            })?;
+            .map_err(|e| invalid_schema!("Invalid regex {}", isl_regex.expression()))?;
 
         Ok(RegexConstraint::new(
             regex,
@@ -1948,7 +1943,7 @@ impl RegexConstraint {
                     sb.push(ch);
                     if let Some(ch) = si.next() {
                         if ch == '?' {
-                            return invalid_schema_error(format!("invalid character {ch}"));
+                            return invalid_schema!("invalid character {ch}");
                         }
                         sb.push(ch)
                     }
@@ -1965,11 +1960,7 @@ impl RegexConstraint {
                             }
                             's' => sb.push_str("[ \\f\\n\\r\\t]"),
                             'S' => sb.push_str("[^ \\f\\n\\r\\t]"),
-                            _ => {
-                                return invalid_schema_error(format!(
-                                    "invalid escape character {ch}",
-                                ))
-                            }
+                            _ => return invalid_schema!("invalid escape character {ch}",),
                         }
                     }
                 }
@@ -1993,10 +1984,10 @@ impl RegexConstraint {
             match ch {
                 '&' => {
                     if si.peek() == Some(&'&') {
-                        return invalid_schema_error("'&&' is not supported in a character class");
+                        return invalid_schema!("'&&' is not supported in a character class");
                     }
                 }
-                '[' => return invalid_schema_error("'[' must be escaped within a character class"),
+                '[' => return invalid_schema!("'[' must be escaped within a character class"),
                 '\\' => {
                     if let Some(ch2) = si.next() {
                         match ch2 {
@@ -2006,10 +1997,10 @@ impl RegexConstraint {
                                 match isl_version {
                                     IslVersion::V1_0 => {
                                         // returns an error for ISL 1.0 as it does not support pre-defined char classes (i.e., \d, \s, \w)
-                                        return invalid_schema_error(format!(
+                                        return invalid_schema!(
                                             "invalid sequence '{:?}' in character class",
                                             si
-                                        ));
+                                        );
                                     }
                                     IslVersion::V2_0 => {
                                         // Change \w and \W to be [a-zA-Z0-9_] and [^a-zA-Z0-9_] respectively
@@ -2028,9 +2019,9 @@ impl RegexConstraint {
                                 }
                             }
                             _ => {
-                                return invalid_schema_error(format!(
+                                return invalid_schema!(
                                     "invalid sequence '\\{ch2}' in character class"
-                                ))
+                                )
                             }
                         }
                     }
@@ -2040,7 +2031,7 @@ impl RegexConstraint {
             }
         }
 
-        invalid_schema_error("character class missing ']'")
+        invalid_schema!("character class missing ']'")
     }
 
     fn parse_quantifier(sb: &mut String, si: &mut Peekable<Chars<'_>>) -> IonSchemaResult<()> {
@@ -2069,22 +2060,22 @@ impl RegexConstraint {
                                 complete = true;
                                 break;
                             }
-                            _ => return invalid_schema_error(format!("invalid character {ch}")),
+                            _ => return invalid_schema!("invalid character {ch}"),
                         }
                     }
 
                     if !complete {
-                        return invalid_schema_error("range quantifier missing '}'");
+                        return invalid_schema!("range quantifier missing '}}'");
                     }
                 }
                 _ => {}
             }
             if sb.len() > initial_length {
                 if let Some(ch) = si.peek().cloned() {
                     match ch {
-                        '?' => return invalid_schema_error(format!("invalid character {ch}")),
+                        '?' => return invalid_schema!("invalid character {ch}"),
 
-                        '+' => return invalid_schema_error(format!("invalid character {ch}")),
+                        '+' => return invalid_schema!("invalid character {ch}"),
                         _ => {}
                     }
                 }

ion-schema/src/internal_traits.rs

@@ -4,7 +4,7 @@
 // TODO: This file is a placeholder. These things will eventually be moved to more sensible locations
 //       instead of being clobbered together.
 
-use crate::result::{invalid_schema_error, IonSchemaResult};
+use crate::result::{invalid_schema, IonSchemaResult};
 use crate::{IonSchemaElement, IslVersion, ViolationRecorder};
 use ion_rs::{Element, ValueWriter};
 use std::fmt::Debug;
@@ -44,9 +44,7 @@ pub(crate) trait WriteAsIsl<V: IslVersion>: Debug {
         ctx: &WriteContext<V>,
     ) -> IonSchemaResult<()> {
         let (major, minor) = V::MAJOR_MINOR;
-        invalid_schema_error(format!(
-            "{self:?} is not supported in Ion Schema Language {major}.{minor}"
-        ))
+        invalid_schema!("{self:?} is not supported in Ion Schema Language {major}.{minor}")
     }
 }
 

ion-schema/src/ion_extension.rs

@@ -1,7 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::result::{invalid_schema_error, IonSchemaResult};
+use crate::result::{invalid_schema, IonSchemaResult};
 use ion_rs::{Decimal, IonResult, Struct, Symbol};
 use ion_rs::{Element, Value};
 use num_traits::ToPrimitive;
@@ -54,7 +54,7 @@ impl ElementExtensions for Element {
         let text = symbol.expect_text()?;
         match annotations.next() {
             None => Ok(Some(text)),
-            Some(_) => invalid_schema_error(format!("Unexpected annotations: {self}")),
+            Some(_) => invalid_schema!("Unexpected annotations: {self}"),
         }
     }
 
@@ -93,7 +93,7 @@ impl StructExtensions for Struct {
         let first = iter.next();
         let second = iter.next();
         if second.is_some() {
-            invalid_schema_error(format!("Illegal repeated field '{field_name}' in: {self}"))
+            invalid_schema!("Illegal repeated field '{field_name}' in: {self}")
         } else {
             Ok(first)
         }
@@ -103,7 +103,7 @@ impl StructExtensions for Struct {
         if let Some(element) = self.get_optional(field_name)? {
             Ok(element)
         } else {
-            invalid_schema_error(format!("Missing required field '{field_name}' in: {self}"))
+            invalid_schema!("Missing required field '{field_name}' in: {self}")
         }
     }
 }

ion-schema/src/ion_schema_version.rs

@@ -49,9 +49,6 @@ use std::marker::PhantomData;
 
 /// Wrapper for data that needs to be passed around with an ISL version—for example, builder methods
 /// for some constraints can accept `Versioned<TypeArgument>`s.
-///
-/// Technically, this is a smart pointer that (rather than managing the ownership or memory of the
-/// wrapped value) encodes Ion Schema version information along with the wrapped value.
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Versioned<T, V: IslVersion>(T, PhantomData<V>);
 impl<T, V: IslVersion> Versioned<T, V> {