progress

Author: edg-l

src/ir/lowering/lower.rs

@@ -11,13 +11,7 @@ use crate::{
 };
 
 use super::{
-    IRBuilderContext, Symbol,
-    adts::{lower_enum, lower_struct},
-    constants::lower_constant,
-    functions::{lower_func, lower_func_decl},
-    ir::{IR, ModuleIndex, Type},
-    traits::{TraitDatabase, TraitImpl},
-    types::lower_type,
+    adts::{lower_enum, lower_struct}, constants::lower_constant, functions::{lower_func, lower_func_decl}, ir::{ModuleIndex, Type, IR}, traits::{TraitDatabase, TraitGeneric, TraitImpl}, types::lower_type, IRBuilderContext, Symbol
 };
 
 /// Lowers the ast compile units, the last should be the "main" unit whose unit tests are saved.
@@ -632,16 +626,47 @@ pub fn lower_module(
                         path: builder.get_current_module().file_path.clone(),
                     })?;
 
+                let mut trait_generics = Vec::new();
+
+                for g in &impl_trait.generic_params {
+                    if let Some(ty) = builder.context.generics_mapping.get(&g.name.name) {
+                        trait_generics.push(TraitGeneric::Type(*ty));
+                    } else {
+                        trait_generics.push(TraitGeneric::Generic);
+                    }
+                }
+
+                let target_ty = if !impl_trait.generic_params.is_empty() {
+                    let adt_symbol = Symbol {
+                        name: impl_trait.target.get_name().unwrap(),
+                        method_of: None,
+                        generics: Vec::new(),
+                    };
+
+                    let id = *builder
+                        .symbols
+                        .get(&builder.get_current_module_idx())
+                        .unwrap()
+                        .aggregates
+                        .get(&adt_symbol)
+                        .unwrap();
+
+                    let type_id = *builder.adt_to_type_idx.get(&id).unwrap();
+                    type_id
+                } else {
+                    lower_type(builder, &impl_trait.target)?
+                };
+
+                builder.trait_db.add_trait_impl(
+                    trait_id,
+                    TraitImpl {
+                        implementor: target_ty,
+                        generics: trait_generics,
+                    },
+                );
+
                 if impl_trait.generic_params.is_empty() {
-                    let target_ty = lower_type(builder, &impl_trait.target)?;
                     builder.context.self_ty = Some(target_ty);
-                    builder.trait_db.add_trait_impl(
-                        trait_id,
-                        TraitImpl {
-                            implementor: target_ty,
-                            generics: Vec::new(),
-                        },
-                    );
                     for method in &impl_trait.methods {
                         if method.decl.generic_params.is_empty() {
                             lower_func(builder, method, Some(target_ty))?;

src/ir/lowering/traits.rs

@@ -4,7 +4,7 @@ use typed_generational_arena::{StandardSlab, StandardSlabIndex};
 
 use crate::{
     ast::traits::TraitDecl,
-    ir::{FnIndex, ModuleIndex, TypeIndex},
+    ir::{ModuleIndex, TypeIndex},
 };
 
 pub type TraitIdx = StandardSlabIndex<Arc<TraitDecl>>;
@@ -26,7 +26,13 @@ pub struct TraitDatabase {
 #[derive(Debug, Clone)]
 pub struct TraitImpl {
     pub implementor: TypeIndex,
-    pub generics: Vec<TypeIndex>,
+    pub generics: Vec<TraitGeneric>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum TraitGeneric {
+    Generic,
+    Type(TypeIndex),
 }
 
 impl Default for TraitDatabase {
@@ -72,7 +78,7 @@ impl TraitDatabase {
         &self,
         ty: TypeIndex,
         check_trait: TraitIdx,
-        generics: &[TypeIndex],
+        generics: &[TraitGeneric],
     ) -> bool {
         if let Some(t) = self.implementors.get(&check_trait.to_idx()) {
             if let Some(impls) = t.get(&ty.to_idx()) {