Enum cairo_lang_semantic::expr::inference::canonic::NoError

source · 
pub enum NoError {}
Expand description

A ‘never’ error.

Trait Implementations§

source§

impl Debug for NoError

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

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

source§

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

source§

fn rewrite(&mut self, value: ConcreteEnumId) -> Result<ConcreteEnumId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteEnumLongId ) -> Result<ConcreteEnumLongId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteExternTypeId ) -> Result<ConcreteExternTypeId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteExternTypeLongId ) -> Result<ConcreteExternTypeLongId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteFunction ) -> Result<ConcreteFunction, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteFunctionWithBody ) -> Result<ConcreteFunctionWithBody, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteFunctionWithBodyId ) -> Result<ConcreteFunctionWithBodyId, NoError>

source§

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

source§

fn rewrite(&mut self, value: ConcreteImplId) -> Result<ConcreteImplId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteImplLongId ) -> Result<ConcreteImplLongId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteStructId ) -> Result<ConcreteStructId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteStructLongId ) -> Result<ConcreteStructLongId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteTraitGenericFunctionId ) -> Result<ConcreteTraitGenericFunctionId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteTraitGenericFunctionLongId ) -> Result<ConcreteTraitGenericFunctionLongId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteTraitId ) -> Result<ConcreteTraitId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteTraitLongId ) -> Result<ConcreteTraitLongId, NoError>

source§

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

source§

fn rewrite(&mut self, value: ConcreteTypeId) -> Result<ConcreteTypeId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ConcreteVariant ) -> Result<ConcreteVariant, NoError>

source§

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

source§

fn rewrite(&mut self, value: Constant) -> Result<Constant, NoError>

source§

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

source§

fn rewrite(&mut self, value: ConstantId) -> Result<ConstantId, NoError>

source§

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

source§

fn rewrite(&mut self, value: EnumId) -> Result<EnumId, NoError>

source§

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

source§

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

source§

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

source§

fn rewrite(&mut self, value: ExprAssignment) -> Result<ExprAssignment, NoError>

source§

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

source§

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

source§

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

source§

fn rewrite(&mut self, value: ExprConstant) -> Result<ExprConstant, NoError>

source§

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

source§

fn rewrite(&mut self, value: ExprDesnap) -> Result<ExprDesnap, NoError>

source§

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

source§

fn rewrite( &mut self, value: ExprEnumVariantCtor ) -> Result<ExprEnumVariantCtor, NoError>

source§

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

source§

fn rewrite( &mut self, value: ExprFunctionCall ) -> Result<ExprFunctionCall, NoError>

source§

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

source§

fn rewrite( &mut self, value: ExprFunctionCallArg ) -> Result<ExprFunctionCallArg, NoError>

source§

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

source§

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

source§

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

source§

fn rewrite(&mut self, value: ExprLiteral) -> Result<ExprLiteral, NoError>

source§

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

source§

fn rewrite( &mut self, value: ExprLogicalOperator ) -> Result<ExprLogicalOperator, NoError>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn rewrite( &mut self, value: ExprMemberAccess ) -> Result<ExprMemberAccess, NoError>

source§

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

source§

fn rewrite(&mut self, value: ExprMissing) -> Result<ExprMissing, NoError>

source§

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

source§

fn rewrite( &mut self, value: ExprPropagateError ) -> Result<ExprPropagateError, NoError>

source§

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

source§

fn rewrite(&mut self, value: ExprSnapshot) -> Result<ExprSnapshot, NoError>

source§

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

source§

fn rewrite(&mut self, value: ExprStructCtor) -> Result<ExprStructCtor, NoError>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn rewrite( &mut self, value: ExprVarMemberPath ) -> Result<ExprVarMemberPath, NoError>

source§

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

source§

fn rewrite( &mut self, value: ExternFunctionId ) -> Result<ExternFunctionId, NoError>

source§

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

source§

fn rewrite(&mut self, value: ExternTypeId) -> Result<ExternTypeId, NoError>

source§

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

source§

fn rewrite(&mut self, value: FreeFunctionId) -> Result<FreeFunctionId, NoError>

source§

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

source§

fn rewrite(&mut self, value: FunctionId) -> Result<FunctionId, NoError>

source§

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

source§

fn rewrite(&mut self, value: FunctionLongId) -> Result<FunctionLongId, NoError>

source§

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

source§

fn rewrite( &mut self, value: GenericArgumentId ) -> Result<GenericArgumentId, NoError>

source§

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

source§

fn rewrite( &mut self, value: GenericFunctionId ) -> Result<GenericFunctionId, NoError>

source§

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

source§

fn rewrite( &mut self, value: GenericFunctionWithBodyId ) -> Result<GenericFunctionWithBodyId, NoError>

source§

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

source§

fn rewrite(&mut self, value: GenericParam) -> Result<GenericParam, NoError>

source§

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

source§

fn rewrite( &mut self, value: GenericParamConst ) -> Result<GenericParamConst, NoError>

source§

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

source§

fn rewrite(&mut self, value: GenericParamId) -> Result<GenericParamId, NoError>

