Struct cairo_lang_semantic::expr::inference::Inference

pub struct Inference<'db> {
    pub data: &'db mut InferenceData,
    /* private fields */
}

State of inference. A system of inference constraints.

Fields

data: &'db mut InferenceData

Implementations

impl<'db> Inference<'db>

pub fn with_data( db: &'db dyn SemanticGroup, data: &'db mut InferenceData ) -> Self

Creates a new Inference instance with the given InferenceData.

pub fn clone_data(&self) -> InferenceData

pub fn impl_assignment(&self, var_id: LocalImplVarId) -> Option<ImplId>

Getter for an impl var assignment.

pub fn new_type_var(&mut self, stable_ptr: Option<SyntaxStablePtrId>) -> TypeId

Allocates a new TypeVar for an unknown type that needs to be inferred. Returns a wrapping TypeId.

pub fn new_type_var_raw( &mut self, stable_ptr: Option<SyntaxStablePtrId> ) -> TypeVar

Allocates a new TypeVar for an unknown type that needs to be inferred. Returns the variable id.

pub fn new_impl_var( &mut self, concrete_trait_id: ConcreteTraitId, stable_ptr: Option<SyntaxStablePtrId>, lookup_context: ImplLookupContext ) -> InferenceResult<ImplId>

Allocates a new ImplVar for an unknown type that needs to be inferred. Returns a wrapping ImplId.

pub fn solve(&mut self) -> InferenceResult<()>

Solves the inference system. After a successful solve, there are no more pending impl inferences.

pub fn solution_set(&mut self) -> InferenceResult<SolutionSet<()>>

Returns the solution set status for the inference: Whether there is a unique solution, multiple solutions, no solutions or an error.

pub fn finalize( &mut self ) -> Option<(Option<SyntaxStablePtrId>, InferenceError)>

Finalizes an inference by inferring uninferred numeric literals as felt252.

pub fn first_undetermined_variable( &mut self ) -> Option<(InferenceVar, InferenceError)>

Retrieves the first variable that is still not inferred, or None, if everything is inferred.

pub fn trait_solution_set( &mut self, concrete_trait_id: ConcreteTraitId, lookup_context: ImplLookupContext ) -> InferenceResult<SolutionSet<(CanonicalImpl, CanonicalMapping)>>

Computes the solution set for an trait with a recursive query.

Methods from Deref<Target = InferenceData>

pub fn inference<'db, 'b: 'db>( &'db mut self, db: &'b dyn SemanticGroup ) -> Inference<'db>

Trait Implementations

impl<'db> Debug for Inference<'db>

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

Formats the value using the given formatter.

impl Deref for Inference<'_>

type Target = InferenceData

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Inference<'_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a> HasDb<&'a dyn SemanticGroup> for Inference<'a>

fn get_db(&self) -> &'a dyn SemanticGroup

impl<'db> InferenceConform for Inference<'db>

fn conform_ty( &mut self, ty0: TypeId, ty1: TypeId ) -> Result<TypeId, InferenceError>

Conforms ty0 to ty1. Should be called when ty0 should be coerced to ty1. Not symmetric. Returns the reduced type for ty0, or an error if the type is no coercible.

fn conform_ty_ex( &mut self, ty0: TypeId, ty1: TypeId, ty0_is_self: bool ) -> Result<(TypeId, usize), InferenceError>

Same as conform_ty but supports adding snapshots to ty0 if ty0_is_self is true. Returns the reduced type for ty0 and the number of snapshots that needs to be added for the types to conform.

fn conform_generic_args( &mut self, gargs0: &[GenericArgumentId], gargs1: &[GenericArgumentId] ) -> Result<Vec<GenericArgumentId>, InferenceError>

Conforms generics args. See conform_ty().

fn conform_generic_arg( &mut self, garg0: GenericArgumentId, garg1: GenericArgumentId ) -> Result<GenericArgumentId, InferenceError>

Conforms a generics arg. See conform_ty().

fn conform_impl( &mut self, impl0: ImplId, impl1: ImplId ) -> InferenceResult<ImplId>

Conforms an impl. See conform_ty().

fn conform_traits( &mut self, trt0: ConcreteTraitId, trt1: ConcreteTraitId ) -> Result<ConcreteTraitId, InferenceError>

Conforms generics traits. See conform_ty().

fn ty_contains_var( &mut self, ty: TypeId, var: InferenceVar ) -> InferenceResult<bool>

Checks if a type tree contains a certain InferenceVar somewhere. Used to avoid inference cycles.

fn generic_args_contain_var( &mut self, generic_args: &[GenericArgumentId], var: InferenceVar ) -> InferenceResult<bool>

Checks if a slice of generics arguments contain a certain InferenceVar somewhere. Used to avoid inference cycles.

fn impl_contains_var( &mut self, impl_id: &ImplId, var: InferenceVar ) -> Result<bool, InferenceError>

Checks if an impl contains a certain InferenceVar somewhere. Used to avoid inference cycles.

fn maybe_peel_snapshots( &mut self, ty0_is_self: bool, ty1: TypeId ) -> (usize, TypeLongId)

impl<'db> InferenceEmbeddings for Inference<'db>

fn infer_impl( &mut self, uninferred_impl: UninferredImpl, concrete_trait_id: ConcreteTraitId, lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<ImplId>

Infers all the variables required to make an uninferred impl provide a concrete trait.

fn infer_impl_def( &mut self, impl_def_id: ImplDefId, concrete_trait_id: ConcreteTraitId, lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<ImplId>

Infers all the variables required to make an impl (possibly with free generic params) provide a concrete trait.

fn infer_impl_alias( &mut self, impl_alias_id: ImplAliasId, concrete_trait_id: ConcreteTraitId, lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<ImplId>

Infers all the variables required to make an impl alias (possibly with free generic params) provide a concrete trait.

fn infer_generic_assignment( &mut self, generic_params: &[GenericParam], generic_args: &[GenericArgumentId], expected_generic_args: &[GenericArgumentId], lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<Vec<GenericArgumentId>>

Chooses and assignment to generic_params s.t. generic_args will be substituted to expected_generic_args. Returns the generic_params assignment.

fn infer_generic_args( &mut self, generic_params: &[GenericParam], lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<Vec<GenericArgumentId>>

Infers all generic_arguments given the parameters.

fn infer_concrete_trait_by_self( &mut self, trait_function: TraitFunctionId, self_ty: TypeId, lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> Option<(ConcreteTraitId, usize)>

Tries to infer a trait function as a method for self_ty. Supports snapshot snapshot coercions.

Returns the deduced type and the number of snapshots that need to be added to it.

fn infer_generic_arg( &mut self, param: &GenericParam, lookup_context: ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<GenericArgumentId>

Infers a generic argument to be passed as a generic paramter. Allocates a new inference variable of the correct kind, and wraps in a generic argument.

fn infer_trait_function( &mut self, concrete_trait_function: ConcreteTraitGenericFunctionId, lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<FunctionId>

Infers the impl to be substituted instead of a trait for a given trait function, and the generic arguments to be passed to the function. Returns the resulting impl function.

fn infer_generic_function( &mut self, generic_function: GenericFunctionId, lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<FunctionId>

Infers generic arguments to be passed to a generic function. Returns the resulting specialized function.

fn infer_trait_generic_function( &mut self, trait_function: ConcreteTraitGenericFunctionId, lookup_context: &ImplLookupContext, stable_ptr: Option<SyntaxStablePtrId> ) -> InferenceResult<GenericFunctionId>

Infers the impl to be substituted instead of a trait for a given trait function. Returns the resulting impl generic function.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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