Make self mapping more error-proof (#163)

* Fix self mapping

* lint

src/hir/declarations/trait.rs

@@ -11,6 +11,7 @@ use indexmap::IndexMap;
 
 use crate::{
     compilation::Module,
+    hir::SelfType,
     named::Named,
     syntax::{Identifier, Keyword, Ranged},
     AddSourceLocation,
@@ -25,6 +26,13 @@ pub struct Trait {
     inner: Arc<RwLock<TraitData>>,
 }
 
+impl Trait {
+    /// Get self type for this trait
+    pub fn self_type(&self) -> SelfType {
+        SelfType::for_trait(self.clone())
+    }
+}
+
 impl DataHolder for Trait {
     type Data = TraitData;
 

src/hir/types.rs

@@ -4,10 +4,7 @@ use std::{
     fmt::{Debug, Display},
 };
 
-use crate::{
-    mutability::Mutable, named::Named, syntax::Identifier,
-    AddSourceLocation,
-};
+use crate::{mutability::Mutable, named::Named, syntax::Identifier, AddSourceLocation};
 
 use super::{Basename, BuiltinClass, Class, Generic, Member, Trait, TypeReference};
 use derive_more::{Display, From, TryInto};
@@ -108,6 +105,13 @@ pub struct SelfType {
     pub associated_trait: Trait,
 }
 
+impl SelfType {
+    /// Create new self type for trait
+    pub fn for_trait(associated_trait: Trait) -> Self {
+        Self { associated_trait }
+    }
+}
+
 impl PartialEq for SelfType {
     fn eq(&self, other: &Self) -> bool {
         self.associated_trait == other.associated_trait

src/semantics/contexts/context.rs

@@ -2,7 +2,7 @@ use std::fmt::Display;
 
 use crate::{
     compilation::Compiler,
-    hir::{Function, FunctionData, FunctionNamePart, ModuleData, SelfType, Type, Typed},
+    hir::{Function, FunctionData, FunctionNamePart, ModuleData, Type, Typed},
     semantics::{AddDeclaration, ConvertibleTo, FindDeclaration, Implements},
 };
 
@@ -64,10 +64,7 @@ pub trait Context: FindDeclaration + AddDeclaration + Display {
     where
         Self: Sized,
     {
-        let self_ty: Type = SelfType {
-            associated_trait: trait_fn.tr.clone().unwrap(),
-        }
-        .into();
+        let self_ty: Type = trait_fn.tr.clone().unwrap().self_type().into();
         let mut context = GenericContext::for_generics(vec![self_ty.clone()], self);
         if let Some(concrete) = self_type_specialization.clone() {
             context.map_generic(self_ty, concrete);

src/semantics/contexts/generic.rs

@@ -25,12 +25,10 @@ impl<'p> GenericContext<'p> {
     pub fn for_fn(f: &FunctionData, parent: &'p mut impl Context) -> Self {
         let mut candidate_context = Self::for_generics(f.generic_types.clone(), parent);
 
-        if let Some(ty) = f
-            .parameters()
-            .map(|p| p.ty())
-            .find(|ty| matches!(ty, Type::SelfType(_)))
-        {
-            candidate_context.generic_parameters.push(ty);
+        if let Some(tr) = &f.tr {
+            candidate_context
+                .generic_parameters
+                .push(tr.self_type().into());
         }
 
         return candidate_context;

src/semantics/contexts/trait.rs

@@ -1,7 +1,7 @@
 use std::fmt::Display;
 
 use crate::{
-    hir::{Class, Function, SelfType, Trait, Type, Variable},
+    hir::{Class, Function, Trait, Type, Variable},
     named::Named,
     semantics::{AddDeclaration, FindDeclaration, FindDeclarationHere},
 };
@@ -43,12 +43,7 @@ impl FindDeclarationHere for TraitContext<'_> {
             return None;
         }
 
-        Some(
-            SelfType {
-                associated_trait: self.tr.clone(),
-            }
-            .into(),
-        )
+        Some(self.tr.self_type().into())
     }
 
     fn functions_with_n_name_parts_here(&self, n: usize) -> Vec<Function> {