source§

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

source§

fn rewrite( &mut self, value: GenericParamImpl ) -> Result<GenericParamImpl, NoError>

source§

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

source§

fn rewrite( &mut self, value: GenericParamType ) -> Result<GenericParamType, NoError>

source§

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

source§

fn rewrite(&mut self, value: ExprId) -> Result<ExprId, NoError>

source§

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

source§

fn rewrite(&mut self, value: StatementId) -> Result<StatementId, NoError>

source§

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

source§

fn rewrite(&mut self, value: ImplAliasId) -> Result<ImplAliasId, NoError>

source§

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

source§

fn rewrite(&mut self, value: ImplDefId) -> Result<ImplDefId, NoError>

source§

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

source§

fn rewrite(&mut self, value: ImplFunctionId) -> Result<ImplFunctionId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ImplGenericFunctionId ) -> Result<ImplGenericFunctionId, NoError>

source§

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

source§

fn rewrite( &mut self, value: ImplGenericFunctionWithBodyId ) -> Result<ImplGenericFunctionWithBodyId, NoError>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn rewrite(&mut self, value: LiteralId) -> Result<LiteralId, NoError>

source§

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

source§

fn rewrite(&mut self, value: LocalVarId) -> Result<LocalVarId, NoError>

source§

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

source§

fn rewrite(&mut self, value: LocalVariable) -> Result<LocalVariable, NoError>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn rewrite(&mut self, value: MemberId) -> Result<MemberId, NoError>

source§

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

source§

fn rewrite(&mut self, value: ParamId) -> Result<ParamId, NoError>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn rewrite( &mut self, value: PatternEnumVariant ) -> Result<PatternEnumVariant, NoError>

source§

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

source§

fn rewrite(&mut self, value: PatternLiteral) -> Result<PatternLiteral, NoError>

source§

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

source§

fn rewrite( &mut self, value: PatternOtherwise ) -> Result<PatternOtherwise, NoError>

source§

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

source§

fn rewrite(&mut self, value: PatternStruct) -> Result<PatternStruct, NoError>

source§

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

source§

fn rewrite(&mut self, value: PatternTuple) -> Result<PatternTuple, NoError>

source§

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

source§

fn rewrite( &mut self, value: PatternVariable ) -> Result<PatternVariable, NoError>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn rewrite(&mut self, value: StatementBreak) -> Result<StatementBreak, NoError>

source§

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

source§

fn rewrite( &mut self, value: StatementContinue ) -> Result<StatementContinue, NoError>

source§

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

source§

fn rewrite(&mut self, value: StatementExpr) -> Result<StatementExpr, NoError>

source§

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

source§

fn rewrite(&mut self, value: StatementLet) -> Result<StatementLet, NoError>

source§

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

source§

fn rewrite( &mut self, value: StatementReturn ) -> Result<StatementReturn, NoError>

source§

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

source§

fn rewrite(&mut self, value: StructId) -> Result<StructId, NoError>

source§

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

source§

fn rewrite( &mut self, value: TraitFunctionId ) -> Result<TraitFunctionId, NoError>

source§

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

source§

fn rewrite(&mut self, value: TraitId) -> Result<TraitId, NoError>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn rewrite(&mut self, value: TypeVar) -> Result<TypeVar, NoError>

source§

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

source§

fn rewrite(&mut self, value: UninferredImpl) -> Result<UninferredImpl, NoError>

source§

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

source§

fn rewrite(&mut self, value: VarId) -> Result<VarId, NoError>

source§

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

source§

fn rewrite(&mut self, value: VariantId) -> Result<VariantId, NoError>

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T0, T1, E, TRewriter> SemanticRewriter<(T0, T1), E> for TRewriterwhere TRewriter: SemanticRewriter<T0, E> + SemanticRewriter<T1, E>,

source§

fn rewrite(&mut self, value: (T0, T1)) -> Result<(T0, T1), E>

source§

impl<T, E, TRewriter> SemanticRewriter<Box<T, Global>, E> for TRewriterwhere T: Clone, TRewriter: SemanticRewriter<T, E>,

source§

fn rewrite(&mut self, value: Box<T, Global>) -> Result<Box<T, Global>, E>

source§

impl<T, E, TRewriter> SemanticRewriter<Option<T>, E> for TRewriterwhere TRewriter: SemanticRewriter<T, E>,

source§

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

source§

impl<T, E, TRewriter, E2> SemanticRewriter<Result<T, E2>, E> for TRewriterwhere TRewriter: SemanticRewriter<T, E>,

source§

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

source§

impl<T, E, TRewriter> SemanticRewriter<Vec<T, Global>, E> for TRewriterwhere TRewriter: SemanticRewriter<T, E>,

source§

fn rewrite(&mut self, value: Vec<T, Global>) -> Result<Vec<T, Global>, E>

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> Upcast<T> for Twhere T: ?Sized,

source§

fn upcast(&self) -> &T

source§

impl<T> UpcastMut<T> for Twhere T: ?Sized,

source§

fn upcast_mut(&mut self) -> &mut T