Struct cairo_lang_semantic::substitution::SubstitutionRewriter

pub struct SubstitutionRewriter<'a> {
    pub db: &'a dyn SemanticGroup,
    pub substitution: &'a GenericSubstitution,
}

Fields

db: &'a dyn SemanticGroup

substitution: &'a GenericSubstitution

Trait Implementations

impl<'a> HasDb<&'a dyn SemanticGroup> for SubstitutionRewriter<'a>

fn get_db(&self) -> &'a dyn SemanticGroup

impl<'a> SemanticRewriter<ConcreteEnumId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteEnumId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteEnumLongId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteEnumLongId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteExternTypeId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteExternTypeId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteExternTypeLongId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteExternTypeLongId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteFunction, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteFunction ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteFunctionWithBody, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteFunctionWithBody ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteFunctionWithBodyId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteFunctionWithBodyId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteImplId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteImplId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteImplLongId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteImplLongId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteStructId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteStructId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteStructLongId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteStructLongId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteTraitGenericFunctionId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteTraitGenericFunctionId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteTraitGenericFunctionLongId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteTraitGenericFunctionLongId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteTraitId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteTraitId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteTraitLongId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteTraitLongId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteTypeId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteTypeId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConcreteVariant, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConcreteVariant ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConstValue, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite(&mut self, value: &mut ConstValue) -> Maybe<RewriteResult>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConstValueId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ConstValueId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ConstVar, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ConstVar ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<EnumId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut EnumId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ExprVar, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ExprVar ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ExprVarMemberPath, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ExprVarMemberPath ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ExternFunctionId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ExternFunctionId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ExternTypeId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ExternTypeId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<FreeFunctionId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut FreeFunctionId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<FunctionId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut FunctionId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<FunctionLongId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut FunctionLongId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<GenericArgumentId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut GenericArgumentId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<GenericFunctionId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut GenericFunctionId ) -> Maybe<RewriteResult>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<GenericFunctionWithBodyId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut GenericFunctionWithBodyId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<GenericParam, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut GenericParam ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<GenericParamConst, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut GenericParamConst ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<GenericParamId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut GenericParamId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<GenericParamImpl, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut GenericParamImpl ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<GenericParamType, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut GenericParamType ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplAliasId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ImplAliasId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplDefId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ImplDefId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplFunctionBodyId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ImplFunctionBodyId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplFunctionId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ImplFunctionId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplGenericFunctionId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ImplGenericFunctionId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplGenericFunctionWithBodyId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ImplGenericFunctionWithBodyId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite(&mut self, value: &mut ImplId) -> Maybe<RewriteResult>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplTypeId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ImplTypeId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplVar, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ImplVar ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ImplVarId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ImplVarId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<InferenceId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut InferenceId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<InferenceVar, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut InferenceVar ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<LocalConstVarId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut LocalConstVarId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<LocalImplVarId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut LocalImplVarId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<LocalTypeVarId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut LocalTypeVarId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<LocalVarId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut LocalVarId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<MatchArmSelector, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut MatchArmSelector ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<MemberId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut MemberId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ParamId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ParamId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<Parameter, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut Parameter ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<Signature, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut Signature ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<StructId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut StructId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<TraitFunctionId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut TraitFunctionId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<TraitId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut TraitId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<TraitTypeId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut TraitTypeId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<TypeId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite(&mut self, value: &mut TypeId) -> Maybe<RewriteResult>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<TypeLongId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite(&mut self, value: &mut TypeLongId) -> Maybe<RewriteResult>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<TypeVar, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut TypeVar ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<UninferredImpl, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut UninferredImpl ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<ValueSelectorArm, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ValueSelectorArm ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<VarId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut VarId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl<'a> SemanticRewriter<VariantId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut VariantId ) -> Result<RewriteResult, DiagnosticAdded>

fn rewrite(&mut self, value: T) -> Result<T, Error>