pub enum NoError {}Expand description
A ‘never’ error.
Trait Implementations§
Source§impl<'a> SemanticRewriter<CanonicalTrait, NoError> for Inference<'a>
impl<'a> SemanticRewriter<CanonicalTrait, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut CanonicalTrait, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ClosureTypeLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ClosureTypeLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ClosureTypeLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteEnumId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteEnumId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteEnumId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteEnumLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteEnumLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteEnumLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteExternTypeId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteExternTypeId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteExternTypeId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteExternTypeLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteExternTypeLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteExternTypeLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteFunction, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteFunction, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteFunction, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteFunctionWithBody, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteFunctionWithBody, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteFunctionWithBody, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteFunctionWithBodyId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteFunctionWithBodyId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteFunctionWithBodyId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteImplId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteImplId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteImplId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteImplLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteImplLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteImplLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteStructId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteStructId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteStructId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteStructLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteStructLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteStructLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteTraitGenericFunctionId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteTraitGenericFunctionId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteTraitGenericFunctionId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteTraitGenericFunctionLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteTraitGenericFunctionLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteTraitGenericFunctionLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteTraitId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteTraitId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteTraitId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteTraitLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteTraitLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteTraitLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteTypeId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteTypeId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteTypeId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConcreteVariant, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConcreteVariant, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConcreteVariant, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl SemanticRewriter<ConstValue, NoError> for Inference<'_>
impl SemanticRewriter<ConstValue, NoError> for Inference<'_>
fn internal_rewrite( &mut self, value: &mut ConstValue, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConstValueId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConstValueId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ConstValueId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ConstantId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ConstantId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut ConstantId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprAssignment, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprAssignment, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprAssignment, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprClosure, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprClosure, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprClosure, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprConstant, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprConstant, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprConstant, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprDesnap, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprDesnap, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprDesnap, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprEnumVariantCtor, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprEnumVariantCtor, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprEnumVariantCtor, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprFixedSizeArray, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprFixedSizeArray, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprFixedSizeArray, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprFunctionCall, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprFunctionCall, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprFunctionCall, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprFunctionCallArg, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprFunctionCallArg, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprFunctionCallArg, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprLiteral, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprLiteral, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprLiteral, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprLogicalOperator, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprLogicalOperator, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprLogicalOperator, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprMemberAccess, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprMemberAccess, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprMemberAccess, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprMissing, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprMissing, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprMissing, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprPropagateError, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprPropagateError, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprPropagateError, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprSnapshot, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprSnapshot, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprSnapshot, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprStringLiteral, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprStringLiteral, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprStringLiteral, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprStructCtor, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprStructCtor, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprStructCtor, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExprVarMemberPath, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExprVarMemberPath, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ExprVarMemberPath, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExternFunctionId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExternFunctionId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut ExternFunctionId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ExternTypeId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ExternTypeId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut ExternTypeId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<FixedSizeArrayItems, NoError> for Inference<'a>
impl<'a> SemanticRewriter<FixedSizeArrayItems, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut FixedSizeArrayItems, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<FreeFunctionId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<FreeFunctionId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut FreeFunctionId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<FunctionId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<FunctionId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut FunctionId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<FunctionLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<FunctionLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut FunctionLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GeneratedImplId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GeneratedImplId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GeneratedImplId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GeneratedImplItems, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GeneratedImplItems, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GeneratedImplItems, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GeneratedImplLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GeneratedImplLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GeneratedImplLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GenericArgumentId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GenericArgumentId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GenericArgumentId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GenericFunctionId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GenericFunctionId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GenericFunctionId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GenericFunctionWithBodyId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GenericFunctionWithBodyId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GenericFunctionWithBodyId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GenericParam, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GenericParam, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GenericParam, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GenericParamConst, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GenericParamConst, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GenericParamConst, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GenericParamId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GenericParamId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut GenericParamId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GenericParamImpl, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GenericParamImpl, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GenericParamImpl, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<GenericParamType, NoError> for Inference<'a>
impl<'a> SemanticRewriter<GenericParamType, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut GenericParamType, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<Id<Statement>, NoError> for Inference<'a>
impl<'a> SemanticRewriter<Id<Statement>, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut StatementId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplAliasId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplAliasId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut ImplAliasId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplConstantId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplConstantId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ImplConstantId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplFunctionBodyId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplFunctionBodyId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut ImplFunctionBodyId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplFunctionId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplFunctionId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut ImplFunctionId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplGenericFunctionId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplGenericFunctionId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ImplGenericFunctionId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplGenericFunctionWithBodyId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplGenericFunctionWithBodyId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ImplGenericFunctionWithBodyId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplImplDefId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplImplDefId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut ImplImplDefId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplImplId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplImplId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ImplImplId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl SemanticRewriter<ImplLongId, NoError> for Inference<'_>
impl SemanticRewriter<ImplLongId, NoError> for Inference<'_>
fn internal_rewrite( &mut self, value: &mut ImplLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplTypeId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplTypeId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ImplTypeId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ImplVarTraitItemMappings, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ImplVarTraitItemMappings, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ImplVarTraitItemMappings, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<InferenceId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<InferenceId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut InferenceId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<InferenceVar, NoError> for Inference<'a>
impl<'a> SemanticRewriter<InferenceVar, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut InferenceVar, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<LocalConstVarId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<LocalConstVarId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut LocalConstVarId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<LocalImplVarId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<LocalImplVarId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut LocalImplVarId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<LocalTypeVarId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<LocalTypeVarId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut LocalTypeVarId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<LocalVarId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<LocalVarId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut LocalVarId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<LocalVariable, NoError> for Inference<'a>
impl<'a> SemanticRewriter<LocalVariable, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut LocalVariable, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<MatchArmSelector, NoError> for Inference<'a>
impl<'a> SemanticRewriter<MatchArmSelector, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut MatchArmSelector, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternEnumVariant, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternEnumVariant, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternEnumVariant, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternFixedSizeArray, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternFixedSizeArray, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternFixedSizeArray, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternLiteral, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternLiteral, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternLiteral, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternMissing, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternMissing, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternMissing, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternOtherwise, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternOtherwise, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternOtherwise, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternStringLiteral, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternStringLiteral, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternStringLiteral, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternStruct, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternStruct, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternStruct, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternTuple, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternTuple, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternTuple, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<PatternVariable, NoError> for Inference<'a>
impl<'a> SemanticRewriter<PatternVariable, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut PatternVariable, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<StatementBreak, NoError> for Inference<'a>
impl<'a> SemanticRewriter<StatementBreak, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut StatementBreak, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<StatementContinue, NoError> for Inference<'a>
impl<'a> SemanticRewriter<StatementContinue, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut StatementContinue, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<StatementExpr, NoError> for Inference<'a>
impl<'a> SemanticRewriter<StatementExpr, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut StatementExpr, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<StatementItem, NoError> for Inference<'a>
impl<'a> SemanticRewriter<StatementItem, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut StatementItem, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<StatementLet, NoError> for Inference<'a>
impl<'a> SemanticRewriter<StatementLet, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut StatementLet, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<StatementReturn, NoError> for Inference<'a>
impl<'a> SemanticRewriter<StatementReturn, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut StatementReturn, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<TraitConstantId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<TraitConstantId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut TraitConstantId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<TraitFunctionId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<TraitFunctionId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut TraitFunctionId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<TraitImplId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<TraitImplId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut TraitImplId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<TraitTypeId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<TraitTypeId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, _value: &mut TraitTypeId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl SemanticRewriter<TypeLongId, NoError> for Inference<'_>
impl SemanticRewriter<TypeLongId, NoError> for Inference<'_>
fn internal_rewrite( &mut self, value: &mut TypeLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<UninferredGeneratedImplId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<UninferredGeneratedImplId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut UninferredGeneratedImplId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<UninferredGeneratedImplLongId, NoError> for Inference<'a>
impl<'a> SemanticRewriter<UninferredGeneratedImplLongId, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut UninferredGeneratedImplLongId, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<UninferredImpl, NoError> for Inference<'a>
impl<'a> SemanticRewriter<UninferredImpl, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut UninferredImpl, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Source§impl<'a> SemanticRewriter<ValueSelectorArm, NoError> for Inference<'a>
impl<'a> SemanticRewriter<ValueSelectorArm, NoError> for Inference<'a>
fn internal_rewrite( &mut self, value: &mut ValueSelectorArm, ) -> Result<RewriteResult, NoError>
fn rewrite(&mut self, value: T) -> Result<T, Error>
Auto Trait Implementations§
impl Freeze for NoError
impl RefUnwindSafe for NoError
impl Send for NoError
impl Sync for NoError
impl Unpin for NoError
impl UnwindSafe for NoError
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more