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 rewrite( &mut self, value: ConcreteEnumId ) -> Result<ConcreteEnumId, DiagnosticAdded>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn rewrite(&mut self, value: EnumId) -> Result<EnumId, DiagnosticAdded>

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

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

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

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

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

fn rewrite( &mut self, value: ExternFunctionId ) -> Result<ExternFunctionId, DiagnosticAdded>

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

fn rewrite( &mut self, value: ExternTypeId ) -> Result<ExternTypeId, DiagnosticAdded>

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

fn rewrite( &mut self, value: FreeFunctionId ) -> Result<FreeFunctionId, DiagnosticAdded>

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

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

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

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

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

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

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

fn rewrite( &mut self, value: GenericFunctionId ) -> Result<GenericFunctionId, DiagnosticAdded>

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

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

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

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

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

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

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

fn rewrite( &mut self, value: GenericParamId ) -> Result<GenericParamId, DiagnosticAdded>

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

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

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

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

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

fn rewrite( &mut self, value: ImplAliasId ) -> Result<ImplAliasId, DiagnosticAdded>

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

fn rewrite(&mut self, value: ImplDefId) -> Result<ImplDefId, DiagnosticAdded>

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

fn rewrite( &mut self, value: ImplFunctionId ) -> Result<ImplFunctionId, DiagnosticAdded>

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

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

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

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

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

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

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

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

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

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

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

fn rewrite(&mut self, value: LiteralId) -> Result<LiteralId, DiagnosticAdded>

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

fn rewrite(&mut self, value: LocalVarId) -> Result<LocalVarId, DiagnosticAdded>

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

fn rewrite(&mut self, value: MemberId) -> Result<MemberId, DiagnosticAdded>

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

fn rewrite(&mut self, value: ParamId) -> Result<ParamId, DiagnosticAdded>

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

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

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

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

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

fn rewrite(&mut self, value: StructId) -> Result<StructId, DiagnosticAdded>

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

fn rewrite( &mut self, value: TraitFunctionId ) -> Result<TraitFunctionId, DiagnosticAdded>

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

fn rewrite(&mut self, value: TraitId) -> Result<TraitId, DiagnosticAdded>

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

fn rewrite(&mut self, value: TypeId) -> Result<TypeId, DiagnosticAdded>

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

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

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

fn rewrite(&mut self, value: TypeVar) -> Result<TypeVar, DiagnosticAdded>

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

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

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

fn rewrite(&mut self, value: VarId) -> Result<VarId, DiagnosticAdded>

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

fn rewrite(&mut self, value: VariantId) -> Result<VariantId, DiagnosticAdded>