Converted polymorph collection to use index set instead of hash set

Author: IsaacShelton

Diff for: src/resolve/collect_polymorphs.rs

@@ -1,35 +1,35 @@
-use crate::asg::{self};
-use std::collections::HashSet;
+use crate::asg::{Type, TypeKind};
+use indexmap::IndexSet;
 
-pub fn collect_polymorphs(map: &mut HashSet<String>, ty: &asg::Type) {
+pub fn collect_polymorphs(map: &mut IndexSet<String>, ty: &Type) {
     match &ty.kind {
-        asg::TypeKind::Unresolved => panic!(),
-        asg::TypeKind::Boolean
-        | asg::TypeKind::Integer(_, _)
-        | asg::TypeKind::CInteger(_, _)
-        | asg::TypeKind::IntegerLiteral(_)
-        | asg::TypeKind::FloatLiteral(_)
-        | asg::TypeKind::Floating(_) => (),
-        asg::TypeKind::Ptr(inner) => collect_polymorphs(map, inner.as_ref()),
-        asg::TypeKind::Void => (),
-        asg::TypeKind::Never => (),
-        asg::TypeKind::AnonymousStruct() => todo!(),
-        asg::TypeKind::AnonymousUnion() => todo!(),
-        asg::TypeKind::AnonymousEnum(_) => (),
-        asg::TypeKind::FixedArray(fixed_array) => collect_polymorphs(map, &fixed_array.inner),
-        asg::TypeKind::FuncPtr(_) => todo!(),
-        asg::TypeKind::Enum(_, _) => (),
-        asg::TypeKind::Structure(_, _, params) | asg::TypeKind::TypeAlias(_, _, params) => {
+        TypeKind::Unresolved => panic!(),
+        TypeKind::Boolean
+        | TypeKind::Integer(_, _)
+        | TypeKind::CInteger(_, _)
+        | TypeKind::IntegerLiteral(_)
+        | TypeKind::FloatLiteral(_)
+        | TypeKind::Floating(_) => (),
+        TypeKind::Ptr(inner) => collect_polymorphs(map, inner.as_ref()),
+        TypeKind::Void => (),
+        TypeKind::Never => (),
+        TypeKind::AnonymousStruct() => todo!(),
+        TypeKind::AnonymousUnion() => todo!(),
+        TypeKind::AnonymousEnum(_) => (),
+        TypeKind::FixedArray(fixed_array) => collect_polymorphs(map, &fixed_array.inner),
+        TypeKind::FuncPtr(_) => todo!(),
+        TypeKind::Enum(_, _) => (),
+        TypeKind::Structure(_, _, params) | TypeKind::TypeAlias(_, _, params) => {
             for parameter in params {
                 collect_polymorphs(map, parameter);
             }
         }
-        asg::TypeKind::Polymorph(name) => {
+        TypeKind::Polymorph(name) => {
             if !map.contains(name) {
                 map.insert(name.into());
             }
         }
-        asg::TypeKind::Trait(_, _, parameters) => {
+        TypeKind::Trait(_, _, parameters) => {
             for parameter in parameters {
                 collect_polymorphs(map, parameter);
             }

Diff for: src/resolve/impl_head/for_alls.rs

@@ -1,15 +1,16 @@
 use crate::{resolve::error::ResolveError, source_files::Source};
-use std::collections::{HashMap, HashSet};
+use indexmap::IndexSet;
+use std::collections::HashMap;
 
 #[derive(Debug, Default)]
 pub struct ForAlls {
-    substitution_polys: HashSet<String>,
+    substitution_polys: IndexSet<String>,
     trait_to_impl: HashMap<String, String>,
     impl_to_trait: HashMap<String, String>,
 }
 
 impl ForAlls {
-    pub fn new(substitution_polys: HashSet<String>) -> Self {
+    pub fn new(substitution_polys: IndexSet<String>) -> Self {
         Self {
             substitution_polys,
             trait_to_impl: Default::default(),

Diff for: src/resolve/impl_head/mod.rs

@@ -13,7 +13,8 @@ use crate::{
     workspace::fs::FsNodeId,
 };
 use for_alls::ForAlls;
-use std::collections::{HashMap, HashSet};
+use indexmap::IndexSet;
+use std::collections::HashMap;
 
 pub fn create_impl_heads(
     ctx: &mut ResolveCtx,
@@ -98,7 +99,7 @@ fn ensure_satisfies_trait_func(
         ));
     }
 
-    let mut mappings = HashSet::new();
+    let mut mappings = IndexSet::new();
     for sub in expected.values() {
         collect_polymorphs(&mut mappings, sub);
     }