Struct 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<CanonicalTrait, DiagnosticAdded> for SubstitutionRewriter<'a>

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

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

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

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

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

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 SemanticRewriter<ConstValue, DiagnosticAdded> for SubstitutionRewriter<'_>

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<GeneratedImplId, DiagnosticAdded> for SubstitutionRewriter<'a>

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

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

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

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

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

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

fn internal_rewrite( &mut self, value: &mut GeneratedImplLongId, ) -> 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 SemanticRewriter<GenericFunctionId, DiagnosticAdded> for SubstitutionRewriter<'_>

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<Id<Expr>, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut ExprId, ) -> 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<ImplConstantId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ImplConstantId, ) -> 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 SemanticRewriter<ImplId, DiagnosticAdded> for SubstitutionRewriter<'_>

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

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

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

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

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

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

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

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

impl SemanticRewriter<ImplLongId, DiagnosticAdded> for SubstitutionRewriter<'_>

fn internal_rewrite(&mut self, value: &mut ImplLongId) -> 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<ImplVarTraitItemMappings, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, value: &mut ImplVarTraitItemMappings, ) -> 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<TraitConstantId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut TraitConstantId, ) -> 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<TraitImplId, DiagnosticAdded> for SubstitutionRewriter<'a>

fn internal_rewrite( &mut self, _value: &mut TraitImplId, ) -> 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 SemanticRewriter<TypeId, DiagnosticAdded> for SubstitutionRewriter<'_>

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

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

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

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<UninferredGeneratedImplId, DiagnosticAdded> for SubstitutionRewriter<'a>

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

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

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

fn internal_rewrite( &mut self, value: &mut UninferredGeneratedImplLongId, ) -> 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>