Replace ProcFlags and VarTypeFlags::to_vec() with iter()

Author: SpaceManiac

crates/dreammaker/src/ast.rs

@@ -419,12 +419,23 @@ impl ProcFlags {
         self.contains(ProcFlags::FINAL)
     }
 
-    pub fn to_vec(&self) -> Vec<&'static str> {
-        let mut v = Vec::new();
-        if self.is_final() {
-            v.push("final");
+    pub fn iter(&self) -> impl Iterator<Item = &'static str> {
+        struct ProcFlagsIter(ProcFlags);
+
+        impl Iterator for ProcFlagsIter {
+            type Item = &'static str;
+
+            fn next(&mut self) -> Option<Self::Item> {
+                if self.0.is_final() {
+                    self.0 &= !ProcFlags::FINAL;
+                    Some("final")
+                } else {
+                    None
+                }
+            }
         }
-        v
+
+        ProcFlagsIter(*self)
     }
 }
 
@@ -646,27 +657,38 @@ impl VarTypeFlags {
         !self.intersects(VarTypeFlags::CONST | VarTypeFlags::STATIC | VarTypeFlags::PROTECTED)
     }
 
-    pub fn to_vec(&self) -> Vec<&'static str> {
-        let mut v = Vec::new();
-        if self.is_static() {
-            v.push("static");
-        }
-        if self.is_const() {
-            v.push("const");
-        }
-        if self.is_tmp() {
-            v.push("tmp");
-        }
-        if self.is_final() {
-            v.push("final");
-        }
-        if self.is_private() {
-            v.push("SpacemanDMM_private");
-        }
-        if self.is_protected() {
-            v.push("SpacemanDMM_protected");
+    pub fn iter(&self) -> impl Iterator<Item = &'static str> {
+        struct VarTypeFlagsIter(VarTypeFlags);
+
+        impl Iterator for VarTypeFlagsIter {
+            type Item = &'static str;
+
+            fn next(&mut self) -> Option<Self::Item> {
+                if self.0.is_static() {
+                    self.0 &= !VarTypeFlags::STATIC;
+                    Some("static")
+                } else if self.0.is_const() {
+                    self.0 &= !VarTypeFlags::CONST;
+                    Some("const")
+                } else if self.0.is_tmp() {
+                    self.0 &= !VarTypeFlags::TMP;
+                    Some("tmp")
+                } else if self.0.is_final() {
+                    self.0 &= !VarTypeFlags::FINAL;
+                    Some("final")
+                } else if self.0.is_private() {
+                    self.0 &= !VarTypeFlags::PRIVATE;
+                    Some("SpacemanDMM_private")
+                } else if self.0.is_protected() {
+                    self.0 &= !VarTypeFlags::PROTECTED;
+                    Some("SpacemanDMM_protected")
+                } else {
+                    None
+                }
+            }
         }
-        v
+
+        VarTypeFlagsIter(*self)
     }
 }
 

crates/dreammaker/src/constants.rs

@@ -1098,7 +1098,7 @@ impl<'a> ConstantFolder<'a> {
             .collect();
         // Only tricky bit is adding on the type if required
         if let Some(declaration) = proc_ref.get_declaration() {
-            path_elements.push(declaration.kind.name().into());
+            path_elements.push(declaration.kind.into());
         }
         path_elements.push(proc_ref.name().to_owned().into());
         Ok(Constant::Prefab(Box::new(Pop::from(Box::from(

crates/dreammaker/src/objtree.rs

@@ -547,7 +547,7 @@ impl<'o> NavigatePathResult<'o> {
             .collect();
         match self {
             NavigatePathResult::Type(_) => {},
-            NavigatePathResult::ProcGroup(_, kind) => path.push(kind.name().into()),
+            NavigatePathResult::ProcGroup(_, kind) => path.push(kind.into()),
             NavigatePathResult::ProcPath(proc, kind) => {
                 path.push(kind.into());
                 path.push(Ident::from_nonstatic(proc.name()));

crates/dreammaker/src/parser.rs

@@ -2888,22 +2888,18 @@ fn reconstruct_path(
 ) -> Vec<Ident> {
     let mut result: Vec<Ident> = Vec::new();
     for entry in node.split('/').skip(1) {
-        result.push(entry.to_owned().into());
+        result.push(Ident::from_nonstatic(entry));
     }
     if let Some(deets) = proc_deets {
-        result.push(deets.kind.name().into());
-        deets
-            .flags
-            .to_vec()
-            .into_iter()
-            .for_each(|elem| result.push(elem.into()));
+        result.push(deets.kind.into());
+        result.extend(deets.flags.iter().map(From::from));
     }
     if let Some(var) = var_type {
-        result.extend(var.flags.to_vec().into_iter().map(From::from));
+        result.extend(var.flags.iter().map(From::from));
         result.extend(var.type_path.iter().cloned());
     }
     if !last.is_empty() {
-        result.push(last.to_owned().into());
+        result.push(Ident::from_nonstatic(last));
     }
     result
 }