Made Self be workable as an impl. (#7116)

corelib/src/iter/traits/iterator.cairo

@@ -129,9 +129,7 @@ pub trait Iterator<T> {
     /// }
     /// ```
     #[inline]
-    fn map<
-        B, F, impl TIter: Self, +core::ops::Fn<F, (TIter::Item,)>[Output: B], +Drop<T>, +Drop<F>,
-    >(
+    fn map<B, F, +core::ops::Fn<F, (Self::Item,)>[Output: B], +Drop<T>, +Drop<F>>(
         self: T, f: F,
     ) -> Map<T, F> {
         mapped_iterator(self, f)

crates/cairo-lang-doc/src/parser.rs

@@ -306,9 +306,6 @@ impl ToDocumentableItemId<DocumentableItemId> for ResolvedGenericItem {
                 Some(DocumentableItemId::Crate(id))
             }
             ResolvedGenericItem::Variant(variant) => Some(DocumentableItemId::Variant(variant.id)),
-            ResolvedGenericItem::TraitFunction(id) => Some(DocumentableItemId::LookupItem(
-                LookupItemId::TraitItem(TraitItemId::Function(id)),
-            )),
             ResolvedGenericItem::GenericFunction(GenericFunctionId::Impl(generic_impl_func)) => {
                 if let Some(impl_function) = generic_impl_func.impl_function(db).ok().flatten() {
                     Some(DocumentableItemId::LookupItem(LookupItemId::ImplItem(
@@ -320,11 +317,6 @@ impl ToDocumentableItemId<DocumentableItemId> for ResolvedGenericItem {
                     )))
                 }
             }
-            ResolvedGenericItem::GenericFunction(GenericFunctionId::Trait(trait_func)) => {
-                Some(DocumentableItemId::LookupItem(LookupItemId::TraitItem(
-                    TraitItemId::Function(trait_func.trait_function(db)),
-                )))
-            }
             ResolvedGenericItem::Variable(_) => None,
         }
     }

crates/cairo-lang-lowering/src/db.rs

@@ -814,7 +814,6 @@ fn type_size(db: &dyn LoweringGroup, ty: TypeId) -> usize {
         TypeLongId::GenericParameter(_)
         | TypeLongId::Var(_)
         | TypeLongId::ImplType(_)
-        | TypeLongId::TraitType(_)
         | TypeLongId::Missing(_) => {
             panic!("Function should only be called with fully concrete types")
         }

crates/cairo-lang-semantic/src/corelib.rs

@@ -456,10 +456,6 @@ pub fn unwrap_error_propagation_type(
         | TypeLongId::Missing(_)
         | TypeLongId::FixedSizeArray { .. }
         | TypeLongId::Closure(_) => None,
-        // TODO(yuval): for trait function default implementation, this may need to change.
-        TypeLongId::TraitType(_) => {
-            panic!("Trait types should only appear in traits, where there are no function bodies.")
-        }
     }
 }
 

crates/cairo-lang-semantic/src/diagnostic.rs

@@ -1481,7 +1481,6 @@ pub enum ElementKind {
     Variable,
     Module,
     Function,
-    TraitFunction,
     Type,
     Variant,
     Trait,
@@ -1493,10 +1492,11 @@ impl From<&ResolvedConcreteItem> for ElementKind {
             ResolvedConcreteItem::Constant(_) => ElementKind::Constant,
             ResolvedConcreteItem::Module(_) => ElementKind::Module,
             ResolvedConcreteItem::Function(_) => ElementKind::Function,
-            ResolvedConcreteItem::TraitFunction(_) => ElementKind::TraitFunction,
             ResolvedConcreteItem::Type(_) => ElementKind::Type,
             ResolvedConcreteItem::Variant(_) => ElementKind::Variant,
-            ResolvedConcreteItem::Trait(_) => ElementKind::Trait,
+            ResolvedConcreteItem::Trait(_) | ResolvedConcreteItem::SelfTrait(_) => {
+                ElementKind::Trait
+            }
             ResolvedConcreteItem::Impl(_) => ElementKind::Impl,
         }
     }
@@ -1507,7 +1507,6 @@ impl From<&ResolvedGenericItem> for ElementKind {
             ResolvedGenericItem::GenericConstant(_) => ElementKind::Constant,
             ResolvedGenericItem::Module(_) => ElementKind::Module,
             ResolvedGenericItem::GenericFunction(_) => ElementKind::Function,
-            ResolvedGenericItem::TraitFunction(_) => ElementKind::TraitFunction,
             ResolvedGenericItem::GenericType(_) | ResolvedGenericItem::GenericTypeAlias(_) => {
                 ElementKind::Type
             }
@@ -1527,7 +1526,6 @@ impl Display for ElementKind {
             ElementKind::Variable => "variable",
             ElementKind::Module => "module",
             ElementKind::Function => "function",
-            ElementKind::TraitFunction => "function",
             ElementKind::Type => "type",
             ElementKind::Variant => "variant",
             ElementKind::Trait => "trait",

crates/cairo-lang-semantic/src/expr/compute.rs

@@ -2948,9 +2948,6 @@ fn member_access_expr(
             .diagnostics
             .report(&rhs_syntax, TypeHasNoMembers { ty: long_ty.intern(ctx.db), member_name })),
         TypeLongId::Missing(diag_added) => Err(*diag_added),
-        TypeLongId::TraitType(_) => {
-            panic!("Trait types should only appear in traits, where there are no function bodies.")
-        }
     }
 }
 
@@ -3691,7 +3688,6 @@ pub fn compute_statement_semantic(
                             }
                             ResolvedGenericItem::Module(_)
                             | ResolvedGenericItem::GenericFunction(_)
-                            | ResolvedGenericItem::TraitFunction(_)
                             | ResolvedGenericItem::GenericTypeAlias(_)
                             | ResolvedGenericItem::GenericImplAlias(_)
                             | ResolvedGenericItem::Variant(_)

crates/cairo-lang-semantic/src/expr/inference.rs

@@ -1062,7 +1062,7 @@ impl<'db> Inference<'db> {
             ImplLongId::GenericParameter(_)
             | ImplLongId::ImplVar(_)
             | ImplLongId::ImplImpl(_)
-            | ImplLongId::TraitImpl(_) => Ok(SolutionSet::Unique(canonical_impl)),
+            | ImplLongId::SelfImpl(_) => Ok(SolutionSet::Unique(canonical_impl)),
         }
     }
 
@@ -1230,7 +1230,7 @@ impl SemanticRewriter<TypeLongId, NoError> for Inference<'_> {
                 let impl_id = impl_type_id.impl_id();
                 let trait_ty = impl_type_id.ty();
                 return Ok(match impl_id.lookup_intern(self.db) {
-                    ImplLongId::GenericParameter(_) | ImplLongId::TraitImpl(_) => {
+                    ImplLongId::GenericParameter(_) | ImplLongId::SelfImpl(_) => {
                         impl_type_id_rewrite_result
                     }
                     ImplLongId::ImplImpl(impl_impl) => {
@@ -1296,7 +1296,7 @@ impl SemanticRewriter<ConstValue, NoError> for Inference<'_> {
                 let trait_constant = impl_constant_id.trait_constant_id();
                 return Ok(match impl_id.lookup_intern(self.db) {
                     ImplLongId::GenericParameter(_)
-                    | ImplLongId::TraitImpl(_)
+                    | ImplLongId::SelfImpl(_)
                     | ImplLongId::GeneratedImpl(_) => impl_constant_id_rewrite_result,
                     ImplLongId::ImplImpl(impl_impl) => {
                         // The grand parent impl must be var free since we are rewriting the parent,
@@ -1349,7 +1349,7 @@ impl SemanticRewriter<ImplLongId, NoError> for Inference<'_> {
                 let impl_id = impl_impl_id.impl_id();
                 return Ok(match impl_id.lookup_intern(self.db) {
                     ImplLongId::GenericParameter(_)
-                    | ImplLongId::TraitImpl(_)
+                    | ImplLongId::SelfImpl(_)
                     | ImplLongId::GeneratedImpl(_) => impl_impl_id_rewrite_result,
                     ImplLongId::ImplImpl(impl_impl) => {
                         // The grand parent impl must be var free since we are rewriting the parent,

crates/cairo-lang-semantic/src/expr/inference/conform.rs

@@ -196,11 +196,6 @@ impl InferenceConform for Inference<'_> {
             TypeLongId::GenericParameter(_) => {
                 Err(self.set_error(InferenceError::TypeKindMismatch { ty0, ty1 }))
             }
-            TypeLongId::TraitType(_) => {
-                // This should never happen as the trait type should be implized when conformed, but
-                // don't panic in case of a bug.
-                Err(self.set_error(InferenceError::TypeKindMismatch { ty0, ty1 }))
-            }
             TypeLongId::Var(var) => Ok((self.assign_ty(var, ty1)?, 0)),
             TypeLongId::ImplType(impl_type) => {
                 if let Some(ty) = self.impl_type_bounds.get(&impl_type.into()) {
@@ -385,7 +380,7 @@ impl InferenceConform for Inference<'_> {
             }
             ImplLongId::GenericParameter(_)
             | ImplLongId::ImplImpl(_)
-            | ImplLongId::TraitImpl(_)
+            | ImplLongId::SelfImpl(_)
             | ImplLongId::GeneratedImpl(_) => {
                 Err(self.set_error(InferenceError::ImplKindMismatch { impl0, impl1 }))
             }
@@ -467,7 +462,10 @@ impl InferenceConform for Inference<'_> {
                 &concrete_impl_id.lookup_intern(self.db).generic_args,
                 var,
             ),
-            ImplLongId::GenericParameter(_) | ImplLongId::TraitImpl(_) => false,
+            ImplLongId::SelfImpl(concrete_trait_id) => {
+                self.generic_args_contain_var(&concrete_trait_id.generic_args(self.db), var)
+            }
+            ImplLongId::GenericParameter(_) => false,
             ImplLongId::ImplVar(new_var) => {
                 let new_var_long_id = new_var.lookup_intern(self.db);
                 let new_var_local_id = new_var_long_id.id;
@@ -695,9 +693,7 @@ impl Inference<'_> {
                 false
             }
             TypeLongId::ImplType(id) => self.impl_contains_var(id.impl_id(), var),
-            TypeLongId::TraitType(_) | TypeLongId::GenericParameter(_) | TypeLongId::Missing(_) => {
-                false
-            }
+            TypeLongId::GenericParameter(_) | TypeLongId::Missing(_) => false,
             TypeLongId::Coupon(function_id) => self.function_contains_var(function_id, var),
             TypeLongId::FixedSizeArray { type_id, .. } => {
                 self.internal_ty_contains_var(type_id, var)

crates/cairo-lang-semantic/src/items/constant.rs

@@ -116,7 +116,6 @@ pub enum ConstValue {
     Boxed(Box<ConstValue>),
     Generic(#[dont_rewrite] GenericParamId),
     ImplConstant(ImplConstantId),
-    TraitConstant(TraitConstantId),
     Var(ConstVar, TypeId),
     /// A missing value, used in cases where the value is not known due to diagnostics.
     Missing(#[dont_rewrite] DiagnosticAdded),
@@ -136,19 +135,15 @@ impl ConstValue {
                 ConstValue::Generic(_)
                 | ConstValue::Var(_, _)
                 | ConstValue::Missing(_)
-                | ConstValue::ImplConstant(_)
-                | ConstValue::TraitConstant(_) => false,
+                | ConstValue::ImplConstant(_) => false,
             }
     }
 
     /// Returns true if the const does not contain any inference variables.
     pub fn is_var_free(&self, db: &dyn SemanticGroup) -> bool {
         self.ty(db).unwrap().is_var_free(db)
             && match self {
-                ConstValue::Int(_, _)
-                | ConstValue::Generic(_)
-                | ConstValue::Missing(_)
-                | ConstValue::TraitConstant(_) => true,
+                ConstValue::Int(_, _) | ConstValue::Generic(_) | ConstValue::Missing(_) => true,
                 ConstValue::Struct(members, _) => {
                     members.iter().all(|member| member.is_var_free(db))
                 }
@@ -178,7 +173,6 @@ impl ConstValue {
             ConstValue::ImplConstant(impl_constant_id) => {
                 db.impl_constant_concrete_implized_type(*impl_constant_id)?
             }
-            ConstValue::TraitConstant(trait_constant) => db.trait_constant_type(*trait_constant)?,
         })
     }
 
@@ -610,7 +604,6 @@ impl ConstantEvaluateContext<'_> {
                 }
                 self.db.trait_function_signature(id.function)
             }
-            GenericFunctionId::Trait(id) => db.trait_function_signature(id.trait_function(db)),
         })();
         if signature.map(|s| s.is_const) == Ok(true) {
             return true;

crates/cairo-lang-semantic/src/items/fmt.rs

@@ -46,7 +46,6 @@ impl<Db: ?Sized + Upcast<dyn SemanticGroup + 'static>> DebugWithDb<Db> for Const
             ConstValue::Var(var, _) => write!(f, "?{}", var.id.0),
             ConstValue::Missing(_) => write!(f, "missing"),
             ConstValue::ImplConstant(id) => id.fmt(f, db),
-            ConstValue::TraitConstant(id) => id.fmt(f, db),
         }
     }
 }

crates/cairo-lang-semantic/src/items/functions.rs

@@ -58,7 +58,7 @@ impl ImplGenericFunctionId {
             ImplLongId::GenericParameter(_)
             | ImplLongId::ImplVar(_)
             | ImplLongId::ImplImpl(_)
-            | ImplLongId::TraitImpl(_)
+            | ImplLongId::SelfImpl(_)
             | ImplLongId::GeneratedImpl(_) => Ok(None),
         }
     }
@@ -85,7 +85,6 @@ pub enum GenericFunctionId {
     Extern(ExternFunctionId),
     /// A generic function of an impl.
     Impl(ImplGenericFunctionId),
-    Trait(ConcreteTraitGenericFunctionId),
 }
 impl GenericFunctionId {
     pub fn from_generic_with_body(
@@ -104,7 +103,12 @@ impl GenericFunctionId {
                 };
                 GenericFunctionId::Impl(ImplGenericFunctionId { impl_id, function })
             }
-            GenericFunctionWithBodyId::Trait(id) => GenericFunctionId::Trait(id),
+            GenericFunctionWithBodyId::Trait(id) => {
+                GenericFunctionId::Impl(ImplGenericFunctionId {
+                    impl_id: ImplLongId::SelfImpl(id.concrete_trait(db)).intern(db),
+                    function: id.trait_function(db),
+                })
+            }
         })
     }
     pub fn format(&self, db: &dyn SemanticGroup) -> String {
@@ -115,13 +119,6 @@ impl GenericFunctionId {
             GenericFunctionId::Impl(id) => {
                 format!("{:?}::{}", id.impl_id.debug(db.elongate()), id.function.name(defs_db))
             }
-            GenericFunctionId::Trait(id) => {
-                format!(
-                    "{}::{}",
-                    id.concrete_trait(db).full_path(db),
-                    id.trait_function(db).name(defs_db)
-                )
-            }
         }
     }
     pub fn generic_signature(&self, db: &dyn SemanticGroup) -> Maybe<Signature> {
@@ -137,7 +134,6 @@ impl GenericFunctionId {
                 let substitution = &GenericSubstitution::from_impl(id.impl_id);
                 SubstitutionRewriter { db, substitution }.rewrite(signature)
             }
-            GenericFunctionId::Trait(id) => db.concrete_trait_function_signature(id),
         }
     }
     pub fn generic_params(&self, db: &dyn SemanticGroup) -> Maybe<Vec<GenericParam>> {
@@ -149,17 +145,13 @@ impl GenericFunctionId {
                 let id = ConcreteTraitGenericFunctionId::new(db, concrete_trait_id, id.function);
                 db.concrete_trait_function_generic_params(id)
             }
-            GenericFunctionId::Trait(id) => db.concrete_trait_function_generic_params(id),
         }
     }
     pub fn name(&self, db: &dyn SemanticGroup) -> SmolStr {
         match self {
             GenericFunctionId::Free(free_function) => free_function.name(db.upcast()),
             GenericFunctionId::Extern(extern_function) => extern_function.name(db.upcast()),
             GenericFunctionId::Impl(impl_function) => impl_function.format(db.upcast()),
-            GenericFunctionId::Trait(trait_function) => {
-                trait_function.trait_function(db).name(db.upcast())
-            }
         }
     }
     /// Returns the ModuleFileId of the function's definition if possible.
@@ -181,17 +173,13 @@ impl GenericFunctionId {
                     None
                 }
             }
-            GenericFunctionId::Trait(trait_function) => Some(
-                trait_function.trait_function(db).trait_id(db.upcast()).module_file_id(db.upcast()),
-            ),
         }
     }
     /// Returns whether the function has the `#[must_use]` attribute.
     pub fn is_must_use(&self, db: &dyn SemanticGroup) -> Maybe<bool> {
         match self {
             GenericFunctionId::Free(id) => id.has_attr(db, MUST_USE_ATTR),
             GenericFunctionId::Impl(id) => id.function.has_attr(db, MUST_USE_ATTR),
-            GenericFunctionId::Trait(id) => id.trait_function(db).has_attr(db, MUST_USE_ATTR),
             GenericFunctionId::Extern(_) => Ok(false),
         }
     }
@@ -202,7 +190,6 @@ impl GenericFunctionId {
             GenericFunctionId::Impl(impl_generic_function) => {
                 impl_generic_function.impl_id.is_fully_concrete(db)
             }
-            GenericFunctionId::Trait(_) => false,
         }
     }
     /// Returns true if the function does not depend on impl or type variables.
