Added ability to import and access public trait implementations from other modules

Author: IsaacShelton

Diff for: src/asg/implementation.rs

@@ -1,5 +1,5 @@
-use super::{FuncRef, GenericTraitRef};
-use crate::source_files::Source;
+use super::{FuncRef, GenericTraitRef, ImplRef};
+use crate::{ast::Privacy, source_files::Source};
 use indexmap::IndexMap;
 use std::collections::HashMap;
 
@@ -10,3 +10,10 @@ pub struct Impl {
     pub source: Source,
     pub body: HashMap<String, FuncRef>,
 }
+
+#[derive(Clone, Debug)]
+pub struct ImplDecl {
+    pub impl_ref: ImplRef,
+    pub source: Source,
+    pub privacy: Privacy,
+}

Diff for: src/resolve/ctx.rs

@@ -11,7 +11,7 @@ pub struct ResolveCtx {
     pub globals_in_modules: HashMap<FsNodeId, HashMap<String, asg::GlobalVarDecl>>,
     pub helper_exprs_in_modules: HashMap<FsNodeId, HashMap<String, asg::HelperExprDecl>>,
     pub trait_haystacks: HashMap<FsNodeId, HashMap<String, asg::TraitRef>>,
-    pub impls_in_modules: HashMap<FsNodeId, HashMap<String, asg::ImplRef>>,
+    pub impls_in_modules: HashMap<FsNodeId, HashMap<String, asg::ImplDecl>>,
 }
 
 impl ResolveCtx {

Diff for: src/resolve/error.rs

@@ -221,6 +221,9 @@ pub enum ResolveErrorKind {
     DuplicateTypeName {
         name: String,
     },
+    DuplicateImplementationName {
+        name: String,
+    },
     CannotCreateOutOfRangeFloat,
     TypeAliasesCannotContainPolymorphs,
     FailedToConformArgumentToDefaultValue,
@@ -563,6 +566,9 @@ impl Display for ResolveErrorKind {
             ResolveErrorKind::DuplicateTypeName { name } => {
                 write!(f, "Duplicate type name '{}'", name)?;
             }
+            ResolveErrorKind::DuplicateImplementationName { name } => {
+                write!(f, "Duplicate implementation name '{}'", name)?;
+            }
             ResolveErrorKind::CannotCreateOutOfRangeFloat => {
                 write!(f, "Cannot create out-of-range floating-point number")?;
             }

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

@@ -61,7 +61,7 @@ pub struct ResolveExprCtx<'ast, 'root_ctx> {
     pub types_in_modules: &'root_ctx HashMap<FsNodeId, HashMap<String, asg::TypeDecl>>,
     pub globals_in_modules: &'root_ctx HashMap<FsNodeId, HashMap<String, asg::GlobalVarDecl>>,
     pub helper_exprs_in_modules: &'root_ctx HashMap<FsNodeId, HashMap<String, asg::HelperExprDecl>>,
-    pub impls_in_modules: &'root_ctx HashMap<FsNodeId, HashMap<String, asg::ImplRef>>,
+    pub impls_in_modules: &'root_ctx HashMap<FsNodeId, HashMap<String, asg::ImplDecl>>,
     pub module_fs_node_id: FsNodeId,
     pub physical_fs_node_id: FsNodeId,
     pub current_constraints: CurrentConstraints,

Diff for: src/resolve/expr/static_member.rs

@@ -91,24 +91,54 @@ pub fn resolve_impl_mention(
     impl_args: &[TypeArg],
     source: Source,
 ) -> Result<(ImplRef, PolyCatalog), ResolveError> {
-    let Some(impl_name) = impl_name.as_plain_str() else {
-        return Err(ResolveError::other("Invalid implementation name", source));
-    };
+    let impl_decl = impl_name.as_plain_str().and_then(|impl_name| {
+        ctx.impls_in_modules
+            .get(&ctx.module_fs_node_id)
+            .and_then(|impls| impls.get(impl_name))
+    });
+
+    let impl_decl = impl_decl.ok_or(()).or_else(|_| {
+        let mut matches = (!impl_name.namespace.is_empty())
+            .then(|| {
+                ctx.settings
+                    .namespace_to_dependency
+                    .get(impl_name.namespace.as_ref())
+            })
+            .flatten()
+            .into_iter()
+            .flatten()
+            .flat_map(|dependency| {
+                ctx.settings
+                    .dependency_to_module
+                    .get(dependency)
+                    .and_then(|module_fs_node_id| ctx.impls_in_modules.get(module_fs_node_id))
+                    .and_then(|imp| imp.get(impl_name.basename.as_ref()))
+                    .filter(|imp| imp.privacy.is_public())
+                    .into_iter()
+            });
+
+        let Some(imp) = matches.next() else {
+            return Err(ResolveError::other(
+                format!("Undefined trait implementation '{}'", impl_name),
+                source,
+            ));
+        };
 
-    let impl_ref = ctx
-        .impls_in_modules
-        .get(&ctx.module_fs_node_id)
-        .and_then(|impls| impls.get(impl_name));
+        if matches.next().is_some() {
+            return Err(ResolveError::other(
+                format!("Ambiguous trait implementation '{}'", impl_name),
+                source,
+            ));
+        }
 
-    let Some(imp) = impl_ref.and_then(|found| ctx.asg.impls.get(*found)) else {
-        return Err(ResolveError::other(
-            format!("Undefined trait implementation '{}'", impl_name),
-            source,
-        ));
-    };
+        Ok(imp)
+    })?;
 
-    // Guaranteed to be valid now
-    let impl_ref = impl_ref.unwrap();
+    let imp = ctx
+        .asg
+        .impls
+        .get(impl_decl.impl_ref)
+        .expect("public impl of impl decl to exist");
 
     if imp.name_params.len() != impl_args.len() {
         return Err(ResolveError::other(
@@ -135,7 +165,7 @@ pub fn resolve_impl_mention(
         }
     }
 
-    Ok((*impl_ref, catalog))
+    Ok((impl_decl.impl_ref, catalog))
 }
 
 pub fn resolve_static_member_call_named(

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

@@ -4,11 +4,14 @@ use super::{
     func_head::create_func_head, job::FuncJob,
 };
 use crate::{
-    asg::{self, Asg, CurrentConstraints, Func, GenericTraitRef, TraitFunc, Type},
-    ast::{self, AstFile},
+    asg::{
+        self, Asg, CurrentConstraints, Func, GenericTraitRef, ImplDecl, ImplRef, TraitFunc, Type,
+    },
+    ast::{self, AstFile, Privacy},
     cli::BuildOptions,
     name::{Name, ResolvedName},
     resolve::{error::ResolveErrorKind, type_ctx::ResolveTypeCtx},
+    source_files::Source,
     workspace::fs::FsNodeId,
 };
 use for_alls::ForAlls;
@@ -305,16 +308,16 @@ fn matches(
 pub fn create_impl_head<'a>(
     ctx: &mut ResolveCtx,
     asg: &mut Asg<'a>,
-    module_file_id: FsNodeId,
-    physical_file_id: FsNodeId,
+    module_fs_node_id: FsNodeId,
+    physical_fs_node_id: FsNodeId,
     imp: &ast::Impl,
 ) -> Result<asg::ImplRef, ResolveError> {
     let pre_parameters_constraints = CurrentConstraints::new_empty();
 
     let type_ctx = ResolveTypeCtx::new(
         &asg,
-        module_file_id,
-        physical_file_id,
+        module_fs_node_id,
+        physical_fs_node_id,
         &ctx.types_in_modules,
         &pre_parameters_constraints,
     );
@@ -399,18 +402,14 @@ pub fn create_impl_head<'a>(
         .as_ref()
         .map_or("<unnamed impl>", |name| name.as_str());
 
-    if ctx
-        .impls_in_modules
-        .entry(module_file_id)
-        .or_default()
-        .insert(name.to_string(), impl_ref)
-        .is_some()
-    {
-        return Err(ResolveErrorKind::Other {
-            message: format!("Duplicate implementation name '{}'", name),
-        }
-        .at(imp.source));
-    };
+    declare_impl(
+        ctx,
+        module_fs_node_id,
+        name,
+        imp.source,
+        imp.privacy,
+        impl_ref,
+    )?;
 
     Ok(impl_ref)
 }
@@ -428,3 +427,34 @@ fn into_trait(ty: &Type) -> Result<GenericTraitRef, ResolveError> {
         args: args.clone(),
     })
 }
+
+fn declare_impl(
+    ctx: &mut ResolveCtx,
+    module_fs_node_id: FsNodeId,
+    name: &str,
+    source: Source,
+    privacy: Privacy,
+    impl_ref: ImplRef,
+) -> Result<(), ResolveError> {
+    if ctx
+        .impls_in_modules
+        .entry(module_fs_node_id)
+        .or_default()
+        .insert(
+            name.to_string(),
+            ImplDecl {
+                impl_ref,
+                privacy,
+                source,
+            },
+        )
+        .is_some()
+    {
+        return Err(ResolveErrorKind::DuplicateImplementationName {
+            name: name.to_string(),
+        }
+        .at(source));
+    };
+
+    Ok(())
+}

Diff for: tests/success/cast_trait/main.adept

@@ -6,26 +6,18 @@ pragma => {
 }
 
 #[foreign]
-func printf(format ptr<char>, ...) int
+func printf(format ptr#char, ...) int
 
 func main {
-    castTest(1234)::(myCastIntToDouble, myCastIntToLongLong)
+    castTest(1234)::(std/castI32ToDouble, std/castI32ToLongLong)
 }
 
-#[using std/Cast<int, double>]
-#[using std/Cast<int, longlong>]
-func castTest(x int) {
+#[using std/Cast<i32, double>]
+#[using std/Cast<i32, longlong>]
+func castTest(x i32) {
+    printf(c"With long form generics syntax:\n")
     printf(c"%d %f %lld\n", x, x.cast<double>(), x.cast<longlong>())
+    printf(c"With shorthand generics syntax:\n")
+    printf(c"%d %f %lld\n", x, x.cast#double(), x.cast#longlong())
 }
 
-impl std/Cast<int, double> myCastIntToDouble {
-    func cast(from int) double {
-        return from.double()
-    }
-}
-
-impl std/Cast<int, longlong> myCastIntToLongLong {
-    func cast(from int) longlong {
-        return from.longlong()
-    }
-}