Added basic error message for attempting to use undeclared polymorphs inside structure definitions

Author: IsaacShelton

Diff for: src/asg/datatype/kind/mod.rs

@@ -117,6 +117,44 @@ impl TypeKind {
         }
     }
 
+    pub fn for_each_polymorph(&self, f: &mut impl FnMut(&str) -> ()) {
+        match self {
+            TypeKind::Unresolved => panic!("unresolved type"),
+            TypeKind::Boolean
+            | TypeKind::Integer(_, _)
+            | TypeKind::CInteger(_, _)
+            | TypeKind::IntegerLiteral(_)
+            | TypeKind::FloatLiteral(_)
+            | TypeKind::Floating(_) => (),
+            TypeKind::Ptr(inner) => inner.kind.for_each_polymorph(f),
+            TypeKind::Void
+            | TypeKind::Never
+            | TypeKind::AnonymousStruct()
+            | TypeKind::AnonymousUnion()
+            | TypeKind::AnonymousEnum(_) => (),
+            TypeKind::FixedArray(fixed_array) => fixed_array.inner.kind.for_each_polymorph(f),
+            TypeKind::FuncPtr(func) => {
+                for param in func.params.required.iter() {
+                    param.ty.kind.for_each_polymorph(f);
+                }
+                func.return_type.kind.for_each_polymorph(f);
+            }
+            TypeKind::Enum(_, _) => (),
+            TypeKind::Structure(_, _, params) => {
+                for param in params.iter() {
+                    param.kind.for_each_polymorph(f);
+                }
+            }
+            TypeKind::TypeAlias(_, _) => (),
+            TypeKind::Polymorph(name, _) => f(name),
+            TypeKind::Trait(_, _, params) => {
+                for param in params.iter() {
+                    param.kind.for_each_polymorph(f);
+                }
+            }
+        }
+    }
+
     pub fn map_type_params<E>(
         &self,
         mut mapper: impl FnMut(TypeParam) -> Result<TypeParam, E>,

Diff for: src/resolve/type_definition/resolve.rs

@@ -119,6 +119,16 @@ fn resolve_structure(
         let ty =
             type_ctx.resolve_or_undeclared(&field.ast_type, ResolveTypeOptions::KeepAliases)?;
 
+        // TODO: CLEANUP: Cleanup this code
+        let mut ok = Ok(());
+        ty.kind.for_each_polymorph(&mut |name| {
+            if structure.params.params.keys().filter(|n| *n == name).next().is_none() {
+                ok = Err(ResolveError::other(format!("Cannot use polymorph '${}' inside type that is not declared by enclosing structure", name), ty.source));
+            }
+        });
+
+        ok?;
+
         let resolved_struct = asg.structs.get_mut(struct_ref).expect("valid struct");
 
         resolved_struct.fields.insert(