From e8e66f382488f17e2d005de3a6dd425b4b0b3bf8 Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Thu, 18 May 2023 10:19:09 -0400 Subject: [PATCH] Remove unnecessary path prefixes (#4492) --- crates/ruff/src/autofix/actions.rs | 5 +- crates/ruff/src/checkers/ast/mod.rs | 2 +- crates/ruff/src/logging.rs | 4 +- crates/ruff/src/message/text.rs | 2 +- .../ruff/src/rules/pyflakes/rules/strings.rs | 4 +- .../rules/pylint/rules/binary_op_exception.rs | 8 +- .../pyupgrade/rules/deprecated_import.rs | 2 +- crates/ruff_cache/src/cache_key.rs | 2 +- .../ruff_macros/src/derive_message_formats.rs | 2 +- crates/ruff_macros/src/lib.rs | 2 +- crates/ruff_python_ast/src/comparable.rs | 6 +- .../src/source_code/line_index.rs | 4 +- crates/ruff_python_formatter/src/cst/mod.rs | 533 ++++++++---------- 13 files changed, 252 insertions(+), 324 deletions(-) diff --git a/crates/ruff/src/autofix/actions.rs b/crates/ruff/src/autofix/actions.rs index 4442304979..fc6231bda9 100644 --- a/crates/ruff/src/autofix/actions.rs +++ b/crates/ruff/src/autofix/actions.rs @@ -268,10 +268,7 @@ pub(crate) fn remove_unused_imports<'a>( let module = module.map(compose_module_path); let member = compose_module_path(&alias.name); let mut full_name = String::with_capacity( - relative.len() - + module.as_ref().map_or(0, std::string::String::len) - + member.len() - + 1, + relative.len() + module.as_ref().map_or(0, String::len) + member.len() + 1, ); for _ in 0..relative.len() { full_name.push('.'); diff --git a/crates/ruff/src/checkers/ast/mod.rs b/crates/ruff/src/checkers/ast/mod.rs index 7f182d450d..d5e767b844 100644 --- a/crates/ruff/src/checkers/ast/mod.rs +++ b/crates/ruff/src/checkers/ast/mod.rs @@ -4096,7 +4096,7 @@ where fn visit_excepthandler(&mut self, excepthandler: &'b Excepthandler) { match excepthandler { - ast::Excepthandler::ExceptHandler(ast::ExcepthandlerExceptHandler { + Excepthandler::ExceptHandler(ast::ExcepthandlerExceptHandler { type_, name, body, diff --git a/crates/ruff/src/logging.rs b/crates/ruff/src/logging.rs index 458f27c582..dbf719aa80 100644 --- a/crates/ruff/src/logging.rs +++ b/crates/ruff/src/logging.rs @@ -200,11 +200,11 @@ struct TruncateAtNewline<'a>(&'a dyn Display); impl Display for TruncateAtNewline<'_> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { struct TruncateAdapter<'a> { - inner: &'a mut dyn std::fmt::Write, + inner: &'a mut dyn Write, after_new_line: bool, } - impl std::fmt::Write for TruncateAdapter<'_> { + impl Write for TruncateAdapter<'_> { fn write_str(&mut self, s: &str) -> std::fmt::Result { if self.after_new_line { Ok(()) diff --git a/crates/ruff/src/message/text.rs b/crates/ruff/src/message/text.rs index 252e049bc1..23249499ed 100644 --- a/crates/ruff/src/message/text.rs +++ b/crates/ruff/src/message/text.rs @@ -118,7 +118,7 @@ pub(super) struct RuleCodeAndBody<'a> { } impl Display for RuleCodeAndBody<'_> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { let kind = &self.message.kind; if self.show_fix_status && self.message.fix.is_some() { diff --git a/crates/ruff/src/rules/pyflakes/rules/strings.rs b/crates/ruff/src/rules/pyflakes/rules/strings.rs index f4b8e02b11..2324012937 100644 --- a/crates/ruff/src/rules/pyflakes/rules/strings.rs +++ b/crates/ruff/src/rules/pyflakes/rules/strings.rs @@ -269,7 +269,7 @@ pub(crate) fn percent_format_extra_named_arguments( let Expr::Dict(ast::ExprDict { keys, .. }) = &right else { return; }; - if keys.iter().any(std::option::Option::is_none) { + if keys.iter().any(Option::is_none) { return; // contains **x splat } @@ -326,7 +326,7 @@ pub(crate) fn percent_format_missing_arguments( } if let Expr::Dict(ast::ExprDict { keys, .. }) = &right { - if keys.iter().any(std::option::Option::is_none) { + if keys.iter().any(Option::is_none) { return; // contains **x splat } diff --git a/crates/ruff/src/rules/pylint/rules/binary_op_exception.rs b/crates/ruff/src/rules/pylint/rules/binary_op_exception.rs index 70b5e2e264..8ce1fc2bfd 100644 --- a/crates/ruff/src/rules/pylint/rules/binary_op_exception.rs +++ b/crates/ruff/src/rules/pylint/rules/binary_op_exception.rs @@ -11,11 +11,11 @@ enum Boolop { Or, } -impl From<&rustpython_parser::ast::Boolop> for Boolop { - fn from(op: &rustpython_parser::ast::Boolop) -> Self { +impl From<&ast::Boolop> for Boolop { + fn from(op: &ast::Boolop) -> Self { match op { - rustpython_parser::ast::Boolop::And => Boolop::And, - rustpython_parser::ast::Boolop::Or => Boolop::Or, + ast::Boolop::And => Boolop::And, + ast::Boolop::Or => Boolop::Or, } } } diff --git a/crates/ruff/src/rules/pyupgrade/rules/deprecated_import.rs b/crates/ruff/src/rules/pyupgrade/rules/deprecated_import.rs index f331fcd76d..ffc4ed6ddc 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/deprecated_import.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/deprecated_import.rs @@ -527,7 +527,7 @@ pub(crate) fn deprecated_import( return; } - let members: Vec = names.iter().map(std::clone::Clone::clone).collect(); + let members: Vec = names.iter().map(Clone::clone).collect(); let fixer = ImportReplacer::new( stmt, module, diff --git a/crates/ruff_cache/src/cache_key.rs b/crates/ruff_cache/src/cache_key.rs index 6b24ba82c4..999aa8861e 100644 --- a/crates/ruff_cache/src/cache_key.rs +++ b/crates/ruff_cache/src/cache_key.rs @@ -90,7 +90,7 @@ impl DerefMut for CacheKeyHasher { /// * Cache keys must be deterministic where hash keys do not have this constraint. That's why pointers don't implement [`CacheKey`] but they implement [`Hash`]. /// * Ideally, cache keys are portable /// -/// [`Hash`](std::hash::Hash) +/// [`Hash`](Hash) pub trait CacheKey { fn cache_key(&self, state: &mut CacheKeyHasher); diff --git a/crates/ruff_macros/src/derive_message_formats.rs b/crates/ruff_macros/src/derive_message_formats.rs index 8e6f04fe4f..f72113c223 100644 --- a/crates/ruff_macros/src/derive_message_formats.rs +++ b/crates/ruff_macros/src/derive_message_formats.rs @@ -3,7 +3,7 @@ use quote::{quote, quote_spanned, ToTokens}; use syn::spanned::Spanned; use syn::{Block, Expr, ItemFn, Stmt}; -pub(crate) fn derive_message_formats(func: &ItemFn) -> proc_macro2::TokenStream { +pub(crate) fn derive_message_formats(func: &ItemFn) -> TokenStream { let mut strings = quote!(); if let Err(err) = parse_block(&func.block, &mut strings) { diff --git a/crates/ruff_macros/src/lib.rs b/crates/ruff_macros/src/lib.rs index 74a8428781..22ffb939b3 100644 --- a/crates/ruff_macros/src/lib.rs +++ b/crates/ruff_macros/src/lib.rs @@ -24,7 +24,7 @@ pub fn derive_config(input: TokenStream) -> TokenStream { } #[proc_macro_derive(CombineOptions)] -pub fn derive_combine_options(input: proc_macro::TokenStream) -> proc_macro::TokenStream { +pub fn derive_combine_options(input: TokenStream) -> TokenStream { let input = parse_macro_input!(input as DeriveInput); combine_options::derive_impl(input) diff --git a/crates/ruff_python_ast/src/comparable.rs b/crates/ruff_python_ast/src/comparable.rs index fda1c0f8ee..3d6cba47ef 100644 --- a/crates/ruff_python_ast/src/comparable.rs +++ b/crates/ruff_python_ast/src/comparable.rs @@ -915,7 +915,7 @@ impl<'a> From<&'a Stmt> for ComparableStmt<'a> { body: body.iter().map(Into::into).collect(), decorator_list: decorator_list.iter().map(Into::into).collect(), returns: returns.as_ref().map(Into::into), - type_comment: type_comment.as_ref().map(std::string::String::as_str), + type_comment: type_comment.as_ref().map(String::as_str), }, Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { name, @@ -931,7 +931,7 @@ impl<'a> From<&'a Stmt> for ComparableStmt<'a> { body: body.iter().map(Into::into).collect(), decorator_list: decorator_list.iter().map(Into::into).collect(), returns: returns.as_ref().map(Into::into), - type_comment: type_comment.as_ref().map(std::string::String::as_str), + type_comment: type_comment.as_ref().map(String::as_str), }, Stmt::ClassDef(ast::StmtClassDef { name, @@ -967,7 +967,7 @@ impl<'a> From<&'a Stmt> for ComparableStmt<'a> { }) => Self::Assign { targets: targets.iter().map(Into::into).collect(), value: value.into(), - type_comment: type_comment.as_ref().map(std::string::String::as_str), + type_comment: type_comment.as_ref().map(String::as_str), }, Stmt::AugAssign(ast::StmtAugAssign { target, diff --git a/crates/ruff_python_ast/src/source_code/line_index.rs b/crates/ruff_python_ast/src/source_code/line_index.rs index 71e1b7139d..96916d3534 100644 --- a/crates/ruff_python_ast/src/source_code/line_index.rs +++ b/crates/ruff_python_ast/src/source_code/line_index.rs @@ -295,8 +295,8 @@ impl OneIndexed { } } -impl std::fmt::Display for OneIndexed { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { +impl fmt::Display for OneIndexed { + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { std::fmt::Debug::fmt(&self.0.get(), f) } } diff --git a/crates/ruff_python_formatter/src/cst/mod.rs b/crates/ruff_python_formatter/src/cst/mod.rs index e0222d3efe..ef398673b3 100644 --- a/crates/ruff_python_formatter/src/cst/mod.rs +++ b/crates/ruff_python_formatter/src/cst/mod.rs @@ -71,12 +71,12 @@ pub enum ExprContext { Del, } -impl From for ExprContext { - fn from(context: rustpython_parser::ast::ExprContext) -> Self { +impl From for ExprContext { + fn from(context: ast::ExprContext) -> Self { match context { - rustpython_parser::ast::ExprContext::Load => Self::Load, - rustpython_parser::ast::ExprContext::Store => Self::Store, - rustpython_parser::ast::ExprContext::Del => Self::Del, + ast::ExprContext::Load => Self::Load, + ast::ExprContext::Store => Self::Store, + ast::ExprContext::Del => Self::Del, } } } @@ -87,11 +87,11 @@ pub enum BoolOpKind { Or, } -impl From<&rustpython_parser::ast::Boolop> for BoolOpKind { - fn from(op: &rustpython_parser::ast::Boolop) -> Self { +impl From<&ast::Boolop> for BoolOpKind { + fn from(op: &ast::Boolop) -> Self { match op { - rustpython_parser::ast::Boolop::And => Self::And, - rustpython_parser::ast::Boolop::Or => Self::Or, + ast::Boolop::And => Self::And, + ast::Boolop::Or => Self::Or, } } } @@ -117,22 +117,22 @@ pub enum OperatorKind { pub(crate) type Operator = Attributed; -impl From<&rustpython_parser::ast::Operator> for OperatorKind { - fn from(op: &rustpython_parser::ast::Operator) -> Self { +impl From<&ast::Operator> for OperatorKind { + fn from(op: &ast::Operator) -> Self { match op { - rustpython_parser::ast::Operator::Add => Self::Add, - rustpython_parser::ast::Operator::Sub => Self::Sub, - rustpython_parser::ast::Operator::Mult => Self::Mult, - rustpython_parser::ast::Operator::MatMult => Self::MatMult, - rustpython_parser::ast::Operator::Div => Self::Div, - rustpython_parser::ast::Operator::Mod => Self::Mod, - rustpython_parser::ast::Operator::Pow => Self::Pow, - rustpython_parser::ast::Operator::LShift => Self::LShift, - rustpython_parser::ast::Operator::RShift => Self::RShift, - rustpython_parser::ast::Operator::BitOr => Self::BitOr, - rustpython_parser::ast::Operator::BitXor => Self::BitXor, - rustpython_parser::ast::Operator::BitAnd => Self::BitAnd, - rustpython_parser::ast::Operator::FloorDiv => Self::FloorDiv, + ast::Operator::Add => Self::Add, + ast::Operator::Sub => Self::Sub, + ast::Operator::Mult => Self::Mult, + ast::Operator::MatMult => Self::MatMult, + ast::Operator::Div => Self::Div, + ast::Operator::Mod => Self::Mod, + ast::Operator::Pow => Self::Pow, + ast::Operator::LShift => Self::LShift, + ast::Operator::RShift => Self::RShift, + ast::Operator::BitOr => Self::BitOr, + ast::Operator::BitXor => Self::BitXor, + ast::Operator::BitAnd => Self::BitAnd, + ast::Operator::FloorDiv => Self::FloorDiv, } } } @@ -147,13 +147,13 @@ pub enum UnaryOpKind { pub(crate) type UnaryOp = Attributed; -impl From<&rustpython_parser::ast::Unaryop> for UnaryOpKind { - fn from(op: &rustpython_parser::ast::Unaryop) -> Self { +impl From<&ast::Unaryop> for UnaryOpKind { + fn from(op: &ast::Unaryop) -> Self { match op { - rustpython_parser::ast::Unaryop::Invert => Self::Invert, - rustpython_parser::ast::Unaryop::Not => Self::Not, - rustpython_parser::ast::Unaryop::UAdd => Self::UAdd, - rustpython_parser::ast::Unaryop::USub => Self::USub, + ast::Unaryop::Invert => Self::Invert, + ast::Unaryop::Not => Self::Not, + ast::Unaryop::UAdd => Self::UAdd, + ast::Unaryop::USub => Self::USub, } } } @@ -174,27 +174,27 @@ pub enum CmpOpKind { pub(crate) type CmpOp = Attributed; -impl From<&rustpython_parser::ast::Cmpop> for CmpOpKind { - fn from(op: &rustpython_parser::ast::Cmpop) -> Self { +impl From<&ast::Cmpop> for CmpOpKind { + fn from(op: &ast::Cmpop) -> Self { match op { - rustpython_parser::ast::Cmpop::Eq => Self::Eq, - rustpython_parser::ast::Cmpop::NotEq => Self::NotEq, - rustpython_parser::ast::Cmpop::Lt => Self::Lt, - rustpython_parser::ast::Cmpop::LtE => Self::LtE, - rustpython_parser::ast::Cmpop::Gt => Self::Gt, - rustpython_parser::ast::Cmpop::GtE => Self::GtE, - rustpython_parser::ast::Cmpop::Is => Self::Is, - rustpython_parser::ast::Cmpop::IsNot => Self::IsNot, - rustpython_parser::ast::Cmpop::In => Self::In, - rustpython_parser::ast::Cmpop::NotIn => Self::NotIn, + ast::Cmpop::Eq => Self::Eq, + ast::Cmpop::NotEq => Self::NotEq, + ast::Cmpop::Lt => Self::Lt, + ast::Cmpop::LtE => Self::LtE, + ast::Cmpop::Gt => Self::Gt, + ast::Cmpop::GtE => Self::GtE, + ast::Cmpop::Is => Self::Is, + ast::Cmpop::IsNot => Self::IsNot, + ast::Cmpop::In => Self::In, + ast::Cmpop::NotIn => Self::NotIn, } } } pub(crate) type Body = Attributed>; -impl From<(Vec, &Locator<'_>)> for Body { - fn from((body, locator): (Vec, &Locator)) -> Self { +impl From<(Vec, &Locator<'_>)> for Body { + fn from((body, locator): (Vec, &Locator)) -> Self { Body { range: body.first().unwrap().range(), node: body @@ -570,16 +570,13 @@ pub enum PatternKind { pub(crate) type Pattern = Attributed; -impl From<(rustpython_parser::ast::Alias, &Locator<'_>)> for Alias { - fn from((alias, _locator): (rustpython_parser::ast::Alias, &Locator)) -> Self { +impl From<(ast::Alias, &Locator<'_>)> for Alias { + fn from((alias, _locator): (ast::Alias, &Locator)) -> Self { Alias { range: alias.range(), node: AliasData { name: alias.name.to_string(), - asname: alias - .asname - .as_ref() - .map(rustpython_parser::ast::Identifier::to_string), + asname: alias.asname.as_ref().map(ast::Identifier::to_string), }, trivia: vec![], parentheses: Parenthesize::Never, @@ -587,8 +584,8 @@ impl From<(rustpython_parser::ast::Alias, &Locator<'_>)> for Alias { } } -impl From<(rustpython_parser::ast::Withitem, &Locator<'_>)> for Withitem { - fn from((withitem, locator): (rustpython_parser::ast::Withitem, &Locator)) -> Self { +impl From<(ast::Withitem, &Locator<'_>)> for Withitem { + fn from((withitem, locator): (ast::Withitem, &Locator)) -> Self { Withitem { context_expr: (withitem.context_expr, locator).into(), optional_vars: withitem @@ -598,9 +595,9 @@ impl From<(rustpython_parser::ast::Withitem, &Locator<'_>)> for Withitem { } } -impl From<(rustpython_parser::ast::Excepthandler, &Locator<'_>)> for Excepthandler { - fn from((excepthandler, locator): (rustpython_parser::ast::Excepthandler, &Locator)) -> Self { - let rustpython_parser::ast::Excepthandler::ExceptHandler(ast::ExcepthandlerExceptHandler { +impl From<(ast::Excepthandler, &Locator<'_>)> for Excepthandler { + fn from((excepthandler, locator): (ast::Excepthandler, &Locator)) -> Self { + let ast::Excepthandler::ExceptHandler(ast::ExcepthandlerExceptHandler { type_, name, body, @@ -635,35 +632,33 @@ impl From<(rustpython_parser::ast::Excepthandler, &Locator<'_>)> for Excepthandl } } -impl From<(rustpython_parser::ast::Pattern, &Locator<'_>)> for Pattern { - fn from((pattern, locator): (rustpython_parser::ast::Pattern, &Locator)) -> Self { +impl From<(ast::Pattern, &Locator<'_>)> for Pattern { + fn from((pattern, locator): (ast::Pattern, &Locator)) -> Self { Pattern { range: pattern.range(), node: match pattern { - rustpython_parser::ast::Pattern::MatchValue( - rustpython_parser::ast::PatternMatchValue { value, range: _ }, - ) => PatternKind::MatchValue { - value: Box::new((*value, locator).into()), - }, - rustpython_parser::ast::Pattern::MatchSingleton( - rustpython_parser::ast::PatternMatchSingleton { value, range: _ }, - ) => PatternKind::MatchSingleton { value }, - rustpython_parser::ast::Pattern::MatchSequence( - rustpython_parser::ast::PatternMatchSequence { patterns, range: _ }, - ) => PatternKind::MatchSequence { - patterns: patterns - .into_iter() - .map(|pattern| (pattern, locator).into()) - .collect(), - }, - rustpython_parser::ast::Pattern::MatchMapping( - rustpython_parser::ast::PatternMatchMapping { - keys, - patterns, - rest, - range: _, - }, - ) => PatternKind::MatchMapping { + ast::Pattern::MatchValue(ast::PatternMatchValue { value, range: _ }) => { + PatternKind::MatchValue { + value: Box::new((*value, locator).into()), + } + } + ast::Pattern::MatchSingleton(ast::PatternMatchSingleton { value, range: _ }) => { + PatternKind::MatchSingleton { value } + } + ast::Pattern::MatchSequence(ast::PatternMatchSequence { patterns, range: _ }) => { + PatternKind::MatchSequence { + patterns: patterns + .into_iter() + .map(|pattern| (pattern, locator).into()) + .collect(), + } + } + ast::Pattern::MatchMapping(ast::PatternMatchMapping { + keys, + patterns, + rest, + range: _, + }) => PatternKind::MatchMapping { keys: keys.into_iter().map(|key| (key, locator).into()).collect(), patterns: patterns .into_iter() @@ -671,15 +666,13 @@ impl From<(rustpython_parser::ast::Pattern, &Locator<'_>)> for Pattern { .collect(), rest: rest.map(Into::into), }, - rustpython_parser::ast::Pattern::MatchClass( - rustpython_parser::ast::PatternMatchClass { - cls, - patterns, - kwd_attrs, - kwd_patterns, - range: _, - }, - ) => PatternKind::MatchClass { + ast::Pattern::MatchClass(ast::PatternMatchClass { + cls, + patterns, + kwd_attrs, + kwd_patterns, + range: _, + }) => PatternKind::MatchClass { cls: Box::new((*cls, locator).into()), patterns: patterns .into_iter() @@ -691,29 +684,27 @@ impl From<(rustpython_parser::ast::Pattern, &Locator<'_>)> for Pattern { .map(|pattern| (pattern, locator).into()) .collect(), }, - rustpython_parser::ast::Pattern::MatchStar( - rustpython_parser::ast::PatternMatchStar { name, range: _ }, - ) => PatternKind::MatchStar { - name: name.map(Into::into), - }, - rustpython_parser::ast::Pattern::MatchAs( - rustpython_parser::ast::PatternMatchAs { - pattern, - name, - range: _, - }, - ) => PatternKind::MatchAs { + ast::Pattern::MatchStar(ast::PatternMatchStar { name, range: _ }) => { + PatternKind::MatchStar { + name: name.map(Into::into), + } + } + ast::Pattern::MatchAs(ast::PatternMatchAs { + pattern, + name, + range: _, + }) => PatternKind::MatchAs { pattern: pattern.map(|pattern| Box::new((*pattern, locator).into())), name: name.map(Into::into), }, - rustpython_parser::ast::Pattern::MatchOr( - rustpython_parser::ast::PatternMatchOr { patterns, range: _ }, - ) => PatternKind::MatchOr { - patterns: patterns - .into_iter() - .map(|pattern| (pattern, locator).into()) - .collect(), - }, + ast::Pattern::MatchOr(ast::PatternMatchOr { patterns, range: _ }) => { + PatternKind::MatchOr { + patterns: patterns + .into_iter() + .map(|pattern| (pattern, locator).into()) + .collect(), + } + } }, trivia: vec![], parentheses: Parenthesize::Never, @@ -721,8 +712,8 @@ impl From<(rustpython_parser::ast::Pattern, &Locator<'_>)> for Pattern { } } -impl From<(rustpython_parser::ast::MatchCase, &Locator<'_>)> for MatchCase { - fn from((match_case, locator): (rustpython_parser::ast::MatchCase, &Locator)) -> Self { +impl From<(ast::MatchCase, &Locator<'_>)> for MatchCase { + fn from((match_case, locator): (ast::MatchCase, &Locator)) -> Self { // Find the start and end of the `body`. let body = { let body_range = expand_indented_block( @@ -752,10 +743,10 @@ impl From<(rustpython_parser::ast::MatchCase, &Locator<'_>)> for MatchCase { } } -impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { - fn from((stmt, locator): (rustpython_parser::ast::Stmt, &Locator)) -> Self { +impl From<(ast::Stmt, &Locator<'_>)> for Stmt { + fn from((stmt, locator): (ast::Stmt, &Locator)) -> Self { match stmt { - rustpython_parser::ast::Stmt::Expr(ast::StmtExpr { value, range }) => Stmt { + ast::Stmt::Expr(ast::StmtExpr { value, range }) => Stmt { range, node: StmtKind::Expr { value: Box::new((*value, locator).into()), @@ -763,13 +754,13 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Pass(ast::StmtPass { range }) => Stmt { + ast::Stmt::Pass(ast::StmtPass { range }) => Stmt { range, node: StmtKind::Pass, trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Return(ast::StmtReturn { value, range }) => Stmt { + ast::Stmt::Return(ast::StmtReturn { value, range }) => Stmt { range, node: StmtKind::Return { value: value.map(|v| (*v, locator).into()), @@ -777,7 +768,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Assign(ast::StmtAssign { + ast::Stmt::Assign(ast::StmtAssign { targets, value, type_comment, @@ -795,7 +786,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::ClassDef(ast::StmtClassDef { + ast::Stmt::ClassDef(ast::StmtClassDef { name, bases, keywords, @@ -840,7 +831,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::If(ast::StmtIf { + ast::Stmt::If(ast::StmtIf { test, body, orelse, @@ -928,7 +919,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { } } } - rustpython_parser::ast::Stmt::Assert(ast::StmtAssert { test, msg, range }) => Stmt { + ast::Stmt::Assert(ast::StmtAssert { test, msg, range }) => Stmt { range, node: StmtKind::Assert { test: Box::new((*test, locator).into()), @@ -937,7 +928,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::FunctionDef(ast::StmtFunctionDef { + ast::Stmt::FunctionDef(ast::StmtFunctionDef { name, args, body, @@ -983,7 +974,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { + ast::Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { name, args, body, @@ -1029,7 +1020,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::Delete(ast::StmtDelete { targets, range }) => Stmt { + ast::Stmt::Delete(ast::StmtDelete { targets, range }) => Stmt { range, node: StmtKind::Delete { targets: targets @@ -1040,7 +1031,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::AugAssign(ast::StmtAugAssign { + ast::Stmt::AugAssign(ast::StmtAugAssign { target, op, value, @@ -1050,45 +1041,19 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { node: StmtKind::AugAssign { op: { let target_tok = match &op { - rustpython_parser::ast::Operator::Add => { - rustpython_parser::Tok::PlusEqual - } - rustpython_parser::ast::Operator::Sub => { - rustpython_parser::Tok::MinusEqual - } - rustpython_parser::ast::Operator::Mult => { - rustpython_parser::Tok::StarEqual - } - rustpython_parser::ast::Operator::MatMult => { - rustpython_parser::Tok::AtEqual - } - rustpython_parser::ast::Operator::Div => { - rustpython_parser::Tok::SlashEqual - } - rustpython_parser::ast::Operator::Mod => { - rustpython_parser::Tok::PercentEqual - } - rustpython_parser::ast::Operator::Pow => { - rustpython_parser::Tok::DoubleStarEqual - } - rustpython_parser::ast::Operator::LShift => { - rustpython_parser::Tok::LeftShiftEqual - } - rustpython_parser::ast::Operator::RShift => { - rustpython_parser::Tok::RightShiftEqual - } - rustpython_parser::ast::Operator::BitOr => { - rustpython_parser::Tok::VbarEqual - } - rustpython_parser::ast::Operator::BitXor => { - rustpython_parser::Tok::CircumflexEqual - } - rustpython_parser::ast::Operator::BitAnd => { - rustpython_parser::Tok::AmperEqual - } - rustpython_parser::ast::Operator::FloorDiv => { - rustpython_parser::Tok::DoubleSlashEqual - } + ast::Operator::Add => rustpython_parser::Tok::PlusEqual, + ast::Operator::Sub => rustpython_parser::Tok::MinusEqual, + ast::Operator::Mult => rustpython_parser::Tok::StarEqual, + ast::Operator::MatMult => rustpython_parser::Tok::AtEqual, + ast::Operator::Div => rustpython_parser::Tok::SlashEqual, + ast::Operator::Mod => rustpython_parser::Tok::PercentEqual, + ast::Operator::Pow => rustpython_parser::Tok::DoubleStarEqual, + ast::Operator::LShift => rustpython_parser::Tok::LeftShiftEqual, + ast::Operator::RShift => rustpython_parser::Tok::RightShiftEqual, + ast::Operator::BitOr => rustpython_parser::Tok::VbarEqual, + ast::Operator::BitXor => rustpython_parser::Tok::CircumflexEqual, + ast::Operator::BitAnd => rustpython_parser::Tok::AmperEqual, + ast::Operator::FloorDiv => rustpython_parser::Tok::DoubleSlashEqual, }; let op_range = find_tok(TextRange::new(target.end(), value.end()), locator, |tok| { @@ -1102,7 +1067,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::AnnAssign(ast::StmtAnnAssign { + ast::Stmt::AnnAssign(ast::StmtAnnAssign { target, annotation, value, @@ -1119,7 +1084,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::For(ast::StmtFor { + ast::Stmt::For(ast::StmtFor { target, iter, body, @@ -1170,7 +1135,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::AsyncFor(ast::StmtAsyncFor { + ast::Stmt::AsyncFor(ast::StmtAsyncFor { target, iter, body, @@ -1221,7 +1186,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::While(ast::StmtWhile { + ast::Stmt::While(ast::StmtWhile { test, body, orelse, @@ -1268,7 +1233,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::With(ast::StmtWith { + ast::Stmt::With(ast::StmtWith { items, body, type_comment, @@ -1303,7 +1268,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::AsyncWith(ast::StmtAsyncWith { + ast::Stmt::AsyncWith(ast::StmtAsyncWith { items, body, type_comment, @@ -1338,7 +1303,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::Match(ast::StmtMatch { + ast::Stmt::Match(ast::StmtMatch { subject, cases, range, @@ -1354,7 +1319,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Raise(ast::StmtRaise { exc, cause, range }) => Stmt { + ast::Stmt::Raise(ast::StmtRaise { exc, cause, range }) => Stmt { range, node: StmtKind::Raise { exc: exc.map(|exc| Box::new((*exc, locator).into())), @@ -1363,7 +1328,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Try(ast::StmtTry { + ast::Stmt::Try(ast::StmtTry { body, handlers, orelse, @@ -1449,7 +1414,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::TryStar(ast::StmtTryStar { + ast::Stmt::TryStar(ast::StmtTryStar { body, handlers, orelse, @@ -1535,7 +1500,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { parentheses: Parenthesize::Never, } } - rustpython_parser::ast::Stmt::Import(ast::StmtImport { names, range }) => Stmt { + ast::Stmt::Import(ast::StmtImport { names, range }) => Stmt { range, node: StmtKind::Import { names: names @@ -1546,7 +1511,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::ImportFrom(ast::StmtImportFrom { + ast::Stmt::ImportFrom(ast::StmtImportFrom { module, names, level, @@ -1564,7 +1529,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Global(ast::StmtGlobal { names, range }) => Stmt { + ast::Stmt::Global(ast::StmtGlobal { names, range }) => Stmt { range, node: StmtKind::Global { names: names.into_iter().map(Into::into).collect(), @@ -1572,7 +1537,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Nonlocal(ast::StmtNonlocal { names, range }) => Stmt { + ast::Stmt::Nonlocal(ast::StmtNonlocal { names, range }) => Stmt { range, node: StmtKind::Nonlocal { names: names.into_iter().map(Into::into).collect(), @@ -1580,13 +1545,13 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Break(ast::StmtBreak { range }) => Stmt { + ast::Stmt::Break(ast::StmtBreak { range }) => Stmt { range, node: StmtKind::Break, trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Stmt::Continue(ast::StmtContinue { range }) => Stmt { + ast::Stmt::Continue(ast::StmtContinue { range }) => Stmt { range, node: StmtKind::Continue, trivia: vec![], @@ -1596,8 +1561,8 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt { } } -impl From<(rustpython_parser::ast::Keyword, &Locator<'_>)> for Keyword { - fn from((keyword, locator): (rustpython_parser::ast::Keyword, &Locator)) -> Self { +impl From<(ast::Keyword, &Locator<'_>)> for Keyword { + fn from((keyword, locator): (ast::Keyword, &Locator)) -> Self { Keyword { range: keyword.range(), node: KeywordData { @@ -1610,8 +1575,8 @@ impl From<(rustpython_parser::ast::Keyword, &Locator<'_>)> for Keyword { } } -impl From<(rustpython_parser::ast::Arg, &Locator<'_>)> for Arg { - fn from((arg, locator): (rustpython_parser::ast::Arg, &Locator)) -> Self { +impl From<(ast::Arg, &Locator<'_>)> for Arg { + fn from((arg, locator): (ast::Arg, &Locator)) -> Self { Arg { range: arg.range(), node: ArgData { @@ -1625,8 +1590,8 @@ impl From<(rustpython_parser::ast::Arg, &Locator<'_>)> for Arg { } } -impl From<(rustpython_parser::ast::Arguments, &Locator<'_>)> for Arguments { - fn from((arguments, locator): (rustpython_parser::ast::Arguments, &Locator)) -> Self { +impl From<(ast::Arguments, &Locator<'_>)> for Arguments { + fn from((arguments, locator): (ast::Arguments, &Locator)) -> Self { Arguments { posonlyargs: arguments .posonlyargs @@ -1663,8 +1628,8 @@ impl From<(rustpython_parser::ast::Arguments, &Locator<'_>)> for Arguments { } } -impl From<(rustpython_parser::ast::Comprehension, &Locator<'_>)> for Comprehension { - fn from((comprehension, locator): (rustpython_parser::ast::Comprehension, &Locator)) -> Self { +impl From<(ast::Comprehension, &Locator<'_>)> for Comprehension { + fn from((comprehension, locator): (ast::Comprehension, &Locator)) -> Self { Comprehension { target: (comprehension.target, locator).into(), iter: (comprehension.iter, locator).into(), @@ -1678,10 +1643,10 @@ impl From<(rustpython_parser::ast::Comprehension, &Locator<'_>)> for Comprehensi } } -impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { - fn from((expr, locator): (rustpython_parser::ast::Expr, &Locator)) -> Self { +impl From<(ast::Expr, &Locator<'_>)> for Expr { + fn from((expr, locator): (ast::Expr, &Locator)) -> Self { match expr { - rustpython_parser::ast::Expr::Name(ast::ExprName { id, ctx, range }) => Expr { + ast::Expr::Name(ast::ExprName { id, ctx, range }) => Expr { range, node: ExprKind::Name { id: id.into(), @@ -1690,7 +1655,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::BoolOp(ast::ExprBoolOp { op, values, range }) => Expr { + ast::Expr::BoolOp(ast::ExprBoolOp { op, values, range }) => Expr { range, node: ExprKind::BoolOp { ops: values @@ -1698,8 +1663,8 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { .tuple_windows() .map(|(left, right)| { let target_tok = match &op { - rustpython_parser::ast::Boolop::And => rustpython_parser::Tok::And, - rustpython_parser::ast::Boolop::Or => rustpython_parser::Tok::Or, + ast::Boolop::And => rustpython_parser::Tok::And, + ast::Boolop::Or => rustpython_parser::Tok::Or, }; let op_range = find_tok( TextRange::new(left.end(), right.start()), @@ -1717,7 +1682,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::NamedExpr(ast::ExprNamedExpr { + ast::Expr::NamedExpr(ast::ExprNamedExpr { target, value, range, @@ -1730,7 +1695,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::BinOp(ast::ExprBinOp { + ast::Expr::BinOp(ast::ExprBinOp { left, op, right, @@ -1740,33 +1705,19 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { node: ExprKind::BinOp { op: { let target_tok = match &op { - rustpython_parser::ast::Operator::Add => rustpython_parser::Tok::Plus, - rustpython_parser::ast::Operator::Sub => rustpython_parser::Tok::Minus, - rustpython_parser::ast::Operator::Mult => rustpython_parser::Tok::Star, - rustpython_parser::ast::Operator::MatMult => rustpython_parser::Tok::At, - rustpython_parser::ast::Operator::Div => rustpython_parser::Tok::Slash, - rustpython_parser::ast::Operator::Mod => { - rustpython_parser::Tok::Percent - } - rustpython_parser::ast::Operator::Pow => { - rustpython_parser::Tok::DoubleStar - } - rustpython_parser::ast::Operator::LShift => { - rustpython_parser::Tok::LeftShift - } - rustpython_parser::ast::Operator::RShift => { - rustpython_parser::Tok::RightShift - } - rustpython_parser::ast::Operator::BitOr => rustpython_parser::Tok::Vbar, - rustpython_parser::ast::Operator::BitXor => { - rustpython_parser::Tok::CircumFlex - } - rustpython_parser::ast::Operator::BitAnd => { - rustpython_parser::Tok::Amper - } - rustpython_parser::ast::Operator::FloorDiv => { - rustpython_parser::Tok::DoubleSlash - } + ast::Operator::Add => rustpython_parser::Tok::Plus, + ast::Operator::Sub => rustpython_parser::Tok::Minus, + ast::Operator::Mult => rustpython_parser::Tok::Star, + ast::Operator::MatMult => rustpython_parser::Tok::At, + ast::Operator::Div => rustpython_parser::Tok::Slash, + ast::Operator::Mod => rustpython_parser::Tok::Percent, + ast::Operator::Pow => rustpython_parser::Tok::DoubleStar, + ast::Operator::LShift => rustpython_parser::Tok::LeftShift, + ast::Operator::RShift => rustpython_parser::Tok::RightShift, + ast::Operator::BitOr => rustpython_parser::Tok::Vbar, + ast::Operator::BitXor => rustpython_parser::Tok::CircumFlex, + ast::Operator::BitAnd => rustpython_parser::Tok::Amper, + ast::Operator::FloorDiv => rustpython_parser::Tok::DoubleSlash, }; let op_range = find_tok(TextRange::new(left.end(), right.start()), locator, |tok| { @@ -1780,37 +1731,29 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::UnaryOp(ast::ExprUnaryOp { op, operand, range }) => { - Expr { - range, - node: ExprKind::UnaryOp { - op: { - let target_tok = match &op { - rustpython_parser::ast::Unaryop::Invert => { - rustpython_parser::Tok::Tilde - } - rustpython_parser::ast::Unaryop::Not => rustpython_parser::Tok::Not, - rustpython_parser::ast::Unaryop::UAdd => { - rustpython_parser::Tok::Plus - } - rustpython_parser::ast::Unaryop::USub => { - rustpython_parser::Tok::Minus - } - }; - let op_range = find_tok( - TextRange::new(range.start(), operand.start()), - locator, - |tok| tok == target_tok, - ); - UnaryOp::new(op_range, (&op).into()) - }, - operand: Box::new((*operand, locator).into()), + ast::Expr::UnaryOp(ast::ExprUnaryOp { op, operand, range }) => Expr { + range, + node: ExprKind::UnaryOp { + op: { + let target_tok = match &op { + ast::Unaryop::Invert => rustpython_parser::Tok::Tilde, + ast::Unaryop::Not => rustpython_parser::Tok::Not, + ast::Unaryop::UAdd => rustpython_parser::Tok::Plus, + ast::Unaryop::USub => rustpython_parser::Tok::Minus, + }; + let op_range = find_tok( + TextRange::new(range.start(), operand.start()), + locator, + |tok| tok == target_tok, + ); + UnaryOp::new(op_range, (&op).into()) }, - trivia: vec![], - parentheses: Parenthesize::Never, - } - } - rustpython_parser::ast::Expr::Lambda(ast::ExprLambda { args, body, range }) => Expr { + operand: Box::new((*operand, locator).into()), + }, + trivia: vec![], + parentheses: Parenthesize::Never, + }, + ast::Expr::Lambda(ast::ExprLambda { args, body, range }) => Expr { range, node: ExprKind::Lambda { args: Box::new((*args, locator).into()), @@ -1819,7 +1762,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::IfExp(ast::ExprIfExp { + ast::Expr::IfExp(ast::ExprIfExp { test, body, orelse, @@ -1834,7 +1777,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Dict(ast::ExprDict { + ast::Expr::Dict(ast::ExprDict { keys, values, range, @@ -1853,7 +1796,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Set(ast::ExprSet { elts, range }) => Expr { + ast::Expr::Set(ast::ExprSet { elts, range }) => Expr { range, node: ExprKind::Set { elts: elts @@ -1864,7 +1807,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::ListComp(ast::ExprListComp { + ast::Expr::ListComp(ast::ExprListComp { elt, generators, range, @@ -1880,7 +1823,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::SetComp(ast::ExprSetComp { + ast::Expr::SetComp(ast::ExprSetComp { elt, generators, range, @@ -1896,7 +1839,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::DictComp(ast::ExprDictComp { + ast::Expr::DictComp(ast::ExprDictComp { key, value, generators, @@ -1914,7 +1857,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::GeneratorExp(ast::ExprGeneratorExp { + ast::Expr::GeneratorExp(ast::ExprGeneratorExp { elt, generators, range, @@ -1930,7 +1873,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Await(ast::ExprAwait { value, range }) => Expr { + ast::Expr::Await(ast::ExprAwait { value, range }) => Expr { range, node: ExprKind::Await { value: Box::new((*value, locator).into()), @@ -1938,7 +1881,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Yield(ast::ExprYield { value, range }) => Expr { + ast::Expr::Yield(ast::ExprYield { value, range }) => Expr { range, node: ExprKind::Yield { value: value.map(|v| Box::new((*v, locator).into())), @@ -1946,7 +1889,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::YieldFrom(ast::ExprYieldFrom { value, range }) => Expr { + ast::Expr::YieldFrom(ast::ExprYieldFrom { value, range }) => Expr { range, node: ExprKind::YieldFrom { value: Box::new((*value, locator).into()), @@ -1954,7 +1897,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Compare(ast::ExprCompare { + ast::Expr::Compare(ast::ExprCompare { left, ops, comparators, @@ -1968,28 +1911,18 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { .zip(ops.into_iter()) .map(|((left, right), op)| { let target_tok = match &op { - rustpython_parser::ast::Cmpop::Eq => { - rustpython_parser::Tok::EqEqual - } - rustpython_parser::ast::Cmpop::NotEq => { - rustpython_parser::Tok::NotEqual - } - rustpython_parser::ast::Cmpop::Lt => rustpython_parser::Tok::Less, - rustpython_parser::ast::Cmpop::LtE => { - rustpython_parser::Tok::LessEqual - } - rustpython_parser::ast::Cmpop::Gt => { - rustpython_parser::Tok::Greater - } - rustpython_parser::ast::Cmpop::GtE => { - rustpython_parser::Tok::GreaterEqual - } - rustpython_parser::ast::Cmpop::Is => rustpython_parser::Tok::Is, + ast::Cmpop::Eq => rustpython_parser::Tok::EqEqual, + ast::Cmpop::NotEq => rustpython_parser::Tok::NotEqual, + ast::Cmpop::Lt => rustpython_parser::Tok::Less, + ast::Cmpop::LtE => rustpython_parser::Tok::LessEqual, + ast::Cmpop::Gt => rustpython_parser::Tok::Greater, + ast::Cmpop::GtE => rustpython_parser::Tok::GreaterEqual, + ast::Cmpop::Is => rustpython_parser::Tok::Is, // TODO(charlie): Break this into two tokens. - rustpython_parser::ast::Cmpop::IsNot => rustpython_parser::Tok::Is, - rustpython_parser::ast::Cmpop::In => rustpython_parser::Tok::In, + ast::Cmpop::IsNot => rustpython_parser::Tok::Is, + ast::Cmpop::In => rustpython_parser::Tok::In, // TODO(charlie): Break this into two tokens. - rustpython_parser::ast::Cmpop::NotIn => rustpython_parser::Tok::In, + ast::Cmpop::NotIn => rustpython_parser::Tok::In, }; let op_range = find_tok( TextRange::new(left.end(), right.start()), @@ -2008,7 +1941,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Call(ast::ExprCall { + ast::Expr::Call(ast::ExprCall { func, args, keywords, @@ -2029,7 +1962,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::FormattedValue(ast::ExprFormattedValue { + ast::Expr::FormattedValue(ast::ExprFormattedValue { value, conversion, format_spec, @@ -2044,7 +1977,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::JoinedStr(ast::ExprJoinedStr { values, range }) => Expr { + ast::Expr::JoinedStr(ast::ExprJoinedStr { values, range }) => Expr { range, node: ExprKind::JoinedStr { values: values @@ -2055,15 +1988,13 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Constant(ast::ExprConstant { value, kind, range }) => { - Expr { - range, - node: ExprKind::Constant { value, kind }, - trivia: vec![], - parentheses: Parenthesize::Never, - } - } - rustpython_parser::ast::Expr::Attribute(ast::ExprAttribute { + ast::Expr::Constant(ast::ExprConstant { value, kind, range }) => Expr { + range, + node: ExprKind::Constant { value, kind }, + trivia: vec![], + parentheses: Parenthesize::Never, + }, + ast::Expr::Attribute(ast::ExprAttribute { value, attr, ctx, @@ -2078,7 +2009,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Subscript(ast::ExprSubscript { + ast::Expr::Subscript(ast::ExprSubscript { value, slice, ctx, @@ -2093,7 +2024,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Starred(ast::ExprStarred { value, ctx, range }) => Expr { + ast::Expr::Starred(ast::ExprStarred { value, ctx, range }) => Expr { range, node: ExprKind::Starred { value: Box::new((*value, locator).into()), @@ -2102,7 +2033,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::List(ast::ExprList { elts, ctx, range }) => Expr { + ast::Expr::List(ast::ExprList { elts, ctx, range }) => Expr { range, node: ExprKind::List { elts: elts @@ -2114,7 +2045,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Tuple(ast::ExprTuple { elts, ctx, range }) => Expr { + ast::Expr::Tuple(ast::ExprTuple { elts, ctx, range }) => Expr { range, node: ExprKind::Tuple { elts: elts @@ -2126,7 +2057,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr { trivia: vec![], parentheses: Parenthesize::Never, }, - rustpython_parser::ast::Expr::Slice(ast::ExprSlice { + ast::Expr::Slice(ast::ExprSlice { lower, upper, step,