Added error message for attempting to require implementation parameters on main function, as well as cleaned up some implementation parameter code

IsaacShelton · IsaacShelton · commit 35ce0a2c7394 · 2025-01-26T23:46:47.000-06:00
diff --git a/src/asg/func.rs b/src/asg/func.rs
@@ -1,5 +1,4 @@
 use crate::{asg::*, name::ResolvedName, source_files::Source, tag::Tag};
-use indexmap::IndexMap;
 use std::{collections::HashSet, fmt::Display};
 
 #[derive(Clone, Debug)]
@@ -47,11 +46,6 @@ impl<'a> CurrentConstraints {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct ImplParams {
-    pub params: IndexMap<String, GenericTraitRef>,
-}
-
 #[derive(Clone, Debug)]
 pub struct Func {
     pub name: ResolvedName,
diff --git a/src/asg/impl_params.rs b/src/asg/impl_params.rs
@@ -0,0 +1,25 @@
+use super::GenericTraitRef;
+use crate::index_map_ext::IndexMapExt;
+use indexmap::IndexMap;
+
+#[derive(Clone, Debug)]
+pub struct ImplParams {
+    params: IndexMap<String, GenericTraitRef>,
+}
+
+impl ImplParams {
+    pub fn new(params: IndexMap<String, GenericTraitRef>) -> Self {
+        Self { params }
+    }
+    pub fn iter(&self) -> impl Iterator<Item = (&String, &GenericTraitRef)> {
+        self.params.iter()
+    }
+
+    pub fn get(&self, key: &str) -> Option<&GenericTraitRef> {
+        self.params.get(key)
+    }
+
+    pub fn has_items(&self) -> bool {
+        self.params.has_items()
+    }
+}
diff --git a/src/asg/mod.rs b/src/asg/mod.rs
@@ -8,6 +8,7 @@ mod generic_trait_ref;
 mod global;
 mod helper_expr;
 mod human_name;
+mod impl_params;
 mod implementation;
 mod overload;
 mod stmt;
@@ -29,6 +30,7 @@ pub use generic_trait_ref::*;
 pub use global::*;
 pub use helper_expr::*;
 pub use human_name::*;
+pub use impl_params::*;
 pub use implementation::*;
 pub use overload::*;
 use slotmap::{new_key_type, SlotMap};
diff --git a/src/index_map_ext.rs b/src/index_map_ext.rs
@@ -12,6 +12,8 @@ pub trait IndexMapExt<K: Equivalent<K> + Hash + Eq, V> {
     fn get_or_insert_with(&mut self, key: K, make_val: impl Fn() -> V) -> &mut V;
 
     fn insert_or_panic(&mut self, key: K, value: V);
+
+    fn has_items(&self) -> bool;
 }
 
 impl<K: Equivalent<K> + Hash + Eq, V> IndexMapExt<K, V> for IndexMap<K, V> {
@@ -38,4 +40,8 @@ impl<K: Equivalent<K> + Hash + Eq, V> IndexMapExt<K, V> for IndexMap<K, V> {
     fn insert_or_panic(&mut self, key: K, value: V) {
         assert!(self.insert(key, value).is_none());
     }
+
+    fn has_items(&self) -> bool {
+        !self.is_empty()
+    }
 }
diff --git a/src/resolve/expr/call/infer_impl.rs b/src/resolve/expr/call/infer_impl.rs
@@ -13,7 +13,7 @@ pub fn infer_callee_missing_impl_args(
     catalog: &mut PolyCatalog,
     source: Source,
 ) -> Result<(), ResolveError> {
-    for (expected_name, expected_trait) in function.impl_params.params.iter() {
+    for (expected_name, expected_trait) in function.impl_params.iter() {
         if used_names.contains(expected_name) {
             continue;
         }
@@ -27,7 +27,6 @@ pub fn infer_callee_missing_impl_args(
 
         let from_env = caller
             .impl_params
-            .params
             .iter()
             .filter_map(|(param_name, param_trait)| {
                 if catalog
diff --git a/src/resolve/expr/call/specified_impl.rs b/src/resolve/expr/call/specified_impl.rs
@@ -99,7 +99,7 @@ fn resolve_polymorph_impl_arg(
         .get(current_func_ref)
         .expect("referenced function to exist");
 
-    let Some(arg_concrete_trait) = caller.impl_params.params.get(polymorph) else {
+    let Some(arg_concrete_trait) = caller.impl_params.get(polymorph) else {
         return Err(ResolveError::other(
             format!("Undefined implementation polymorph '${}'", polymorph),
             impl_arg_source,
@@ -135,7 +135,6 @@ fn try_register_specified_impl(
         None => Sourced::new(
             callee_func
                 .impl_params
-                .params
                 .iter()
                 .filter(|(param_name, param)| {
                     param.trait_ref == arg_concrete_trait.trait_ref
@@ -157,7 +156,7 @@ fn try_register_specified_impl(
     }
     .clone();
 
-    let Some(param_generic_trait) = impl_params.params.get(target_param.inner().as_str()) else {
+    let Some(param_generic_trait) = impl_params.get(target_param.inner().as_str()) else {
         return Err(ResolveError::other(
             format!(
                 "No implementation parameter named '${}' exists on callee",
diff --git a/src/resolve/expr/static_member.rs b/src/resolve/expr/static_member.rs
@@ -239,7 +239,7 @@ pub fn resolve_static_member_call_polymorph(
         .get(func_ref)
         .expect("referenced function to exist");
 
-    let Some(generic_trait_ref) = func.impl_params.params.get(polymorph) else {
+    let Some(generic_trait_ref) = func.impl_params.get(polymorph) else {
         return Err(ResolveError::other(
             format!("Undeclared implementation '${}'", polymorph),
             *source,
diff --git a/src/resolve/func_head.rs b/src/resolve/func_head.rs
@@ -104,6 +104,15 @@ pub fn create_func_head<'a>(
 
     let impl_params = create_func_impl_params(&type_ctx, head)?;
 
+    let is_main = options.coerce_main_signature && head.name == "main";
+
+    if is_main && impl_params.has_items() {
+        return Err(ResolveError::other(
+            "Main function cannot have implementation parameters",
+            head.source,
+        ));
+    }
+
     Ok(asg.funcs.insert(asg::Func {
         name,
         params,
@@ -113,9 +122,7 @@ pub fn create_func_head<'a>(
         vars: VariableStorage::new(),
         source: head.source,
         abide_abi: head.abide_abi,
-        tag: head.tag.or_else(|| {
-            (options.coerce_main_signature && head.name == "main").then_some(Tag::Main)
-        }),
+        tag: head.tag.or_else(|| is_main.then_some(Tag::Main)),
         is_generic,
         constraints: CurrentConstraints::new(constraints),
         impl_params,
@@ -178,5 +185,5 @@ pub fn create_func_impl_params(
         }
     }
 
-    Ok(ImplParams { params })
+    Ok(ImplParams::new(params))
 }
diff --git a/src/resolve/impl_head/for_alls.rs b/src/resolve/impl_head/for_alls.rs
@@ -0,0 +1,58 @@
+use crate::{resolve::error::ResolveError, source_files::Source};
+use std::collections::{HashMap, HashSet};
+
+#[derive(Debug, Default)]
+pub struct ForAlls {
+    substitution_polys: HashSet<String>,
+    trait_to_impl: HashMap<String, String>,
+    impl_to_trait: HashMap<String, String>,
+}
+
+impl ForAlls {
+    pub fn new(substitution_polys: HashSet<String>) -> Self {
+        Self {
+            substitution_polys,
+            trait_to_impl: Default::default(),
+            impl_to_trait: Default::default(),
+        }
+    }
+
+    pub fn insert(
+        &mut self,
+        in_trait: String,
+        in_impl: String,
+        source: Source,
+    ) -> Result<(), ResolveError> {
+        if self.substitution_polys.contains(&in_impl) {
+            return Err(ResolveError::other("Inconsistent mapping", source));
+        }
+
+        if let Some(expected) = self.trait_to_impl.get(&in_trait) {
+            if *expected != in_impl {
+                return Err(ResolveError::other("Inconsistent mapping", source));
+            }
+        }
+
+        if let Some(expected) = self.impl_to_trait.get(&in_impl) {
+            if *expected != in_trait {
+                return Err(ResolveError::other("Inconsistent mapping", source));
+            }
+        }
+
+        if self.trait_to_impl.contains_key(&in_trait) && self.impl_to_trait.contains_key(&in_impl) {
+            // Already exists, and is correct
+            return Ok(());
+        }
+
+        if !self
+            .trait_to_impl
+            .insert(in_trait.clone(), in_impl.clone())
+            .is_none()
+            || !self.impl_to_trait.insert(in_impl, in_trait).is_none()
+        {
+            return Err(ResolveError::other("Inconsistent mapping", source));
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/resolve/impl_head/mod.rs b/src/resolve/impl_head/mod.rs
@@ -1,3 +1,4 @@
+mod for_alls;
 use super::{
     collect_constraints::collect_constraints_into, ctx::ResolveCtx, error::ResolveError,
     func_head::create_func_head, job::FuncJob,
@@ -8,11 +9,11 @@ use crate::{
     cli::BuildOptions,
     name::{Name, ResolvedName},
     resolve::{error::ResolveErrorKind, type_ctx::ResolveTypeCtx},
-    source_files::Source,
     workspace::fs::FsNodeId,
 };
+use for_alls::ForAlls;
 use indexmap::IndexMap;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 pub fn create_impl_heads(
     ctx: &mut ResolveCtx,
@@ -83,74 +84,26 @@ pub fn create_impl_heads(
     Ok(())
 }
 
-#[derive(Debug, Default)]
-struct ForAlls {
-    substitution_polys: HashSet<String>,
-    trait_to_impl: HashMap<String, String>,
-    impl_to_trait: HashMap<String, String>,
-}
-
-impl ForAlls {
-    pub fn insert(
-        &mut self,
-        in_trait: String,
-        in_impl: String,
-        source: Source,
-    ) -> Result<(), ResolveError> {
-        if self.substitution_polys.contains(&in_impl) {
-            return Err(ResolveError::other("Inconsistent mapping", source));
-        }
-
-        if let Some(expected) = self.trait_to_impl.get(&in_trait) {
-            if *expected != in_impl {
-                return Err(ResolveError::other("Inconsistent mapping", source));
-            }
-        }
-
-        if let Some(expected) = self.impl_to_trait.get(&in_impl) {
-            if *expected != in_trait {
-                return Err(ResolveError::other("Inconsistent mapping", source));
-            }
-        }
-
-        if self.trait_to_impl.contains_key(&in_trait) && self.impl_to_trait.contains_key(&in_impl) {
-            // Already exists, and is correct
-            return Ok(());
-        }
-
-        if !self
-            .trait_to_impl
-            .insert(in_trait.clone(), in_impl.clone())
-            .is_none()
-            || !self.impl_to_trait.insert(in_impl, in_trait).is_none()
-        {
-            return Err(ResolveError::other("Inconsistent mapping", source));
-        }
-
-        Ok(())
-    }
-}
-
 fn ensure_satisfies_trait_func(
     ctx: &ResolveCtx,
     asg: &Asg,
     expected: HashMap<&str, &Type>,
     trait_func: &TraitFunc,
     impl_func: &Func,
 ) -> Result<(), ResolveError> {
-    if !impl_func.impl_params.params.is_empty() {
+    if impl_func.impl_params.has_items() {
         return Err(ResolveError::other(
             "Implementation parameter is not allowed by trait definition",
             impl_func.source,
         ));
     }
 
-    let mut for_alls = ForAlls::default();
     let mut mappings = HashMap::new();
     for sub in expected.values() {
         collect_constraints_into(&mut mappings, sub);
     }
-    for_alls.substitution_polys = mappings.into_keys().collect();
+
+    let mut for_alls = ForAlls::new(mappings.into_keys().collect());
 
     if trait_func.params.is_cstyle_vararg != impl_func.params.is_cstyle_vararg {
         return Err(ResolveError::other(

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@ pub trait IndexMapExt<K: Equivalent<K> + Hash + Eq, V> {`
`12`	`12`	`fn get_or_insert_with(&mut self, key: K, make_val: impl Fn() -> V) -> &mut V;`
`13`	`13`
`14`	`14`	`fn insert_or_panic(&mut self, key: K, value: V);`
	`15`	`+`
	`16`	`+ fn has_items(&self) -> bool;`
`15`	`17`	`}`
`16`	`18`
`17`	`19`	`impl<K: Equivalent<K> + Hash + Eq, V> IndexMapExt<K, V> for IndexMap<K, V> {`
`@@ -38,4 +40,8 @@ impl<K: Equivalent<K> + Hash + Eq, V> IndexMapExt<K, V> for IndexMap<K, V> {`
`38`	`40`	`fn insert_or_panic(&mut self, key: K, value: V) {`
`39`	`41`	`assert!(self.insert(key, value).is_none());`
`40`	`42`	`}`
	`43`	`+`
	`44`	`+ fn has_items(&self) -> bool {`
	`45`	`+ !self.is_empty()`
	`46`	`+ }`
`41`	`47`	`}`