From 5643a5b3ec1eff47dc9216e59d25fe9022aafdb3 Mon Sep 17 00:00:00 2001 From: orizi <104711814+orizi@users.noreply.github.com> Date: Sun, 19 Jan 2025 23:40:43 +0100 Subject: [PATCH] Made `Self` be workable as an impl. (#7116) --- corelib/src/iter/traits/iterator.cairo | 4 +- crates/cairo-lang-doc/src/parser.rs | 8 - crates/cairo-lang-lowering/src/db.rs | 1 - crates/cairo-lang-semantic/src/corelib.rs | 4 - crates/cairo-lang-semantic/src/diagnostic.rs | 8 +- .../cairo-lang-semantic/src/expr/compute.rs | 4 - .../cairo-lang-semantic/src/expr/inference.rs | 8 +- .../src/expr/inference/conform.rs | 16 +- .../cairo-lang-semantic/src/items/constant.rs | 11 +- crates/cairo-lang-semantic/src/items/fmt.rs | 1 - .../src/items/functions.rs | 30 +--- .../cairo-lang-semantic/src/items/generics.rs | 9 +- crates/cairo-lang-semantic/src/items/imp.rs | 44 +++--- .../src/items/tests/trait_default_fn | 12 +- crates/cairo-lang-semantic/src/items/trt.rs | 25 ++-- .../cairo-lang-semantic/src/resolve/item.rs | 15 +- crates/cairo-lang-semantic/src/resolve/mod.rs | 140 ++++++++++-------- .../cairo-lang-semantic/src/substitution.rs | 66 +-------- crates/cairo-lang-semantic/src/types.rs | 18 +-- .../cairo-lang-sierra-generator/src/types.rs | 2 - .../cairo-lang-sierra-generator/src/utils.rs | 3 +- crates/cairo-lang-starknet/src/abi.rs | 1 - 22 files changed, 157 insertions(+), 273 deletions(-) diff --git a/corelib/src/iter/traits/iterator.cairo b/corelib/src/iter/traits/iterator.cairo index ce277dac754..b90a337154e 100644 --- a/corelib/src/iter/traits/iterator.cairo +++ b/corelib/src/iter/traits/iterator.cairo @@ -129,9 +129,7 @@ pub trait Iterator { /// } /// ``` #[inline] - fn map< - B, F, impl TIter: Self, +core::ops::Fn[Output: B], +Drop, +Drop, - >( + fn map[Output: B], +Drop, +Drop>( self: T, f: F, ) -> Map { mapped_iterator(self, f) diff --git a/crates/cairo-lang-doc/src/parser.rs b/crates/cairo-lang-doc/src/parser.rs index 3d2a0e2b58a..18501525701 100644 --- a/crates/cairo-lang-doc/src/parser.rs +++ b/crates/cairo-lang-doc/src/parser.rs @@ -306,9 +306,6 @@ impl ToDocumentableItemId 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 for ResolvedGenericItem { ))) } } - ResolvedGenericItem::GenericFunction(GenericFunctionId::Trait(trait_func)) => { - Some(DocumentableItemId::LookupItem(LookupItemId::TraitItem( - TraitItemId::Function(trait_func.trait_function(db)), - ))) - } ResolvedGenericItem::Variable(_) => None, } } diff --git a/crates/cairo-lang-lowering/src/db.rs b/crates/cairo-lang-lowering/src/db.rs index e9ac7f4aa6e..f9e1899c07d 100644 --- a/crates/cairo-lang-lowering/src/db.rs +++ b/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") } diff --git a/crates/cairo-lang-semantic/src/corelib.rs b/crates/cairo-lang-semantic/src/corelib.rs index f161a538073..f835220d39f 100644 --- a/crates/cairo-lang-semantic/src/corelib.rs +++ b/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.") - } } } diff --git a/crates/cairo-lang-semantic/src/diagnostic.rs b/crates/cairo-lang-semantic/src/diagnostic.rs index 9490c31765f..361d800a9bf 100644 --- a/crates/cairo-lang-semantic/src/diagnostic.rs +++ b/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", diff --git a/crates/cairo-lang-semantic/src/expr/compute.rs b/crates/cairo-lang-semantic/src/expr/compute.rs index 4decdfe6f22..c34effe5e73 100644 --- a/crates/cairo-lang-semantic/src/expr/compute.rs +++ b/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(_) diff --git a/crates/cairo-lang-semantic/src/expr/inference.rs b/crates/cairo-lang-semantic/src/expr/inference.rs index 17d0df63c06..65e2cf2eb95 100644 --- a/crates/cairo-lang-semantic/src/expr/inference.rs +++ b/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 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 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 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, diff --git a/crates/cairo-lang-semantic/src/expr/inference/conform.rs b/crates/cairo-lang-semantic/src/expr/inference/conform.rs index 6e7812ae6e4..3f9ef76fd5a 100644 --- a/crates/cairo-lang-semantic/src/expr/inference/conform.rs +++ b/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) diff --git a/crates/cairo-lang-semantic/src/items/constant.rs b/crates/cairo-lang-semantic/src/items/constant.rs index e4b9b1ef27c..5f595eef2af 100644 --- a/crates/cairo-lang-semantic/src/items/constant.rs +++ b/crates/cairo-lang-semantic/src/items/constant.rs @@ -116,7 +116,6 @@ pub enum ConstValue { Boxed(Box), 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,8 +135,7 @@ impl ConstValue { ConstValue::Generic(_) | ConstValue::Var(_, _) | ConstValue::Missing(_) - | ConstValue::ImplConstant(_) - | ConstValue::TraitConstant(_) => false, + | ConstValue::ImplConstant(_) => false, } } @@ -145,10 +143,7 @@ impl ConstValue { 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; diff --git a/crates/cairo-lang-semantic/src/items/fmt.rs b/crates/cairo-lang-semantic/src/items/fmt.rs index e25b5bfffce..7fdbfcbcaa2 100644 --- a/crates/cairo-lang-semantic/src/items/fmt.rs +++ b/crates/cairo-lang-semantic/src/items/fmt.rs @@ -46,7 +46,6 @@ impl> DebugWithDb 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), } } } diff --git a/crates/cairo-lang-semantic/src/items/functions.rs b/crates/cairo-lang-semantic/src/items/functions.rs index 65dc2ae0d3a..6f16d136155 100644 --- a/crates/cairo-lang-semantic/src/items/functions.rs +++ b/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 { @@ -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> { @@ -149,7 +145,6 @@ 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 { @@ -157,9 +152,6 @@ impl GenericFunctionId { 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,9 +173,6 @@ 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. @@ -191,7 +180,6 @@ impl GenericFunctionId { 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 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), })) } diff --git a/crates/cairo-lang-semantic/src/items/generics.rs b/crates/cairo-lang-semantic/src/items/generics.rs index f9dfcaa8e50..f842eaf5b46 100644 --- a/crates/cairo-lang-semantic/src/items/generics.rs +++ b/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() diff --git a/crates/cairo-lang-semantic/src/items/imp.rs b/crates/cairo-lang-semantic/src/items/imp.rs index 55b4bec3931..fbe5c233999 100644 --- a/crates/cairo-lang-semantic/src/items/imp.rs +++ b/crates/cairo-lang-semantic/src/items/imp.rs @@ -21,9 +21,7 @@ use cairo_lang_syntax::node::ast::OptionTypeClause; use cairo_lang_utils::ordered_hash_map::OrderedHashMap; use cairo_lang_utils::ordered_hash_set::OrderedHashSet; use cairo_lang_utils::unordered_hash_map::UnorderedHashMap; -use cairo_lang_utils::{ - Intern, LookupIntern, define_short_id, extract_matches, try_extract_matches, -}; +use cairo_lang_utils::{Intern, LookupIntern, define_short_id, extract_matches}; use itertools::{Itertools, chain, izip}; use smol_str::SmolStr; use syntax::attribute::structured::{Attribute, AttributeListStructurize}; @@ -170,7 +168,7 @@ pub enum ImplLongId { GenericParameter(GenericParamId), ImplVar(ImplVarId), ImplImpl(ImplImplId), - TraitImpl(TraitImplId), + SelfImpl(ConcreteTraitId), GeneratedImpl(GeneratedImplId), } impl ImplLongId { @@ -181,7 +179,7 @@ impl ImplLongId { ImplLongId::GenericParameter(_) | ImplLongId::ImplVar(_) | ImplLongId::ImplImpl(_) - | ImplLongId::TraitImpl(_) + | ImplLongId::SelfImpl(_) | ImplLongId::GeneratedImpl(_) => { return None; } @@ -204,7 +202,7 @@ impl ImplLongId { .unwrap_or_else(|_| "_".into()) ) .into(), - ImplLongId::TraitImpl(trait_impl) => trait_impl.name(db.upcast()), + ImplLongId::SelfImpl(trait_impl) => trait_impl.name(db.upcast()), ImplLongId::GeneratedImpl(generated_impl) => { format!("{:?}", generated_impl.debug(db.elongate())).into() } @@ -220,7 +218,9 @@ impl ImplLongId { } ImplLongId::ImplVar(var) => format!("{var:?}"), ImplLongId::ImplImpl(impl_impl) => format!("{:?}", impl_impl.debug(db.elongate())), - ImplLongId::TraitImpl(trait_impl) => format!("{:?}", trait_impl.debug(db.elongate())), + ImplLongId::SelfImpl(concrete_trait_id) => { + format!("{:?}", concrete_trait_id.debug(db.elongate())) + } ImplLongId::GeneratedImpl(generated_impl) => { format!("{:?}", generated_impl.debug(db.elongate())) } @@ -231,7 +231,8 @@ impl ImplLongId { pub fn is_var_free(&self, db: &dyn SemanticGroup) -> bool { match self { ImplLongId::Concrete(concrete_impl_id) => concrete_impl_id.is_var_free(db), - ImplLongId::GenericParameter(_) | ImplLongId::TraitImpl(_) => true, + ImplLongId::SelfImpl(concrete_trait_id) => concrete_trait_id.is_var_free(db), + ImplLongId::GenericParameter(_) => true, ImplLongId::ImplVar(_) => false, ImplLongId::ImplImpl(impl_impl) => impl_impl.impl_id().is_var_free(db), ImplLongId::GeneratedImpl(generated_impl) => { @@ -252,7 +253,7 @@ impl ImplLongId { ImplLongId::Concrete(concrete_impl_id) => concrete_impl_id.is_fully_concrete(db), ImplLongId::GenericParameter(_) => false, ImplLongId::ImplVar(_) => false, - ImplLongId::ImplImpl(_) | ImplLongId::TraitImpl(_) => false, + ImplLongId::ImplImpl(_) | ImplLongId::SelfImpl(_) => false, ImplLongId::GeneratedImpl(generated_impl) => { generated_impl.concrete_trait(db).is_fully_concrete(db) && generated_impl @@ -276,7 +277,7 @@ impl DebugWithDb for ImplLongId { ImplLongId::GenericParameter(param) => write!(f, "{:?}", param.debug(db)), ImplLongId::ImplVar(var) => write!(f, "?{}", var.lookup_intern(db).id.0), ImplLongId::ImplImpl(impl_impl) => write!(f, "{:?}", impl_impl.debug(db)), - ImplLongId::TraitImpl(trait_impl) => write!(f, "{:?}", trait_impl.debug(db)), + ImplLongId::SelfImpl(trait_impl) => write!(f, "{:?}", trait_impl.debug(db)), ImplLongId::GeneratedImpl(generated_impl) => { write!(f, "{:?}", generated_impl.debug(db)) } @@ -590,7 +591,7 @@ pub fn impl_concrete_trait(db: &dyn SemanticGroup, impl_id: ImplId) -> Maybe Ok(var.lookup_intern(db).concrete_trait_id), ImplLongId::ImplImpl(impl_impl) => db.impl_impl_concrete_trait(impl_impl), - ImplLongId::TraitImpl(trait_impl) => db.trait_impl_concrete_trait(trait_impl), + ImplLongId::SelfImpl(concrete_trait_id) => Ok(concrete_trait_id), ImplLongId::GeneratedImpl(generated_impl) => Ok(generated_impl.concrete_trait(db)), } } @@ -644,15 +645,12 @@ pub fn priv_impl_declaration_data_inner( let trait_path_syntax = impl_ast.trait_path(syntax_db); let concrete_trait = if resolve_trait { - match resolver.resolve_concrete_path( - &mut diagnostics, - &trait_path_syntax, - NotFoundItemType::Trait, - ) { - Ok(resolved_item) => try_extract_matches!(resolved_item, ResolvedConcreteItem::Trait) - .ok_or_else(|| diagnostics.report(&trait_path_syntax, NotATrait)), - Err(err) => Err(err), - } + resolver + .resolve_concrete_path(&mut diagnostics, &trait_path_syntax, NotFoundItemType::Trait) + .and_then(|resolved_item| match resolved_item { + ResolvedConcreteItem::Trait(id) | ResolvedConcreteItem::SelfTrait(id) => Ok(id), + _ => Err(diagnostics.report(&trait_path_syntax, SemanticDiagnosticKind::NotATrait)), + }) } else { Err(diagnostics.report(&trait_path_syntax, ImplRequirementCycle)) }; @@ -1306,7 +1304,7 @@ fn get_inner_types(db: &dyn SemanticGroup, ty: TypeId) -> Maybe> { TypeLongId::GenericParameter(_) => { return Err(skip_diagnostic()); } - TypeLongId::Var(_) | TypeLongId::TraitType(_) | TypeLongId::ImplType(_) => { + TypeLongId::Var(_) | TypeLongId::ImplType(_) => { panic!("Types should be fully resolved at this point.") } TypeLongId::Coupon(_) => vec![], @@ -2199,7 +2197,7 @@ pub fn impl_type_concrete_implized( }; concrete_impl } - ImplLongId::GenericParameter(_) | ImplLongId::TraitImpl(_) | ImplLongId::ImplVar(_) => { + ImplLongId::GenericParameter(_) | ImplLongId::SelfImpl(_) | ImplLongId::ImplVar(_) => { return Ok(TypeLongId::ImplType(impl_type_id).intern(db)); } ImplLongId::GeneratedImpl(generated) => { @@ -2462,7 +2460,7 @@ pub fn impl_constant_concrete_implized_type( } ImplLongId::ImplVar(var) => var.lookup_intern(db).concrete_trait_id, ImplLongId::ImplImpl(impl_impl) => db.impl_impl_concrete_trait(impl_impl)?, - ImplLongId::TraitImpl(trait_impl) => db.trait_impl_concrete_trait(trait_impl)?, + ImplLongId::SelfImpl(concrete_trait_id) => concrete_trait_id, ImplLongId::GeneratedImpl(generated_impl) => generated_impl.concrete_trait(db), }; diff --git a/crates/cairo-lang-semantic/src/items/tests/trait_default_fn b/crates/cairo-lang-semantic/src/items/tests/trait_default_fn index 3c8406d1c0d..7e2d0b3233e 100644 --- a/crates/cairo-lang-semantic/src/items/tests/trait_default_fn +++ b/crates/cairo-lang-semantic/src/items/tests/trait_default_fn @@ -86,7 +86,7 @@ error: Parameter of trait function `MyTrait::foo` can't be defined as mutable. //! > ========================================================================== -//! > Test default implementation with associated types. +//! > Test default implementation with using `Self` as an outside impl. //! > test_runner_name test_function_diagnostics(expect_diagnostics: false) @@ -98,12 +98,12 @@ fn foo() {} foo //! > module_code -pub trait MyTrait { - type Associated; - fn impl_required() -> Option; - fn default_impl() -> bool { - Self::impl_required().is_some() +trait MyTrait { + fn default_impl() { + bar::(); } } +fn bar<+MyTrait>() {} + //! > expected_diagnostics diff --git a/crates/cairo-lang-semantic/src/items/trt.rs b/crates/cairo-lang-semantic/src/items/trt.rs index d15365dce5e..d6bf740ae4d 100644 --- a/crates/cairo-lang-semantic/src/items/trt.rs +++ b/crates/cairo-lang-semantic/src/items/trt.rs @@ -16,19 +16,20 @@ use cairo_lang_syntax::node::{Terminal, TypedStablePtr, TypedSyntaxNode, ast}; use cairo_lang_utils::ordered_hash_map::OrderedHashMap; use cairo_lang_utils::ordered_hash_set::OrderedHashSet; use cairo_lang_utils::unordered_hash_map::UnorderedHashMap; -use cairo_lang_utils::{Intern, LookupIntern, define_short_id, try_extract_matches}; +use cairo_lang_utils::{Intern, LookupIntern, define_short_id}; use smol_str::SmolStr; use super::TraitOrImplContext; use super::function_with_body::{FunctionBodyData, get_implicit_precedence, get_inline_config}; use super::functions::{ - FunctionDeclarationData, GenericFunctionId, ImplicitPrecedence, InlineConfiguration, + FunctionDeclarationData, GenericFunctionId, ImplGenericFunctionId, ImplicitPrecedence, + InlineConfiguration, }; use super::generics::{ GenericParamsData, fmt_generic_args, generic_params_to_args, semantic_generic_params, semantic_generic_params_ex, }; -use super::imp::{GenericsHeadFilter, TraitFilter}; +use super::imp::{GenericsHeadFilter, ImplLongId, TraitFilter}; use crate::db::{SemanticGroup, get_resolver_data_options}; use crate::diagnostic::SemanticDiagnosticKind::{self, *}; use crate::diagnostic::{NotFoundItemType, SemanticDiagnostics, SemanticDiagnosticsBuilder}; @@ -1041,10 +1042,9 @@ pub fn priv_trait_impl_data( Resolver::with_data(db, parent_resolver_data.clone_with_inference_id(db, inference_id)); let concrete_trait = resolver .resolve_concrete_path(&mut diagnostics, &trait_path, NotFoundItemType::Trait) - .and_then(|resolved_item: crate::resolve::ResolvedConcreteItem| { - try_extract_matches!(resolved_item, ResolvedConcreteItem::Trait).ok_or_else(|| { - diagnostics.report(&trait_path, SemanticDiagnosticKind::UnknownTrait) - }) + .and_then(|resolved_item: crate::resolve::ResolvedConcreteItem| match resolved_item { + ResolvedConcreteItem::Trait(id) | ResolvedConcreteItem::SelfTrait(id) => Ok(id), + _ => Err(diagnostics.report(&trait_path, SemanticDiagnosticKind::UnknownTrait)), }); let attributes = impl_syntax.attributes(syntax_db).structurize(syntax_db); let resolver_data = Arc::new(resolver.data); @@ -1362,13 +1362,10 @@ pub fn priv_trait_function_body_data( generic_args: generic_params_to_args(&generic_parameters, db), } .intern(db); - let generic_function = GenericFunctionId::Trait( - ConcreteTraitGenericFunctionLongId { - concrete_trait, - trait_function: trait_function_id, - } - .intern(db), - ); + let generic_function = GenericFunctionId::Impl(ImplGenericFunctionId { + impl_id: ImplLongId::SelfImpl(concrete_trait).intern(db), + function: trait_function_id, + }); Ok(FunctionLongId::from_generic(db, generic_function)?.intern(db)) })(); diff --git a/crates/cairo-lang-semantic/src/resolve/item.rs b/crates/cairo-lang-semantic/src/resolve/item.rs index f7a7510f671..1277d34bf69 100644 --- a/crates/cairo-lang-semantic/src/resolve/item.rs +++ b/crates/cairo-lang-semantic/src/resolve/item.rs @@ -1,6 +1,6 @@ use cairo_lang_defs::ids::{ ConstantId, GenericTypeId, ImplAliasId, ImplDefId, ModuleId, ModuleItemId, ModuleTypeAliasId, - TopLevelLanguageElementId, TraitFunctionId, TraitId, VarId, + TopLevelLanguageElementId, TraitId, VarId, }; use cairo_lang_diagnostics::Maybe; use cairo_lang_proc_macros::DebugWithDb; @@ -10,7 +10,6 @@ use crate::db::SemanticGroup; use crate::items::constant::ConstValueId; use crate::items::functions::GenericFunctionId; use crate::items::imp::{ImplId, ImplLongId}; -use crate::items::trt::ConcreteTraitGenericFunctionId; use crate::items::us::SemanticUseEx; use crate::{ConcreteTraitId, ConcreteVariant, FunctionId, TypeId, TypeLongId, Variant}; @@ -24,7 +23,6 @@ pub enum ResolvedGenericItem { GenericConstant(ConstantId), Module(ModuleId), GenericFunction(GenericFunctionId), - TraitFunction(TraitFunctionId), GenericType(GenericTypeId), GenericTypeAlias(ModuleTypeAliasId), GenericImplAlias(ImplAliasId), @@ -71,7 +69,6 @@ impl ResolvedGenericItem { ResolvedGenericItem::GenericConstant(_) => "".into(), ResolvedGenericItem::Module(id) => id.full_path(defs_db), ResolvedGenericItem::GenericFunction(id) => id.format(db), - ResolvedGenericItem::TraitFunction(id) => id.full_path(defs_db), ResolvedGenericItem::GenericType(id) => id.full_path(defs_db), ResolvedGenericItem::GenericTypeAlias(id) => id.full_path(defs_db), ResolvedGenericItem::GenericImplAlias(id) => id.full_path(defs_db), @@ -89,10 +86,10 @@ pub enum ResolvedConcreteItem { Constant(ConstValueId), Module(ModuleId), Function(FunctionId), - TraitFunction(ConcreteTraitGenericFunctionId), Type(TypeId), Variant(ConcreteVariant), Trait(ConcreteTraitId), + SelfTrait(ConcreteTraitId), Impl(ImplId), } @@ -104,9 +101,6 @@ impl ResolvedConcreteItem { ResolvedConcreteItem::Function(function) => ResolvedGenericItem::GenericFunction( function.lookup_intern(db).function.generic_function, ), - ResolvedConcreteItem::TraitFunction(trait_function) => { - ResolvedGenericItem::TraitFunction(trait_function.trait_function(db)) - } ResolvedConcreteItem::Type(ty) => { if let TypeLongId::Concrete(concrete) = ty.lookup_intern(db) { ResolvedGenericItem::GenericType(concrete.generic_type(db)) @@ -125,6 +119,9 @@ impl ResolvedConcreteItem { ResolvedConcreteItem::Trait(concrete_trait) => { ResolvedGenericItem::Trait(concrete_trait.lookup_intern(db).trait_id) } + ResolvedConcreteItem::SelfTrait(concrete_trait_id) => { + ResolvedGenericItem::Trait(concrete_trait_id.trait_id(db)) + } ResolvedConcreteItem::Impl(impl_id) => match impl_id.lookup_intern(db) { ImplLongId::Concrete(concrete_impl_id) => { ResolvedGenericItem::Impl(concrete_impl_id.lookup_intern(db).impl_def_id) @@ -132,7 +129,7 @@ impl ResolvedConcreteItem { ImplLongId::GenericParameter(_) | ImplLongId::ImplVar(_) | ImplLongId::ImplImpl(_) - | ImplLongId::TraitImpl(_) + | ImplLongId::SelfImpl(_) | ImplLongId::GeneratedImpl(_) => return None, }, }) diff --git a/crates/cairo-lang-semantic/src/resolve/mod.rs b/crates/cairo-lang-semantic/src/resolve/mod.rs index ba595725ece..9dbd0fb050a 100644 --- a/crates/cairo-lang-semantic/src/resolve/mod.rs +++ b/crates/cairo-lang-semantic/src/resolve/mod.rs @@ -424,15 +424,15 @@ impl<'db> Resolver<'db> { self.data.used_items.insert(LookupItemId::ModuleItem(inner_item_info.item_id)); let inner_generic_item = ResolvedGenericItem::from_module_item(self.db, inner_item_info.item_id)?; - let specialized_item = self.specialize_generic_module_item( + let mut specialized_item = self.specialize_generic_module_item( diagnostics, identifier, inner_generic_item, generic_args_syntax.clone(), )?; - self.warn_same_impl_trait( + self.handle_same_impl_trait( diagnostics, - &specialized_item, + &mut specialized_item, &generic_args_syntax.unwrap_or_default(), segment_stable_ptr, ); @@ -837,12 +837,48 @@ impl<'db> Resolver<'db> { Err(diagnostics.report(identifier, InvalidPath)) } } + ResolvedConcreteItem::SelfTrait(concrete_trait_id) => { + let impl_id = ImplLongId::SelfImpl(*concrete_trait_id).intern(self.db); + let Some(trait_item_id) = + self.db.trait_item_by_name(concrete_trait_id.trait_id(self.db), ident)? + else { + return Err(diagnostics.report(identifier, InvalidPath)); + }; + self.data.used_items.insert(LookupItemId::TraitItem(trait_item_id)); + Ok(match trait_item_id { + TraitItemId::Function(trait_function_id) => { + ResolvedConcreteItem::Function(self.specialize_function( + diagnostics, + identifier.stable_ptr().untyped(), + GenericFunctionId::Impl(ImplGenericFunctionId { + impl_id, + function: trait_function_id, + }), + &generic_args_syntax.unwrap_or_default(), + )?) + } + TraitItemId::Type(trait_type_id) => ResolvedConcreteItem::Type( + TypeLongId::ImplType(ImplTypeId::new(impl_id, trait_type_id, self.db)) + .intern(self.db), + ), + TraitItemId::Constant(trait_constant_id) => ResolvedConcreteItem::Constant( + ConstValue::ImplConstant(ImplConstantId::new( + impl_id, + trait_constant_id, + self.db, + )) + .intern(self.db), + ), + TraitItemId::Impl(trait_impl_id) => ResolvedConcreteItem::Impl( + ImplLongId::ImplImpl(ImplImplId::new(impl_id, trait_impl_id, self.db)) + .intern(self.db), + ), + }) + } ResolvedConcreteItem::Trait(concrete_trait_id) => { - // Find the relevant function in the trait. - let long_trait_id = concrete_trait_id.lookup_intern(self.db); - let trait_id = long_trait_id.trait_id; - - let Some(trait_item_id) = self.db.trait_item_by_name(trait_id, ident)? else { + let Some(trait_item_id) = + self.db.trait_item_by_name(concrete_trait_id.trait_id(self.db), ident)? + else { return Err(diagnostics.report(identifier, InvalidPath)); }; self.data.used_items.insert(LookupItemId::TraitItem(trait_item_id)); @@ -856,18 +892,6 @@ impl<'db> Resolver<'db> { ) .intern(self.db); let identifier_stable_ptr = identifier.stable_ptr().untyped(); - if let TraitOrImplContext::Trait(ctx_trait_id) = &self.trait_or_impl_ctx { - if trait_id == *ctx_trait_id { - return Ok(ResolvedConcreteItem::Function( - self.specialize_function( - diagnostics, - identifier_stable_ptr, - GenericFunctionId::Trait(concrete_trait_function), - &generic_args_syntax.unwrap_or_default(), - )?, - )); - } - } let impl_lookup_context = self.impl_lookup_context(); let generic_function = GenericFunctionId::Impl(self.inference().infer_trait_generic_function( @@ -884,13 +908,6 @@ impl<'db> Resolver<'db> { )?)) } TraitItemId::Type(trait_type_id) => { - if let TraitOrImplContext::Trait(ctx_trait_id) = &self.trait_or_impl_ctx { - if trait_id == *ctx_trait_id { - return Ok(ResolvedConcreteItem::Type( - TypeLongId::TraitType(trait_type_id).intern(self.db), - )); - } - } let concrete_trait_type = ConcreteTraitTypeId::new(self.db, *concrete_trait_id, trait_type_id); @@ -911,14 +928,6 @@ impl<'db> Resolver<'db> { ) .intern(self.db); - if let TraitOrImplContext::Trait(ctx_trait_id) = &self.trait_or_impl_ctx { - if trait_id == *ctx_trait_id { - return Ok(ResolvedConcreteItem::Constant( - ConstValue::TraitConstant(trait_constant_id).intern(self.db), - )); - } - } - let impl_lookup_context = self.impl_lookup_context(); let identifier_stable_ptr = identifier.stable_ptr().untyped(); let imp_constant_id = self.inference().infer_trait_constant( @@ -943,14 +952,6 @@ impl<'db> Resolver<'db> { ) .intern(self.db); - if let TraitOrImplContext::Trait(ctx_trait_id) = &self.trait_or_impl_ctx { - if trait_id == *ctx_trait_id { - return Ok(ResolvedConcreteItem::Impl( - ImplLongId::TraitImpl(trait_impl_id).intern(self.db), - )); - } - } - let impl_lookup_context = self.impl_lookup_context(); let identifier_stable_ptr = identifier.stable_ptr().untyped(); let impl_impl_id = self.inference().infer_trait_impl( @@ -1127,7 +1128,6 @@ impl<'db> Resolver<'db> { &generic_args_syntax.unwrap_or_default(), )?) } - ResolvedGenericItem::TraitFunction(_) => panic!("TraitFunction is not a module item."), ResolvedGenericItem::Variable(_) => panic!("Variable is not a module item."), }) } @@ -1656,11 +1656,17 @@ impl<'db> Resolver<'db> { GenericParam::Impl(param) => { let expr_path = try_extract_matches!(generic_arg_syntax, ast::Expr::Path) .ok_or_else(|| diagnostics.report(generic_arg_syntax, UnknownImpl))?; - let resolved_impl = try_extract_matches!( - self.resolve_concrete_path(diagnostics, expr_path, NotFoundItemType::Impl)?, - ResolvedConcreteItem::Impl - ) - .ok_or_else(|| diagnostics.report(generic_arg_syntax, UnknownImpl))?; + let resolved_impl = match self.resolve_concrete_path( + diagnostics, + expr_path, + NotFoundItemType::Impl, + )? { + ResolvedConcreteItem::Impl(resolved_impl) => resolved_impl, + ResolvedConcreteItem::SelfTrait(concrete_trait_id) => { + ImplLongId::SelfImpl(concrete_trait_id).intern(self.db) + } + _ => return Err(diagnostics.report(generic_arg_syntax, UnknownImpl)), + }; let impl_def_concrete_trait = self.db.impl_concrete_trait(resolved_impl)?; let expected_concrete_trait = param.concrete_trait?; if let Err(err_set) = self @@ -1779,12 +1785,13 @@ impl<'db> Resolver<'db> { // TODO(yuval): on a breaking version change, consider changing warnings to errors. /// Warns about the use of a trait in a path inside the same trait or an impl of it, and the use - /// of an impl in a path inside the same impl. + /// of an impl in a path inside the same impl, addditionally, converts a `Self` equivalent + /// trait to be resolved as `Self`. /// That is, warns about using the actual path equivalent to `Self`, where `Self` can be used. - fn warn_same_impl_trait( + fn handle_same_impl_trait( &mut self, diagnostics: &mut SemanticDiagnostics, - specialized_item: &ResolvedConcreteItem, + specialized_item: &mut ResolvedConcreteItem, generic_args_syntax_slice: &[ast::GenericArg], segment_stable_ptr: SyntaxStablePtrId, ) { @@ -1793,14 +1800,19 @@ impl<'db> Resolver<'db> { match self.trait_or_impl_ctx { TraitOrImplContext::None => {} TraitOrImplContext::Trait(ctx_trait) => { - self.warn_trait_in_same_trait( - diagnostics, - current_segment_concrete_trait.trait_id(self.db), - generic_args_syntax_slice, - ctx_trait, - segment_stable_ptr, - ) - .ok(); + if self + .warn_trait_in_same_trait( + diagnostics, + current_segment_concrete_trait.trait_id(self.db), + generic_args_syntax_slice, + ctx_trait, + segment_stable_ptr, + ) + .is_err() + { + *specialized_item = + ResolvedConcreteItem::SelfTrait(current_segment_concrete_trait); + } } TraitOrImplContext::Impl(ctx_impl_def_id) => { self.warn_trait_in_its_impl( @@ -1958,7 +1970,7 @@ impl<'db> Resolver<'db> { generic_args_syntax: Option>, ) -> ResolvedConcreteItem { let segment_stable_ptr = segment.stable_ptr().untyped(); - let specialized_item = self + let mut specialized_item = self .specialize_generic_module_item( diagnostics, identifier, @@ -1966,9 +1978,9 @@ impl<'db> Resolver<'db> { generic_args_syntax.clone(), ) .unwrap(); - self.warn_same_impl_trait( + self.handle_same_impl_trait( diagnostics, - &specialized_item, + &mut specialized_item, &generic_args_syntax.unwrap_or_default(), segment_stable_ptr, ); @@ -2004,7 +2016,7 @@ fn resolve_actual_self_segment( generic_args: generic_params_to_args(&generic_parameters, db), } .intern(db); - Ok(ResolvedConcreteItem::Trait(concrete_trait_id)) + Ok(ResolvedConcreteItem::SelfTrait(concrete_trait_id)) } TraitOrImplContext::Impl(impl_def_id) => { let generic_parameters = db.impl_def_generic_params(*impl_def_id)?; diff --git a/crates/cairo-lang-semantic/src/substitution.rs b/crates/cairo-lang-semantic/src/substitution.rs index 92971ee4d2f..068c0eeb447 100644 --- a/crates/cairo-lang-semantic/src/substitution.rs +++ b/crates/cairo-lang-semantic/src/substitution.rs @@ -464,7 +464,7 @@ add_basic_rewrites!( <'a>, SubstitutionRewriter<'a>, DiagnosticAdded, - @exclude TypeId TypeLongId ImplId ImplLongId ConstValue GenericFunctionId GenericFunctionWithBodyId + @exclude TypeId TypeLongId ImplId ImplLongId ConstValue GenericFunctionWithBodyId ); impl SemanticRewriter for SubstitutionRewriter<'_> { @@ -507,20 +507,6 @@ impl SemanticRewriter for SubstitutionRewriter<'_> return Ok(impl_type_id_rewrite_result); } } - TypeLongId::TraitType(trait_type_id) => { - if let Some(self_impl) = &self.substitution.self_impl { - if trait_type_id.trait_id(self.db.upcast()) - == self_impl.concrete_trait(self.db)?.trait_id(self.db) - { - let impl_type_id = ImplTypeId::new(*self_impl, *trait_type_id, self.db); - *value = self - .db - .impl_type_concrete_implized(impl_type_id)? - .lookup_intern(self.db); - return Ok(RewriteResult::Modified); - } - } - } _ => {} } value.default_rewrite(self) @@ -550,22 +536,6 @@ impl SemanticRewriter for SubstitutionRewriter<'_> return Ok(impl_const_id_rewrite_result); } } - ConstValue::TraitConstant(trait_constant_id) => { - if let Some(self_impl) = &self.substitution.self_impl { - if trait_constant_id.trait_id(self.db.upcast()) - == self_impl.concrete_trait(self.db)?.trait_id(self.db) - { - let impl_const_id = - ImplConstantId::new(*self_impl, *trait_constant_id, self.db); - *value = self - .db - .impl_constant_concrete_implized_value(impl_const_id)? - .lookup_intern(self.db); - - return Ok(RewriteResult::Modified); - } - } - } _ => {} } @@ -595,19 +565,15 @@ impl SemanticRewriter for SubstitutionRewriter<'_> return Ok(impl_impl_id_rewrite_result); } } - ImplLongId::TraitImpl(trait_impl_id) => { + ImplLongId::SelfImpl(concrete_trait_id) => { + let rewrite_result = self.internal_rewrite(concrete_trait_id)?; if let Some(self_impl) = &self.substitution.self_impl { - if trait_impl_id.trait_id(self.db.upcast()) - == self_impl.concrete_trait(self.db)?.trait_id(self.db) - { - let impl_impl_id = ImplImplId::new(*self_impl, *trait_impl_id, self.db); - *value = self - .db - .impl_impl_concrete_implized(impl_impl_id)? - .lookup_intern(self.db); - + if *concrete_trait_id == self_impl.concrete_trait(self.db)? { + *value = self_impl.lookup_intern(self.db); return Ok(RewriteResult::Modified); } + } else { + return Ok(rewrite_result); } } _ => {} @@ -615,24 +581,6 @@ impl SemanticRewriter for SubstitutionRewriter<'_> value.default_rewrite(self) } } -impl SemanticRewriter for SubstitutionRewriter<'_> { - fn internal_rewrite(&mut self, value: &mut GenericFunctionId) -> Maybe { - if let GenericFunctionId::Trait(id) = value { - if let Some(self_impl) = &self.substitution.self_impl { - let id_rewritten = self.internal_rewrite(id)?; - if id.concrete_trait(self.db.upcast()) == self_impl.concrete_trait(self.db)? { - *value = GenericFunctionId::Impl(ImplGenericFunctionId { - impl_id: *self_impl, - function: id.trait_function(self.db), - }); - return Ok(RewriteResult::Modified); - } - return Ok(id_rewritten); - } - } - value.default_rewrite(self) - } -} impl SemanticRewriter for SubstitutionRewriter<'_> { fn internal_rewrite(&mut self, value: &mut GenericFunctionWithBodyId) -> Maybe { if let GenericFunctionWithBodyId::Trait(id) = value { diff --git a/crates/cairo-lang-semantic/src/types.rs b/crates/cairo-lang-semantic/src/types.rs index 678bfd9e954..4c74bb454ad 100644 --- a/crates/cairo-lang-semantic/src/types.rs +++ b/crates/cairo-lang-semantic/src/types.rs @@ -50,7 +50,6 @@ pub enum TypeLongId { size: ConstValueId, }, ImplType(ImplTypeId), - TraitType(TraitTypeId), Closure(ClosureTypeLongId), Missing(#[dont_rewrite] DiagnosticAdded), } @@ -134,7 +133,6 @@ impl TypeLongId { | TypeLongId::Var(_) | TypeLongId::Missing(_) | TypeLongId::ImplType(_) - | TypeLongId::TraitType(_) | TypeLongId::Closure(_) => { return None; } @@ -165,7 +163,6 @@ impl TypeLongId { | TypeLongId::GenericParameter(_) | TypeLongId::Var(_) | TypeLongId::Coupon(_) - | TypeLongId::TraitType(_) | TypeLongId::ImplType(_) | TypeLongId::Missing(_) | TypeLongId::Closure(_) => false, @@ -201,14 +198,6 @@ impl DebugWithDb for TypeLongId { TypeLongId::FixedSizeArray { type_id, size } => { write!(f, "[{}; {:?}]", type_id.format(db), size.debug(db.elongate())) } - TypeLongId::TraitType(trait_type_id) => { - write!( - f, - "{}::{}", - trait_type_id.trait_id(def_db).name(def_db), - trait_type_id.name(def_db) - ) - } TypeLongId::Closure(closure) => { write!(f, "{:?}", closure.debug(db.elongate())) } @@ -759,7 +748,6 @@ pub fn single_value_type(db: &dyn SemanticGroup, ty: TypeId) -> Maybe { | TypeLongId::Missing(_) | TypeLongId::Coupon(_) | TypeLongId::ImplType(_) - | TypeLongId::TraitType(_) | TypeLongId::Closure(_) => false, TypeLongId::FixedSizeArray { type_id, size } => { db.single_value_type(type_id)? @@ -846,7 +834,6 @@ pub fn type_size_info(db: &dyn SemanticGroup, ty: TypeId) -> Maybe {} TypeLongId::FixedSizeArray { type_id, size } => { @@ -897,8 +884,7 @@ pub fn priv_type_is_fully_concrete(db: &dyn SemanticGroup, ty: TypeId) -> bool { TypeLongId::GenericParameter(_) | TypeLongId::Var(_) | TypeLongId::Missing(_) - | TypeLongId::ImplType(_) - | TypeLongId::TraitType(_) => false, + | TypeLongId::ImplType(_) => false, TypeLongId::Coupon(function_id) => function_id.is_fully_concrete(db), TypeLongId::FixedSizeArray { type_id, size } => { type_id.is_fully_concrete(db) && size.is_fully_concrete(db) @@ -916,7 +902,7 @@ pub fn priv_type_is_var_free(db: &dyn SemanticGroup, ty: TypeId) -> bool { TypeLongId::Tuple(types) => types.iter().all(|ty| ty.is_var_free(db)), TypeLongId::Snapshot(ty) => ty.is_var_free(db), TypeLongId::Var(_) => false, - TypeLongId::GenericParameter(_) | TypeLongId::Missing(_) | TypeLongId::TraitType(_) => true, + TypeLongId::GenericParameter(_) | TypeLongId::Missing(_) => true, TypeLongId::Coupon(function_id) => function_id.is_var_free(db), TypeLongId::FixedSizeArray { type_id, size } => { type_id.is_var_free(db) && size.is_var_free(db) diff --git a/crates/cairo-lang-sierra-generator/src/types.rs b/crates/cairo-lang-sierra-generator/src/types.rs index bfcc8060bde..68bc58d601d 100644 --- a/crates/cairo-lang-sierra-generator/src/types.rs +++ b/crates/cairo-lang-sierra-generator/src/types.rs @@ -148,7 +148,6 @@ pub fn get_concrete_long_type_id( semantic::TypeLongId::GenericParameter(_) | semantic::TypeLongId::Var(_) | semantic::TypeLongId::ImplType(_) - | semantic::TypeLongId::TraitType(_) | semantic::TypeLongId::Missing(_) => { panic!( "Types should be fully resolved at this point. Got: `{}`.", @@ -201,7 +200,6 @@ pub fn type_dependencies( semantic::TypeLongId::GenericParameter(_) | semantic::TypeLongId::Var(_) | semantic::TypeLongId::ImplType(_) - | semantic::TypeLongId::TraitType(_) | semantic::TypeLongId::Missing(_) => { panic!( "Types should be fully resolved at this point. Got: `{}`.", diff --git a/crates/cairo-lang-sierra-generator/src/utils.rs b/crates/cairo-lang-sierra-generator/src/utils.rs index 584b6bef9be..692268b22c9 100644 --- a/crates/cairo-lang-sierra-generator/src/utils.rs +++ b/crates/cairo-lang-sierra-generator/src/utils.rs @@ -222,8 +222,7 @@ fn const_type_id( ConstValue::Generic(_) | ConstValue::Var(_, _) | ConstValue::Missing(_) - | ConstValue::ImplConstant(_) - | ConstValue::TraitConstant(_) => { + | ConstValue::ImplConstant(_) => { unreachable!("Should be caught by the lowering.") } }, diff --git a/crates/cairo-lang-starknet/src/abi.rs b/crates/cairo-lang-starknet/src/abi.rs index a2c3d23531b..6810c644255 100644 --- a/crates/cairo-lang-starknet/src/abi.rs +++ b/crates/cairo-lang-starknet/src/abi.rs @@ -666,7 +666,6 @@ impl<'a> AbiBuilder<'a> { TypeLongId::Coupon(_) | TypeLongId::GenericParameter(_) | TypeLongId::Var(_) - | TypeLongId::TraitType(_) | TypeLongId::ImplType(_) | TypeLongId::Missing(_) | TypeLongId::Closure(_) => Err(ABIError::UnexpectedType),