Enum NoError 

pub enum NoError {}

A ‘never’ error.

Trait Implementations

impl Debug for NoError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, 'mt> SemanticRewriter<Ambiguity<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut Ambiguity<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<CanonicalTrait<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ClosureTypeLongId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteEnumId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteEnumLongId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteExternTypeId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteExternTypeLongId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteFunction<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteFunctionWithBody<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteFunctionWithBodyId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteImplId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteImplLongId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteStructId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteStructLongId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteTraitGenericFunctionId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteTraitGenericFunctionLongId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteTraitId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteTraitLongId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteTraitTypeId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ConcreteTraitTypeId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ConcreteTraitTypeLongId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ConcreteTraitTypeLongId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ConcreteTypeId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConcreteVariant<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<Condition, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut Condition, ) -> Result<RewriteResult, NoError>

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

impl<'db, 'mt> SemanticRewriter<ConstValue<'db>, NoError> for Inference<'db, 'mt>

fn internal_rewrite( &mut self, value: &mut ConstValue<'db>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ConstValueId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConstVar<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ConstantId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, _value: &mut ConstantId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<EnumId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<Expr<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut Expr<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprAssignment<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprAssignment<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprBlock<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprBlock<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprClosure<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprClosure<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprConstant<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprConstant<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprDesnap<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprDesnap<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprEnumVariantCtor<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprEnumVariantCtor<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprFixedSizeArray<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprFixedSizeArray<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprFor<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprFor<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprFunctionCall<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprFunctionCall<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprFunctionCallArg<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprFunctionCallArg<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprId, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, _value: &mut ExprId, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprIf<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprIf<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprLiteral<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprLiteral<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprLogicalOperator<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprLogicalOperator<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprLoop<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprLoop<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprMatch<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprMatch<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprMemberAccess<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprMemberAccess<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprMissing<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprMissing<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprPropagateError<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprPropagateError<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprSnapshot<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprSnapshot<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprStringLiteral<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprStringLiteral<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprStructCtor<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprStructCtor<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprTuple<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprTuple<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExprVar<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ExprVarMemberPath<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ExprWhile<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ExprWhile<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ExternFunctionId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ExternTypeId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<FixedSizeArrayItems<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut FixedSizeArrayItems<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<FreeFunctionId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<FunctionId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<FunctionLongId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GeneratedImplId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GeneratedImplItems<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GeneratedImplLongId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut GeneratedImplLongId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<GenericArgumentId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GenericFunctionId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut GenericFunctionId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<GenericFunctionWithBodyId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GenericParam<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GenericParamConst<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GenericParamId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GenericParamImpl<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<GenericParamType<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplAliasId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplConstantId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ImplConstantId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ImplDefId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplFunctionBodyId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplFunctionId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplGenericFunctionId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplGenericFunctionWithBodyId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'db, 'mt> SemanticRewriter<ImplId<'db>, NoError> for Inference<'db, 'mt>

fn internal_rewrite( &mut self, value: &mut ImplId<'db>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ImplImplDefId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplImplId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'db, 'mt> SemanticRewriter<ImplLongId<'db>, NoError> for Inference<'db, 'mt>

fn internal_rewrite( &mut self, value: &mut ImplLongId<'db>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ImplTypeId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplVar<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplVarId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ImplVarTraitItemMappings<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut ImplVarTraitItemMappings<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<InferenceId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<InferenceVar, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<LocalConstVarId, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<LocalImplVarId, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<LocalNegativeImplVarId, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, _value: &mut LocalNegativeImplVarId, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<LocalTypeVarId, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<LocalVarId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<LocalVariable<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut LocalVariable<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<MatchArm, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut MatchArm, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<MatchArmSelector<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<Member<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut Member<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<MemberId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'db, 'mt> SemanticRewriter<NegativeImplId<'db>, NoError> for Inference<'db, 'mt>

fn internal_rewrite( &mut self, value: &mut NegativeImplId<'db>, ) -> Result<RewriteResult, NoError>

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

impl<'db, 'mt> SemanticRewriter<NegativeImplLongId<'db>, NoError> for Inference<'db, 'mt>

fn internal_rewrite( &mut self, value: &mut NegativeImplLongId<'db>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<NegativeImplVar<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut NegativeImplVar<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<NegativeImplVarId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut NegativeImplVarId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<ParamId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<Parameter<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<Pattern<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut Pattern<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternEnumVariant<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternEnumVariant<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternFixedSizeArray<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternFixedSizeArray<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternId, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, _value: &mut PatternId, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternLiteral<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternLiteral<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternMissing<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternMissing<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternOtherwise<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternOtherwise<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternStringLiteral<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternStringLiteral<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternStruct<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternStruct<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternTuple<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternTuple<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<PatternVariable<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut PatternVariable<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<Signature<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<Statement<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut Statement<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<StatementBreak<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut StatementBreak<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<StatementContinue<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut StatementContinue<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<StatementExpr<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut StatementExpr<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<StatementId, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, _value: &mut StatementId, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<StatementItem<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut StatementItem<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<StatementLet<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut StatementLet<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<StatementReturn<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut StatementReturn<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<StructId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<TraitConstantId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, _value: &mut TraitConstantId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<TraitFunctionId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<TraitId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<TraitImplId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, _value: &mut TraitImplId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<TraitTypeId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'db, 'mt> SemanticRewriter<TypeId<'db>, NoError> for Inference<'db, 'mt>

fn internal_rewrite( &mut self, value: &mut TypeId<'db>, ) -> Result<RewriteResult, NoError>

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

impl<'db, 'mt> SemanticRewriter<TypeLongId<'db>, NoError> for Inference<'db, 'mt>

fn internal_rewrite( &mut self, value: &mut TypeLongId<'db>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<TypeVar<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<UninferredGeneratedImplId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<UninferredGeneratedImplLongId<'a>, NoError> for Inference<'a, 'mt>

fn internal_rewrite( &mut self, value: &mut UninferredGeneratedImplLongId<'a>, ) -> Result<RewriteResult, NoError>

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

impl<'a, 'mt> SemanticRewriter<UninferredImpl<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<ValueSelectorArm, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<VarId<'a>, NoError> for Inference<'a, 'mt>

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

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

impl<'a, 'mt> SemanticRewriter<VariantId<'a>, NoError> for Inference<'a, 'mt>

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

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