GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing docs.rs — RandomLocator in rustpython_parser::source_code - Rust

rustpython_parser::source_code

Struct RandomLocator

pub struct RandomLocator<'a> {
    pub source: &'a str,
    /* private fields */
}

Expand description

Converts source code byte-offset to Python convention line and column numbers.

Fields§

§source: &'a str

Implementations§

Source §

pub fn locate_error<T, U>(&mut self, base: BaseError<T>) -> LocatedError
where T: Into,

Trait Implementations§

Source §

impl Fold<TextRange> for RandomLocator<'_>

Source §

type TargetU = SourceRange

Source §

type Error = !

Source §

type UserContext = SourceLocation

Source §

fn will_map_user( &mut self, user: &TextRange, ) -> <RandomLocator<'_> as Fold<TextRange>>::UserContext

Source §

fn map_user( &mut self, user: TextRange, start: <RandomLocator<'_> as Fold<TextRange>>::UserContext, ) -> Result<<RandomLocator<'_> as Fold<TextRange>>::TargetU, <RandomLocator<'_> as Fold<TextRange>>::Error>

Source §

fn will_map_user_cfg( &mut self, _user: &EmptyRange, ) -> EmptyRange<Self::TargetU>

Source §

fn map_user_cfg( &mut self, _user: EmptyRange, _context: EmptyRange<Self::TargetU>, ) -> Result<EmptyRange<Self::TargetU>, Self::Error>

Source §

fn fold<X>( &mut self, node: X, ) -> Result<<X as Foldable<U, Self::TargetU>>::Mapped, Self::Error>
where X: Foldable<U, Self::TargetU>,

Source §

fn fold_mod(&mut self, node: Mod) -> Result<Mod<Self::TargetU>, Self::Error>

Source §

fn fold_mod_module( &mut self, node: ModModule, ) -> Result<ModModule<Self::TargetU>, Self::Error>

Source §

fn fold_mod_interactive( &mut self, node: ModInteractive, ) -> Result<ModInteractive<Self::TargetU>, Self::Error>

Source §

fn fold_mod_expression( &mut self, node: ModExpression, ) -> Result<ModExpression<Self::TargetU>, Self::Error>

Source §

fn fold_mod_function_type( &mut self, node: ModFunctionType, ) -> Result<ModFunctionType<Self::TargetU>, Self::Error>

Source §

fn fold_stmt( &mut self, node: Stmt, ) -> Result<Stmt<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_function_def( &mut self, node: StmtFunctionDef, ) -> Result<StmtFunctionDef<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_async_function_def( &mut self, node: StmtAsyncFunctionDef, ) -> Result<StmtAsyncFunctionDef<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_class_def( &mut self, node: StmtClassDef, ) -> Result<StmtClassDef<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_return( &mut self, node: StmtReturn, ) -> Result<StmtReturn<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_delete( &mut self, node: StmtDelete, ) -> Result<StmtDelete<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_assign( &mut self, node: StmtAssign, ) -> Result<StmtAssign<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_type_alias( &mut self, node: StmtTypeAlias, ) -> Result<StmtTypeAlias<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_aug_assign( &mut self, node: StmtAugAssign, ) -> Result<StmtAugAssign<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_ann_assign( &mut self, node: StmtAnnAssign, ) -> Result<StmtAnnAssign<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_for( &mut self, node: StmtFor, ) -> Result<StmtFor<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_async_for( &mut self, node: StmtAsyncFor, ) -> Result<StmtAsyncFor<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_while( &mut self, node: StmtWhile, ) -> Result<StmtWhile<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_if( &mut self, node: StmtIf, ) -> Result<StmtIf<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_with( &mut self, node: StmtWith, ) -> Result<StmtWith<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_async_with( &mut self, node: StmtAsyncWith, ) -> Result<StmtAsyncWith<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_match( &mut self, node: StmtMatch, ) -> Result<StmtMatch<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_raise( &mut self, node: StmtRaise, ) -> Result<StmtRaise<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_try( &mut self, node: StmtTry, ) -> Result<StmtTry<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_try_star( &mut self, node: StmtTryStar, ) -> Result<StmtTryStar<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_assert( &mut self, node: StmtAssert, ) -> Result<StmtAssert<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_import( &mut self, node: StmtImport, ) -> Result<StmtImport<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_import_from( &mut self, node: StmtImportFrom, ) -> Result<StmtImportFrom<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_global( &mut self, node: StmtGlobal, ) -> Result<StmtGlobal<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_nonlocal( &mut self, node: StmtNonlocal, ) -> Result<StmtNonlocal<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_expr( &mut self, node: StmtExpr, ) -> Result<StmtExpr<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_pass( &mut self, node: StmtPass, ) -> Result<StmtPass<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_break( &mut self, node: StmtBreak, ) -> Result<StmtBreak<Self::TargetU>, Self::Error>

Source §

fn fold_stmt_continue( &mut self, node: StmtContinue, ) -> Result<StmtContinue<Self::TargetU>, Self::Error>

Source §

fn fold_expr( &mut self, node: Expr, ) -> Result<Expr<Self::TargetU>, Self::Error>

Source §

fn fold_expr_bool_op( &mut self, node: ExprBoolOp, ) -> Result<ExprBoolOp<Self::TargetU>, Self::Error>

Source §

fn fold_expr_named_expr( &mut self, node: ExprNamedExpr, ) -> Result<ExprNamedExpr<Self::TargetU>, Self::Error>

Source §

fn fold_expr_bin_op( &mut self, node: ExprBinOp, ) -> Result<ExprBinOp<Self::TargetU>, Self::Error>

Source §

fn fold_expr_unary_op( &mut self, node: ExprUnaryOp, ) -> Result<ExprUnaryOp<Self::TargetU>, Self::Error>

Source §

fn fold_expr_lambda( &mut self, node: ExprLambda, ) -> Result<ExprLambda<Self::TargetU>, Self::Error>

Source §

fn fold_expr_if_exp( &mut self, node: ExprIfExp, ) -> Result<ExprIfExp<Self::TargetU>, Self::Error>

Source §

fn fold_expr_dict( &mut self, node: ExprDict, ) -> Result<ExprDict<Self::TargetU>, Self::Error>

Source §

fn fold_expr_set( &mut self, node: ExprSet, ) -> Result<ExprSet<Self::TargetU>, Self::Error>

Source §

fn fold_expr_list_comp( &mut self, node: ExprListComp, ) -> Result<ExprListComp<Self::TargetU>, Self::Error>

Source §

fn fold_expr_set_comp( &mut self, node: ExprSetComp, ) -> Result<ExprSetComp<Self::TargetU>, Self::Error>

Source §

fn fold_expr_dict_comp( &mut self, node: ExprDictComp, ) -> Result<ExprDictComp<Self::TargetU>, Self::Error>

Source §

fn fold_expr_generator_exp( &mut self, node: ExprGeneratorExp, ) -> Result<ExprGeneratorExp<Self::TargetU>, Self::Error>

Source §

fn fold_expr_await( &mut self, node: ExprAwait, ) -> Result<ExprAwait<Self::TargetU>, Self::Error>

Source §

fn fold_expr_yield( &mut self, node: ExprYield, ) -> Result<ExprYield<Self::TargetU>, Self::Error>

Source §

fn fold_expr_yield_from( &mut self, node: ExprYieldFrom, ) -> Result<ExprYieldFrom<Self::TargetU>, Self::Error>

Source §

fn fold_expr_compare( &mut self, node: ExprCompare, ) -> Result<ExprCompare<Self::TargetU>, Self::Error>

Source §

fn fold_expr_call( &mut self, node: ExprCall, ) -> Result<ExprCall<Self::TargetU>, Self::Error>

Source §

fn fold_expr_formatted_value( &mut self, node: ExprFormattedValue, ) -> Result<ExprFormattedValue<Self::TargetU>, Self::Error>

Source §

fn fold_expr_joined_str( &mut self, node: ExprJoinedStr, ) -> Result<ExprJoinedStr<Self::TargetU>, Self::Error>

Source §

fn fold_expr_constant( &mut self, node: ExprConstant, ) -> Result<ExprConstant<Self::TargetU>, Self::Error>

Source §

fn fold_expr_attribute( &mut self, node: ExprAttribute, ) -> Result<ExprAttribute<Self::TargetU>, Self::Error>

Source §

fn fold_expr_subscript( &mut self, node: ExprSubscript, ) -> Result<ExprSubscript<Self::TargetU>, Self::Error>

Source §

fn fold_expr_starred( &mut self, node: ExprStarred, ) -> Result<ExprStarred<Self::TargetU>, Self::Error>

Source §

fn fold_expr_name( &mut self, node: ExprName, ) -> Result<ExprName<Self::TargetU>, Self::Error>

Source §

fn fold_expr_list( &mut self, node: ExprList, ) -> Result<ExprList<Self::TargetU>, Self::Error>

Source §

fn fold_expr_tuple( &mut self, node: ExprTuple, ) -> Result<ExprTuple<Self::TargetU>, Self::Error>

Source §

fn fold_expr_slice( &mut self, node: ExprSlice, ) -> Result<ExprSlice<Self::TargetU>, Self::Error>

Source §

fn fold_expr_context( &mut self, node: ExprContext, ) -> Result<ExprContext, Self::Error>

Source §

fn fold_boolop(&mut self, node: BoolOp) -> Result<BoolOp, Self::Error>

Source §

fn fold_operator(&mut self, node: Operator) -> Result<Operator, Self::Error>

Source §

fn fold_unaryop(&mut self, node: UnaryOp) -> Result<UnaryOp, Self::Error>

Source §

fn fold_cmpop(&mut self, node: CmpOp) -> Result<CmpOp, Self::Error>

Source §

fn fold_comprehension( &mut self, node: Comprehension, ) -> Result<Comprehension<Self::TargetU>, Self::Error>

Source §

fn fold_excepthandler( &mut self, node: ExceptHandler, ) -> Result<ExceptHandler<Self::TargetU>, Self::Error>

Source §

fn fold_excepthandler_except_handler( &mut self, node: ExceptHandlerExceptHandler, ) -> Result<ExceptHandlerExceptHandler<Self::TargetU>, Self::Error>

Source §

fn fold_arguments( &mut self, node: Arguments, ) -> Result<Arguments<Self::TargetU>, Self::Error>

Source §

fn fold_arg(&mut self, node: Arg) -> Result<Arg<Self::TargetU>, Self::Error>

Source §

fn fold_keyword( &mut self, node: Keyword, ) -> Result<Keyword<Self::TargetU>, Self::Error>

Source §

fn fold_alias( &mut self, node: Alias, ) -> Result<Alias<Self::TargetU>, Self::Error>

Source §

fn fold_withitem( &mut self, node: WithItem, ) -> Result<WithItem<Self::TargetU>, Self::Error>

Source §

fn fold_match_case( &mut self, node: MatchCase, ) -> Result<MatchCase<Self::TargetU>, Self::Error>

Source §

fn fold_pattern( &mut self, node: Pattern, ) -> Result<Pattern<Self::TargetU>, Self::Error>

Source §

fn fold_pattern_match_value( &mut self, node: PatternMatchValue, ) -> Result<PatternMatchValue<Self::TargetU>, Self::Error>

Source §

fn fold_pattern_match_singleton( &mut self, node: PatternMatchSingleton, ) -> Result<PatternMatchSingleton<Self::TargetU>, Self::Error>

Source §

fn fold_pattern_match_sequence( &mut self, node: PatternMatchSequence, ) -> Result<PatternMatchSequence<Self::TargetU>, Self::Error>

Source §

fn fold_pattern_match_mapping( &mut self, node: PatternMatchMapping, ) -> Result<PatternMatchMapping<Self::TargetU>, Self::Error>

Source §

fn fold_pattern_match_class( &mut self, node: PatternMatchClass, ) -> Result<PatternMatchClass<Self::TargetU>, Self::Error>

Source §

fn fold_pattern_match_star( &mut self, node: PatternMatchStar, ) -> Result<PatternMatchStar<Self::TargetU>, Self::Error>

Source §

fn fold_pattern_match_as( &mut self, node: PatternMatchAs, ) -> Result<PatternMatchAs<Self::TargetU>, Self::Error>

Source §

fn fold_pattern_match_or( &mut self, node: PatternMatchOr, ) -> Result<PatternMatchOr<Self::TargetU>, Self::Error>

Source §

fn fold_type_ignore( &mut self, node: TypeIgnore, ) -> Result<TypeIgnore<Self::TargetU>, Self::Error>

Source §

fn fold_type_ignore_type_ignore( &mut self, node: TypeIgnoreTypeIgnore, ) -> Result<TypeIgnoreTypeIgnore<Self::TargetU>, Self::Error>

Source §

fn fold_type_param( &mut self, node: TypeParam, ) -> Result<TypeParam<Self::TargetU>, Self::Error>

Source §

fn fold_type_param_type_var( &mut self, node: TypeParamTypeVar, ) -> Result<TypeParamTypeVar<Self::TargetU>, Self::Error>

Source §

fn fold_type_param_param_spec( &mut self, node: TypeParamParamSpec, ) -> Result<TypeParamParamSpec<Self::TargetU>, Self::Error>

Source §

fn fold_type_param_type_var_tuple( &mut self, node: TypeParamTypeVarTuple, ) -> Result<TypeParamTypeVarTuple<Self::TargetU>, Self::Error>

Source §

fn fold_arg_with_default( &mut self, node: ArgWithDefault, ) -> Result<ArgWithDefault<Self::TargetU>, Self::Error>

Auto Trait Implementations§

impl<'a> Freeze for RandomLocator<'a>

impl<'a> RefUnwindSafe for RandomLocator<'a>

impl<'a> Send for RandomLocator<'a>

impl<'a> Sync for RandomLocator<'a>

impl<'a> Unpin for RandomLocator<'a>

impl<'a> UnsafeUnpin for RandomLocator<'a>

impl<'a> UnwindSafe for RandomLocator<'a>

Blanket Implementations§

Source §

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

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

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

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

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

Source §

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

Mutably borrows from an owned value. Read more

Source §

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source §

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source §

impl<T, U> ExactFrom<T> for U
where U: TryFrom<T>,

Source §

fn exact_from(value: T) -> U

Source §

impl<T, U> ExactInto for T
where U: ExactFrom<T>,

Source §

fn exact_into(self) -> U

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, U> Into for T
where 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<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

impl<T, U> OverflowingInto for T
where U: OverflowingFrom<T>,

Source §

fn overflowing_into(self) -> (U, bool)

Source §

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source §

impl<T, U> RoundingInto for T
where U: RoundingFrom<T>,

Source §

fn rounding_into(self, rm: RoundingMode) -> (U, Ordering)

Source §

impl<T, U> SaturatingInto for T
where U: SaturatingFrom<T>,

Source §

fn saturating_into(self) -> U

Source §

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

Source §

type Error = !

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, !>

Performs the conversion.

Source §

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

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

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

Performs the conversion.

Source §

impl<T, U> WrappingInto for T
where U: WrappingFrom<T>,

Source §

fn wrapping_into(self) -> U

You are visitor 01402520 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.

GeezerVison

Struct RandomLocator

Fields§

Implementations§

impl<'a> RandomLocator<'a>

pub fn new(source: &'a str) -> RandomLocator<'a>

pub fn to_source_code(&self) -> SourceCode<'_, '_>

pub fn locate(&mut self, offset: TextSize) -> SourceLocation

pub fn locate_error<T, U>(&mut self, base: BaseError<T>) -> LocatedError<U>where T: Into<U>,

Trait Implementations§

impl Fold<TextRange> for RandomLocator<'_>

type TargetU = SourceRange

type Error = !

type UserContext = SourceLocation

fn will_map_user( &mut self, user: &TextRange, ) -> <RandomLocator<'_> as Fold<TextRange>>::UserContext

fn map_user( &mut self, user: TextRange, start: <RandomLocator<'_> as Fold<TextRange>>::UserContext, ) -> Result<<RandomLocator<'_> as Fold<TextRange>>::TargetU, <RandomLocator<'_> as Fold<TextRange>>::Error>

fn will_map_user_cfg( &mut self, _user: &EmptyRange<U>, ) -> EmptyRange<Self::TargetU>

fn map_user_cfg( &mut self, _user: EmptyRange<U>, _context: EmptyRange<Self::TargetU>, ) -> Result<EmptyRange<Self::TargetU>, Self::Error>

fn fold<X>( &mut self, node: X, ) -> Result<<X as Foldable<U, Self::TargetU>>::Mapped, Self::Error>where X: Foldable<U, Self::TargetU>,

fn fold_mod(&mut self, node: Mod<U>) -> Result<Mod<Self::TargetU>, Self::Error>

fn fold_mod_module( &mut self, node: ModModule<U>, ) -> Result<ModModule<Self::TargetU>, Self::Error>

fn fold_mod_interactive( &mut self, node: ModInteractive<U>, ) -> Result<ModInteractive<Self::TargetU>, Self::Error>

fn fold_mod_expression( &mut self, node: ModExpression<U>, ) -> Result<ModExpression<Self::TargetU>, Self::Error>

fn fold_mod_function_type( &mut self, node: ModFunctionType<U>, ) -> Result<ModFunctionType<Self::TargetU>, Self::Error>

fn fold_stmt( &mut self, node: Stmt<U>, ) -> Result<Stmt<Self::TargetU>, Self::Error>

fn fold_stmt_function_def( &mut self, node: StmtFunctionDef<U>, ) -> Result<StmtFunctionDef<Self::TargetU>, Self::Error>

fn fold_stmt_async_function_def( &mut self, node: StmtAsyncFunctionDef<U>, ) -> Result<StmtAsyncFunctionDef<Self::TargetU>, Self::Error>

fn fold_stmt_class_def( &mut self, node: StmtClassDef<U>, ) -> Result<StmtClassDef<Self::TargetU>, Self::Error>

fn fold_stmt_return( &mut self, node: StmtReturn<U>, ) -> Result<StmtReturn<Self::TargetU>, Self::Error>

fn fold_stmt_delete( &mut self, node: StmtDelete<U>, ) -> Result<StmtDelete<Self::TargetU>, Self::Error>

fn fold_stmt_assign( &mut self, node: StmtAssign<U>, ) -> Result<StmtAssign<Self::TargetU>, Self::Error>

fn fold_stmt_type_alias( &mut self, node: StmtTypeAlias<U>, ) -> Result<StmtTypeAlias<Self::TargetU>, Self::Error>

fn fold_stmt_aug_assign( &mut self, node: StmtAugAssign<U>, ) -> Result<StmtAugAssign<Self::TargetU>, Self::Error>

fn fold_stmt_ann_assign( &mut self, node: StmtAnnAssign<U>, ) -> Result<StmtAnnAssign<Self::TargetU>, Self::Error>

fn fold_stmt_for( &mut self, node: StmtFor<U>, ) -> Result<StmtFor<Self::TargetU>, Self::Error>

fn fold_stmt_async_for( &mut self, node: StmtAsyncFor<U>, ) -> Result<StmtAsyncFor<Self::TargetU>, Self::Error>

fn fold_stmt_while( &mut self, node: StmtWhile<U>, ) -> Result<StmtWhile<Self::TargetU>, Self::Error>

fn fold_stmt_if( &mut self, node: StmtIf<U>, ) -> Result<StmtIf<Self::TargetU>, Self::Error>

fn fold_stmt_with( &mut self, node: StmtWith<U>, ) -> Result<StmtWith<Self::TargetU>, Self::Error>

fn fold_stmt_async_with( &mut self, node: StmtAsyncWith<U>, ) -> Result<StmtAsyncWith<Self::TargetU>, Self::Error>

fn fold_stmt_match( &mut self, node: StmtMatch<U>, ) -> Result<StmtMatch<Self::TargetU>, Self::Error>

fn fold_stmt_raise( &mut self, node: StmtRaise<U>, ) -> Result<StmtRaise<Self::TargetU>, Self::Error>

fn fold_stmt_try( &mut self, node: StmtTry<U>, ) -> Result<StmtTry<Self::TargetU>, Self::Error>

fn fold_stmt_try_star( &mut self, node: StmtTryStar<U>, ) -> Result<StmtTryStar<Self::TargetU>, Self::Error>

fn fold_stmt_assert( &mut self, node: StmtAssert<U>, ) -> Result<StmtAssert<Self::TargetU>, Self::Error>

fn fold_stmt_import( &mut self, node: StmtImport<U>, ) -> Result<StmtImport<Self::TargetU>, Self::Error>

fn fold_stmt_import_from( &mut self, node: StmtImportFrom<U>, ) -> Result<StmtImportFrom<Self::TargetU>, Self::Error>

fn fold_stmt_global( &mut self, node: StmtGlobal<U>, ) -> Result<StmtGlobal<Self::TargetU>, Self::Error>

fn fold_stmt_nonlocal( &mut self, node: StmtNonlocal<U>, ) -> Result<StmtNonlocal<Self::TargetU>, Self::Error>

fn fold_stmt_expr( &mut self, node: StmtExpr<U>, ) -> Result<StmtExpr<Self::TargetU>, Self::Error>

fn fold_stmt_pass( &mut self, node: StmtPass<U>, ) -> Result<StmtPass<Self::TargetU>, Self::Error>

fn fold_stmt_break( &mut self, node: StmtBreak<U>, ) -> Result<StmtBreak<Self::TargetU>, Self::Error>

fn fold_stmt_continue( &mut self, node: StmtContinue<U>, ) -> Result<StmtContinue<Self::TargetU>, Self::Error>

fn fold_expr( &mut self, node: Expr<U>, ) -> Result<Expr<Self::TargetU>, Self::Error>

fn fold_expr_bool_op( &mut self, node: ExprBoolOp<U>, ) -> Result<ExprBoolOp<Self::TargetU>, Self::Error>

fn fold_expr_named_expr( &mut self, node: ExprNamedExpr<U>, ) -> Result<ExprNamedExpr<Self::TargetU>, Self::Error>

fn fold_expr_bin_op( &mut self, node: ExprBinOp<U>, ) -> Result<ExprBinOp<Self::TargetU>, Self::Error>

fn fold_expr_unary_op( &mut self, node: ExprUnaryOp<U>, ) -> Result<ExprUnaryOp<Self::TargetU>, Self::Error>

fn fold_expr_lambda( &mut self, node: ExprLambda<U>, ) -> Result<ExprLambda<Self::TargetU>, Self::Error>

fn fold_expr_if_exp( &mut self, node: ExprIfExp<U>, ) -> Result<ExprIfExp<Self::TargetU>, Self::Error>

fn fold_expr_dict( &mut self, node: ExprDict<U>, ) -> Result<ExprDict<Self::TargetU>, Self::Error>

fn fold_expr_set( &mut self, node: ExprSet<U>, ) -> Result<ExprSet<Self::TargetU>, Self::Error>

fn fold_expr_list_comp( &mut self, node: ExprListComp<U>, ) -> Result<ExprListComp<Self::TargetU>, Self::Error>

fn fold_expr_set_comp( &mut self, node: ExprSetComp<U>, ) -> Result<ExprSetComp<Self::TargetU>, Self::Error>

fn fold_expr_dict_comp( &mut self, node: ExprDictComp<U>, ) -> Result<ExprDictComp<Self::TargetU>, Self::Error>

fn fold_expr_generator_exp( &mut self, node: ExprGeneratorExp<U>, ) -> Result<ExprGeneratorExp<Self::TargetU>, Self::Error>

fn fold_expr_await( &mut self, node: ExprAwait<U>, ) -> Result<ExprAwait<Self::TargetU>, Self::Error>

fn fold_expr_yield( &mut self, node: ExprYield<U>, ) -> Result<ExprYield<Self::TargetU>, Self::Error>

fn fold_expr_yield_from( &mut self, node: ExprYieldFrom<U>, ) -> Result<ExprYieldFrom<Self::TargetU>, Self::Error>

fn fold_expr_compare( &mut self, node: ExprCompare<U>, ) -> Result<ExprCompare<Self::TargetU>, Self::Error>

fn fold_expr_call( &mut self, node: ExprCall<U>, ) -> Result<ExprCall<Self::TargetU>, Self::Error>

fn fold_expr_formatted_value( &mut self, node: ExprFormattedValue<U>, ) -> Result<ExprFormattedValue<Self::TargetU>, Self::Error>

fn fold_expr_joined_str( &mut self, node: ExprJoinedStr<U>, ) -> Result<ExprJoinedStr<Self::TargetU>, Self::Error>

fn fold_expr_constant( &mut self, node: ExprConstant<U>, ) -> Result<ExprConstant<Self::TargetU>, Self::Error>

fn fold_expr_attribute( &mut self, node: ExprAttribute<U>, ) -> Result<ExprAttribute<Self::TargetU>, Self::Error>

fn fold_expr_subscript( &mut self, node: ExprSubscript<U>, ) -> Result<ExprSubscript<Self::TargetU>, Self::Error>

fn fold_expr_starred( &mut self, node: ExprStarred<U>, ) -> Result<ExprStarred<Self::TargetU>, Self::Error>

fn fold_expr_name( &mut self, node: ExprName<U>, ) -> Result<ExprName<Self::TargetU>, Self::Error>

fn fold_expr_list( &mut self, node: ExprList<U>, ) -> Result<ExprList<Self::TargetU>, Self::Error>

fn fold_expr_tuple( &mut self, node: ExprTuple<U>, ) -> Result<ExprTuple<Self::TargetU>, Self::Error>

pub fn locate_error<T, U>(&mut self, base: BaseError<T>) -> LocatedError<U>
where T: Into<U>,

fn fold<X>( &mut self, node: X, ) -> Result<<X as Foldable<U, Self::TargetU>>::Mapped, Self::Error>
where X: Foldable<U, Self::TargetU>,

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

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

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

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

impl<T, U> ExactFrom<T> for U
where U: TryFrom<T>,

impl<T, U> ExactInto<U> for T
where U: ExactFrom<T>,

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

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

impl<T, U> OverflowingInto<U> for T
where U: OverflowingFrom<T>,

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

impl<T, U> RoundingInto<U> for T
where U: RoundingFrom<T>,

impl<T, U> SaturatingInto<U> for T
where U: SaturatingFrom<T>,

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