Enum cairo_lang_semantic::expr::inference::canonic::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<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<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<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<ExprParamConstant, NoError> for Inference<'a>

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