Adds suggested changes

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/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)
         }

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

@@ -18,14 +18,17 @@ pub struct TypeReference {
 }
 
 impl TypeReference {
-    fn new<S: Into<String>>(type_name: S) -> 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()),
@@ -46,14 +49,15 @@ impl TypeReference {
         self.resolved_type_coordinates
     }
 
-    pub(crate) fn resolve_type_coordinates(&mut self, type_coordinates: Option<TypeCoordinates>) {
+    /// 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::new(value)
+        TypeReference::local(value)
     }
 }
 
@@ -110,7 +114,7 @@ mod tests {
     #[test]
     fn from_string() {
         let from_value = "foo";
-        let expected = TypeReference::new("foo");
+        let expected = TypeReference::local("foo");
         assert_eq!(expected, from_value.into())
     }
 
@@ -126,7 +130,7 @@ mod tests {
     }
 
     #[rstest]
-    #[case::type_name("foo", TypeReference::new("foo"))]
+    #[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);