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> SemanticRewriter<Ambiguity, NoError> for Inference<'a>

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

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

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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

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

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

impl<'a> SemanticRewriter<ConstValue, NoError> for Inference<'a>

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

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

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>

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

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

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

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>

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

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

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

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

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

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

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>

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

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

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

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>

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>

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>

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>

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>

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

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

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

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>

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>

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

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

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

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>

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>

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

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

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

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

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

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

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>

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>

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>

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>

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>

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>

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

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

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

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

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

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

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>

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

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

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

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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

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

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

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

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

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

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>

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>

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>

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

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

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

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>

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>

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>

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>

impl<'a> SemanticRewriter<ImplId, NoError> for Inference<'a>

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

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

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>

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>

impl<'a> SemanticRewriter<ImplLongId, NoError> for Inference<'a>

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

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

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>

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

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

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

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

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

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

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>

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>

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>

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>

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>

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>

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>

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

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

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

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>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>

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>

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>

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>

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>

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>

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>

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>

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>

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

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

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

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

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

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

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>

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>

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>

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>

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>

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

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

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

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>

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>

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

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

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

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>

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>

impl<'a> SemanticRewriter<TypeId, NoError> for Inference<'a>

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

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

impl<'a> SemanticRewriter<TypeLongId, NoError> for Inference<'a>

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

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

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

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

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

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>

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>

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>

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>

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

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

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

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

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

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