Adds resolve function, ResolvedSchema, and ResolvedType (#245)

Author: popematt

ion-schema/src/model/bag.rs

@@ -58,6 +58,10 @@ impl<T> Bag<T> {
     pub fn iter(&self) -> impl Iterator<Item = &T> {
         self.items.iter()
     }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
+        self.items.iter_mut()
+    }
 }
 
 impl<T> IntoIterator for Bag<T> {

ion-schema/src/model/constraints/annotations/mod.rs

@@ -32,7 +32,7 @@ impl ConstraintName for Annotations {
 pub struct Annotations {
     variant: AnnotationsVariant,
 }
-impl_type_ref_walker!(Annotations, as_annotations_v2_standard());
+impl_type_ref_walker!(Annotations, as_annotations_v2_standard_mut());
 
 impl Annotations {
     pub fn as_annotations_v1(&self) -> Option<&AnnotationsV1> {
@@ -56,6 +56,14 @@ impl Annotations {
             None
         }
     }
+
+    pub fn as_annotations_v2_standard_mut(&mut self) -> Option<&mut AnnotationsV2Standard> {
+        if let AnnotationsVariant::V2Standard(ref mut variant) = &mut self.variant {
+            Some(variant)
+        } else {
+            None
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Clone)]

ion-schema/src/model/constraints/any_constraint.rs

@@ -39,7 +39,7 @@ macro_rules! any_constraint {
         )+
 
         impl TypeRefWalker for AnyConstraint {
-            fn walk<V: TypeRefVisitor>(&self, visitor: &mut V) {
+            fn walk<V: TypeRefVisitor>(&mut self, visitor: &mut V) {
                 match self {
                     $(AnyConstraint::$name(constraint) => constraint.walk(visitor),
                     )+

ion-schema/src/model/mod.rs

@@ -18,3 +18,4 @@ pub use schema_header::*;
 pub use type_argument::*;
 pub use type_definition::*;
 pub use type_reference::*;
+pub use variable_type_argument::*;

ion-schema/src/model/schema.rs

@@ -33,7 +33,7 @@ impl From<Element> for SchemaItem {
 }
 
 impl TypeRefWalker for SchemaItem {
-    fn walk<V: TypeRefVisitor>(&self, visitor: &mut V) {
+    fn walk<V: TypeRefVisitor>(&mut self, visitor: &mut V) {
         if let SchemaItem::Type(_, t) = self {
             t.walk(visitor)
         }
@@ -84,6 +84,25 @@ impl SchemaDocument {
         self.items.iter()
     }
 
+    /// Iterate all types declared in this schema document
+    pub fn types(&self) -> impl Iterator<Item = (&str, &TypeDefinition)> {
+        self.items.iter().filter_map(|item| match item {
+            SchemaItem::Type(name, def) => Some((name.as_str(), def)),
+            _ => None,
+        })
+    }
+
+    /// Gets the [`SchemaHeader`], if this schema document has a header.
+    pub fn header(&self) -> Option<&SchemaHeader> {
+        self.items.iter().find_map(|item| {
+            if let SchemaItem::Header(header) = item {
+                Some(header)
+            } else {
+                None
+            }
+        })
+    }
+
     /// Get a type from the schema, by name.
     pub fn get_type(&self, name: &str) -> Option<&TypeDefinition> {
         self.items.iter().find_map(|item| match item {
@@ -92,6 +111,17 @@ impl SchemaDocument {
         })
     }
 
+    /// Iterate all types declared in this schema definition
+    pub(crate) fn indexed_type_names(&self) -> impl Iterator<Item = (usize, &String)> {
+        self.items
+            .iter()
+            .enumerate()
+            .filter_map(|(idx, item)| match item {
+                SchemaItem::Type(name, _) => Some((idx, name)),
+                _ => None,
+            })
+    }
+
     pub(crate) fn get_type_idx_by_name(&self, name: &str) -> Option<usize> {
         self.items
             .iter()

ion-schema/src/model/schema_header.rs

@@ -64,6 +64,25 @@ impl Import {
             }),
         }
     }
+
+    /// The Schema ID that this [`Import`] is targeting.
+    pub fn schema_id(&self) -> &str {
+        &self.schema_id
+    }
+
+    /// The (optional) type that this [`Import`] is targeting.
+    pub fn type_name(&self) -> Option<&str> {
+        self.type_import
+            .as_ref()
+            .map(|type_import| type_import.type_name.as_str())
+    }
+
+    /// The (optional) alias for the type that this [`Import`] is targeting.
+    pub fn type_alias(&self) -> Option<&str> {
+        self.type_import
+            .as_ref()
+            .and_then(|type_import| type_import.alias.as_deref())
+    }
 }
 
 /// Builds a [`SchemaHeader`].

ion-schema/src/model/type_argument.rs

@@ -52,10 +52,10 @@ enum TypeArgumentKind {
 }
 
 impl TypeRefWalker for TypeArgument {
-    fn walk<V: TypeRefVisitor>(&self, visitor: &mut V) {
-        match &self.kind {
-            TypeArgumentKind::TypeReference(ref type_ref) => visitor.visit(type_ref),
-            TypeArgumentKind::InlineType(type_def) => type_def.walk(visitor),
+    fn walk<V: TypeRefVisitor>(&mut self, visitor: &mut V) {
+        match &mut self.kind {
+            TypeArgumentKind::TypeReference(ref mut type_ref) => visitor.visit(type_ref),
+            TypeArgumentKind::InlineType(ref mut type_def) => type_def.walk(visitor),
         }
     }
 }

ion-schema/src/model/type_reference.rs

@@ -3,7 +3,7 @@
 
 use crate::internal_traits::{LoaderContext, ReadFromIsl, WriteAsIsl, WriteContext};
 use crate::ion_extension::StructExtensions;
-use crate::model::type_definition::TypeDefinition;
+use crate::resolver::TypeCoordinates;
 use crate::result::{invalid_schema_error, IonSchemaResult};
 use crate::IslVersion;
 use ion_rs::{Element, StructWriter, Value, ValueWriter};
@@ -13,17 +13,27 @@ use ion_rs::{Element, StructWriter, Value, ValueWriter};
 pub struct TypeReference {
     schema_id: Option<String>,
     type_name: String,
-    // Not exposed in public API.
-    // Initially `None`, but changed to `Some(_)` when resolving the schemas
-    // TODO: resolved: Cell<Option<...>>,
+    // Not exposed in public API. Initially `None`, but changed to `Some(_)` when resolving the schemas
+    resolved_type_coordinates: Option<TypeCoordinates>,
 }
 
 impl TypeReference {
-    // TODO: Determine if this needs to be pub
-    pub(crate) fn imported<A: Into<String>, B: Into<String>>(schema_id: A, type_name: B) -> Self {
+    /// Creates a `TypeReference` for a type name that is defined in or imported to the current
+    /// [`SchemaDocument`].
+    fn local<S: Into<String>>(type_name: S) -> Self {
+        TypeReference {
+            schema_id: None,
+            type_name: type_name.into(),
+            resolved_type_coordinates: None,
+        }
+    }
+
+    /// Creates a `TypeReference` that is an inline import from another schema.
+    pub fn imported<A: Into<String>, B: Into<String>>(schema_id: A, type_name: B) -> Self {
         TypeReference {
             schema_id: Some(schema_id.into()),
             type_name: type_name.into(),
+            resolved_type_coordinates: None,
         }
     }
 
@@ -35,20 +45,19 @@ impl TypeReference {
         self.type_name.as_str()
     }
 
-    /// Returns an immutable borrow of the [TypeDefinition] to which this [TypeReference] refers.
-    pub fn get(&self) -> Option<&TypeDefinition> {
-        todo!()
+    pub(crate) fn type_coordinates(&self) -> Option<TypeCoordinates> {
+        self.resolved_type_coordinates
     }
 
-    // TODO: functions for setting the resolved type
+    /// Sets the [`TypeCoordinates`] of this `TypeReference`.
+    pub(crate) fn set_type_coordinates(&mut self, type_coordinates: Option<TypeCoordinates>) {
+        self.resolved_type_coordinates = type_coordinates
+    }
 }
 
 impl<T: Into<String>> From<T> for TypeReference {
     fn from(value: T) -> Self {
-        TypeReference {
-            schema_id: None,
-            type_name: value.into(),
-        }
+        TypeReference::local(value)
     }
 }
 
@@ -105,10 +114,7 @@ mod tests {
     #[test]
     fn from_string() {
         let from_value = "foo";
-        let expected = TypeReference {
-            schema_id: None,
-            type_name: "foo".to_string(),
-        };
+        let expected = TypeReference::local("foo");
         assert_eq!(expected, from_value.into())
     }
 
@@ -118,13 +124,14 @@ mod tests {
         let expected = TypeReference {
             schema_id: Some("foo".to_string()),
             type_name: "bar".to_string(),
+            resolved_type_coordinates: None,
         };
         assert_eq!(expected, actual)
     }
 
     #[rstest]
-    #[case::type_name("foo", TypeReference { schema_id: None, type_name: "foo".to_string() })]
-    #[case::inline_import("{id:\"foo.isl\",type:bar}", TypeReference { schema_id: Some("foo.isl".to_string()), type_name: "bar".to_string() } )]
+    #[case::type_name("foo", TypeReference::local("foo"))]
+    #[case::inline_import("{id:\"foo.isl\",type:bar}", TypeReference::imported("foo.isl", "bar"))]
     fn type_reference_try_read_ok(#[case] ion: &str, #[case] expected: TypeReference) {
         let expected = Ok(expected);
         let element = Element::read_one(ion).unwrap();

ion-schema/src/resolver/mod.rs

@@ -3,11 +3,39 @@
 
 use crate::model::SchemaDocument;
 
+mod resolve_fn;
+mod resolved_schema;
 mod type_ref_visitor;
 
+pub use resolve_fn::resolve;
+pub use resolve_fn::unresolve;
+pub use resolved_schema::*;
 pub(crate) use type_ref_visitor::*;
 
+/// A schema index and type index.
+#[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq)]
+pub(crate) struct TypeCoordinates(usize, usize);
+impl TypeCoordinates {
+    #[cfg(test)]
+    pub(crate) fn new(s_idx: usize, t_idx: usize) -> Self {
+        TypeCoordinates(s_idx, t_idx)
+    }
+
+    fn schema_idx(&self) -> usize {
+        self.0
+    }
+    fn type_idx(&self) -> usize {
+        self.1
+    }
+}
+
 #[derive(Debug)]
 pub(crate) struct SchemaStore {
     schemas: Vec<(String, SchemaDocument)>,
 }
+
+impl SchemaStore {
+    pub(crate) fn get_schema(&self, schema_idx: usize) -> &SchemaDocument {
+        &self.schemas[schema_idx].1
+    }
+}