Add the concept of semantic similarity to the type system

sway-core/src/ir_generation/const_eval.rs

@@ -148,7 +148,7 @@ fn const_eval_typed_expr(
         TypedExpressionVariant::StructExpression { fields, .. } => {
             let (field_typs, field_vals): (Vec<_>, Vec<_>) = fields
                 .iter()
-                .filter_map(|TypedStructExpressionField { name: _, value }| {
+                .filter_map(|TypedStructExpressionField { name: _, value, .. }| {
                     const_eval_typed_expr(context, module, known_consts, value)
                         .map(|cv| (value.return_type, cv))
                 })

sway-core/src/parse_tree/declaration/type_parameter.rs

@@ -2,7 +2,10 @@ use crate::{error::*, parse_tree::*, semantic_analysis::*, type_engine::*};
 
 use sway_types::{ident::Ident, span::Span, Spanned};
 
-use std::hash::{Hash, Hasher};
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+};
 
 #[derive(Debug, Clone, Eq)]
 pub struct TypeParameter {
@@ -57,6 +60,12 @@ impl ReplaceSelfType for TypeParameter {
     }
 }
 
+impl fmt::Display for TypeParameter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: {}", self.name_ident, self.type_id)
+    }
+}
+
 impl TypeParameter {
     pub(crate) fn type_check(
         type_parameter: TypeParameter,

sway-core/src/semantic_analysis/ast_node/declaration/monomorphize.rs

@@ -64,7 +64,7 @@ where
 
     fn monomorphize(
         self,
-        type_arguments: Vec<TypeArgument>,
+        mut type_arguments: Vec<TypeArgument>,
         enforce_type_arguments: EnforceTypeArguments,
         self_type: Option<TypeId>,
         call_site_span: Option<&Span>,
@@ -107,7 +107,6 @@ where
                 err(warnings, errors)
             }
             (false, false) => {
-                let mut type_arguments = type_arguments;
                 for type_argument in type_arguments.iter_mut() {
                     let type_id = match self_type {
                         Some(self_type) => namespace.resolve_type_with_self(
@@ -191,13 +190,15 @@ pub(crate) trait MonomorphizeHelper {
     fn monomorphize_inner(self, type_mapping: &TypeMapping, namespace: &mut Items) -> Self::Output;
 }
 
-pub(crate) fn monomorphize_inner<T>(decl: T, type_mapping: &TypeMapping, namespace: &mut Items) -> T
+pub(crate) fn monomorphize_inner<T>(
+    decl: T,
+    type_mapping: &TypeMapping,
+    _namespace: &mut Items,
+) -> T
 where
     T: CopyTypes + CreateTypeId,
 {
-    let old_type_id = decl.create_type_id();
     let mut new_decl = decl;
     new_decl.copy_types(type_mapping);
-    namespace.copy_methods_to_type(old_type_id, new_decl.create_type_id(), type_mapping);
     new_decl
 }

sway-core/src/semantic_analysis/namespace/items.rs

@@ -138,33 +138,6 @@ impl Items {
             .get_methods_for_type(implementing_for_type_id)
     }
 
-    // Given a TypeInfo old_type with a set of methods available to it, make those same methods
-    // available to TypeInfo new_type. This is useful in situations where old_type is being
-    // monomorphized to new_type and and we want `get_methods_for_type()` to return the same set of
-    // methods for new_type as it does for old_type.
-    pub(crate) fn copy_methods_to_type(
-        &mut self,
-        old_type: TypeId,
-        new_type: TypeId,
-        type_mapping: &TypeMapping,
-    ) {
-        // This map grabs all (trait name, vec of methods) from self.implemented_traits
-        // corresponding to `old_type`.
-        let methods = self
-            .implemented_traits
-            .get_methods_for_type_by_trait(old_type);
-
-        // Insert into `self.implemented_traits` the contents of the map above but with `new_type`
-        // as the `TypeInfo` key.
-        for (trait_name, mut trait_methods) in methods.into_iter() {
-            trait_methods
-                .iter_mut()
-                .for_each(|method| method.copy_types(type_mapping));
-            self.implemented_traits
-                .insert(trait_name, new_type, trait_methods);
-        }
-    }
-
     pub(crate) fn get_canonical_path(&self, symbol: &Ident) -> &[Ident] {
         self.use_synonyms.get(symbol).map(|v| &v[..]).unwrap_or(&[])
     }

sway-core/src/semantic_analysis/namespace/trait_map.rs

@@ -1,10 +1,8 @@
 use crate::{
-    type_engine::{look_up_type_id, TypeId},
+    type_engine::{create_type_mapping, look_up_type_id, CopyTypes, TypeId},
     CallPath, TypeInfo, TypedFunctionDeclaration,
 };
 
-use std::collections::HashMap;
-
 type TraitName = CallPath;
 
 // This cannot be a HashMap because of how TypeInfo's are handled.
@@ -46,8 +44,7 @@ impl TraitMap {
     ) {
         let mut methods_map = im::HashMap::new();
         for method in methods.into_iter() {
-            let method_name = method.name.as_str().to_string();
-            methods_map.insert(method_name, method);
+            methods_map.insert(method.name.as_str().to_string(), method);
         }
         self.trait_map
             .push_back(((trait_name, incoming_type_id), methods_map));
@@ -69,7 +66,7 @@ impl TraitMap {
     ) -> Vec<((CallPath, TypeId), Vec<TypedFunctionDeclaration>)> {
         let mut ret = vec![];
         for ((call_path, map_type_id), methods) in self.trait_map.iter() {
-            if look_up_type_id(*map_type_id) == look_up_type_id(incoming_type_id) {
+            if look_up_type_id(incoming_type_id).is_subset_of(&look_up_type_id(*map_type_id)) {
                 ret.push((
                     (call_path.clone(), *map_type_id),
                     methods.values().cloned().collect(),
@@ -88,29 +85,14 @@ impl TraitMap {
         if look_up_type_id(incoming_type_id) == TypeInfo::ErrorRecovery {
             return methods;
         }
-        for ((_, map_type_id), l_methods) in self.trait_map.iter() {
-            if look_up_type_id(*map_type_id) == look_up_type_id(incoming_type_id) {
-                methods.append(&mut l_methods.values().cloned().collect());
-            }
-        }
-        methods
-    }
-
-    pub(crate) fn get_methods_for_type_by_trait(
-        &self,
-        incoming_type_id: TypeId,
-    ) -> HashMap<TraitName, Vec<TypedFunctionDeclaration>> {
-        let mut methods: HashMap<TraitName, Vec<TypedFunctionDeclaration>> = HashMap::new();
-        // small performance gain in bad case
-        if look_up_type_id(incoming_type_id) == TypeInfo::ErrorRecovery {
-            return methods;
-        }
-        for ((trait_name, map_type_id), trait_methods) in self.trait_map.iter() {
-            if look_up_type_id(*map_type_id) == look_up_type_id(incoming_type_id) {
-                methods.insert(
-                    (*trait_name).clone(),
-                    trait_methods.values().cloned().collect(),
-                );
+        for ((_, map_type_id), trait_methods) in self.trait_map.iter() {
+            if look_up_type_id(incoming_type_id).is_subset_of(&look_up_type_id(*map_type_id)) {
+                let type_mapping = create_type_mapping(*map_type_id, incoming_type_id);
+                let mut trait_methods = trait_methods.values().cloned().collect::<Vec<_>>();
+                trait_methods
+                    .iter_mut()
+                    .for_each(|x| x.copy_types(&type_mapping));
+                methods.append(&mut trait_methods);
             }
         }
         methods