Enum cairo_lang_semantic::expr::inference::InferenceError

pub enum InferenceError {
    Failed(DiagnosticAdded),
    Cycle {
        var: InferenceVar,
    },
    TypeKindMismatch {
        ty0: TypeId,
        ty1: TypeId,
    },
    ImplKindMismatch {
        impl0: ImplId,
        impl1: ImplId,
    },
    GenericArgMismatch {
        garg0: GenericArgumentId,
        garg1: GenericArgumentId,
    },
    TraitMismatch {
        trt0: TraitId,
        trt1: TraitId,
    },
    ConstInferenceNotSupported,
    NoImplsFound {
        concrete_trait_id: ConcreteTraitId,
    },
    MultipleImplsFound {
        concrete_trait_id: ConcreteTraitId,
        impls: Vec<UninferredImpl>,
    },
    TypeNotInferred {
        ty: TypeId,
    },
    WillNotInfer {
        concrete_trait_id: ConcreteTraitId,
    },
    AlreadyReported,
}

Variants

Failed(DiagnosticAdded)

Cycle

Fields

var: InferenceVar

TypeKindMismatch

Fields

ty0: TypeId

ty1: TypeId

ImplKindMismatch

Fields

impl0: ImplId

impl1: ImplId

GenericArgMismatch

Fields

garg0: GenericArgumentId

garg1: GenericArgumentId

TraitMismatch

Fields

trt0: TraitId

trt1: TraitId

ConstInferenceNotSupported

NoImplsFound

Fields

concrete_trait_id: ConcreteTraitId

MultipleImplsFound

Fields

concrete_trait_id: ConcreteTraitId

impls: Vec<UninferredImpl>

TypeNotInferred

Fields

ty: TypeId

WillNotInfer

Fields

concrete_trait_id: ConcreteTraitId

AlreadyReported

Implementations

impl InferenceError

pub fn format(&self, db: &(dyn SemanticGroup + 'static)) -> String

impl InferenceError

pub fn report( &self, diagnostics: &mut SemanticDiagnostics, stable_ptr: SyntaxStablePtrId ) -> DiagnosticAdded

Trait Implementations

impl Clone for InferenceError

fn clone(&self) -> InferenceError

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InferenceError

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

Formats the value using the given formatter.

impl From<DiagnosticAdded> for InferenceError

fn from(value: DiagnosticAdded) -> Self

Converts to this type from the input type.

impl Hash for InferenceError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<InferenceError> for InferenceError

fn eq(&self, other: &InferenceError) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Eq for InferenceError

impl StructuralEq for InferenceError

impl StructuralPartialEq for InferenceError