@@ -212,7 +199,6 @@ impl GenericFunctionId {
             GenericFunctionId::Impl(impl_generic_function) => {
                 impl_generic_function.impl_id.is_var_free(db)
             }
-            GenericFunctionId::Trait(_) => false,
         }
     }
 }
@@ -245,7 +231,6 @@ impl DebugWithDb<dyn SemanticGroup> for GenericFunctionId {
             GenericFunctionId::Free(func) => write!(f, "{:?}", func.debug(db)),
             GenericFunctionId::Extern(func) => write!(f, "{:?}", func.debug(db)),
             GenericFunctionId::Impl(func) => write!(f, "{:?}", func.debug(db)),
-            GenericFunctionId::Trait(func) => write!(f, "{:?}", func.debug(db)),
         }
     }
 }
@@ -391,7 +376,6 @@ impl GenericFunctionWithBodyId {
                     },
                 })
             }
-            GenericFunctionId::Trait(id) => GenericFunctionWithBodyId::Trait(id),
             _ => return Ok(None),
         }))
     }

crates/cairo-lang-semantic/src/items/generics.rs

@@ -13,7 +13,7 @@ use cairo_lang_syntax as syntax;
 use cairo_lang_syntax::node::ast::{AssociatedItemConstraints, OptionAssociatedItemConstraints};
 use cairo_lang_syntax::node::{Terminal, TypedSyntaxNode, ast};
 use cairo_lang_utils::ordered_hash_map::{Entry, OrderedHashMap};
-use cairo_lang_utils::{Intern, LookupIntern, extract_matches, try_extract_matches};
+use cairo_lang_utils::{Intern, LookupIntern, extract_matches};
 use syntax::node::TypedStablePtr;
 use syntax::node::db::SyntaxGroup;
 
@@ -583,10 +583,9 @@ fn impl_generic_param_semantic(
 ) -> GenericParamImpl {
     let concrete_trait = resolver
         .resolve_concrete_path(diagnostics, path_syntax, NotFoundItemType::Trait)
-        .and_then(|resolved_item| {
-            try_extract_matches!(resolved_item, ResolvedConcreteItem::Trait).ok_or_else(|| {
-                diagnostics.report(path_syntax, SemanticDiagnosticKind::UnknownTrait)
-            })
+        .and_then(|resolved_item| match resolved_item {
+            ResolvedConcreteItem::Trait(id) | ResolvedConcreteItem::SelfTrait(id) => Ok(id),
+            _ => Err(diagnostics.report(path_syntax, SemanticDiagnosticKind::UnknownTrait)),
         });
     let type_constraints = concrete_trait
         .ok()