mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-07-23 04:55:09 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Remove unnecessary path prefixes (#4492)

Browse source
This commit is contained in:
Charlie Marsh 2023-05-18 10:19:09 -04:00 • committed by GitHub
parent a8d080c825
commit e8e66f3824
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 252 additions and 324 deletions
Download patch file Download diff file Expand all files Collapse all files

5
crates/ruff/src/autofix/actions.rs
View file

@ -268,10 +268,7 @@ pub(crate) fn remove_unused_imports<'a>(
let module = module.map(compose_module_path); let module = module.map(compose_module_path);
let member = compose_module_path(&alias.name); let member = compose_module_path(&alias.name);
let mut full_name = String::with_capacity( let mut full_name = String::with_capacity(
relative.len() relative.len() + module.as_ref().map_or(0, String::len) + member.len() + 1,
+ module.as_ref().map_or(0, std::string::String::len)
+ member.len()
+ 1,
); );
for _ in 0..relative.len() { for _ in 0..relative.len() {
full_name.push('.'); full_name.push('.');

2
crates/ruff/src/checkers/ast/mod.rs
View file

@ -4096,7 +4096,7 @@ where
fn visit_excepthandler(&mut self, excepthandler: &'b Excepthandler) { fn visit_excepthandler(&mut self, excepthandler: &'b Excepthandler) {
match excepthandler { match excepthandler {
ast::Excepthandler::ExceptHandler(ast::ExcepthandlerExceptHandler { Excepthandler::ExceptHandler(ast::ExcepthandlerExceptHandler {
type_, type_,
name, name,
body, body,

4
crates/ruff/src/logging.rs
View file

@ -200,11 +200,11 @@ struct TruncateAtNewline<'a>(&'a dyn Display);
impl Display for TruncateAtNewline<'_> { impl Display for TruncateAtNewline<'_> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
struct TruncateAdapter<'a> { struct TruncateAdapter<'a> {
inner: &'a mut dyn std::fmt::Write, inner: &'a mut dyn Write,
after_new_line: bool, after_new_line: bool,
} }
impl std::fmt::Write for TruncateAdapter<'_> { impl Write for TruncateAdapter<'_> {
fn write_str(&mut self, s: &str) -> std::fmt::Result { fn write_str(&mut self, s: &str) -> std::fmt::Result {
if self.after_new_line { if self.after_new_line {
Ok(()) Ok(())

2
crates/ruff/src/message/text.rs
View file

@ -118,7 +118,7 @@ pub(super) struct RuleCodeAndBody<'a> {
} }
impl Display for RuleCodeAndBody<'_> { 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; let kind = &self.message.kind;
if self.show_fix_status && self.message.fix.is_some() { if self.show_fix_status && self.message.fix.is_some() {

4
crates/ruff/src/rules/pyflakes/rules/strings.rs
View file

@ -269,7 +269,7 @@ pub(crate) fn percent_format_extra_named_arguments(
let Expr::Dict(ast::ExprDict { keys, .. }) = &right else { let Expr::Dict(ast::ExprDict { keys, .. }) = &right else {
return; return;
}; };
if keys.iter().any(std::option::Option::is_none) { if keys.iter().any(Option::is_none) {
return; // contains **x splat return; // contains **x splat
} }
@ -326,7 +326,7 @@ pub(crate) fn percent_format_missing_arguments(
} }
if let Expr::Dict(ast::ExprDict { keys, .. }) = &right { 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 return; // contains **x splat
} }

8
crates/ruff/src/rules/pylint/rules/binary_op_exception.rs
View file

@ -11,11 +11,11 @@ enum Boolop {
Or, Or,
} }
impl From<&rustpython_parser::ast::Boolop> for Boolop { impl From<&ast::Boolop> for Boolop {
fn from(op: &rustpython_parser::ast::Boolop) -> Self { fn from(op: &ast::Boolop) -> Self {
match op { match op {
rustpython_parser::ast::Boolop::And => Boolop::And, ast::Boolop::And => Boolop::And,
rustpython_parser::ast::Boolop::Or => Boolop::Or, ast::Boolop::Or => Boolop::Or,
} }
} }
} }

2
crates/ruff/src/rules/pyupgrade/rules/deprecated_import.rs
View file

@ -527,7 +527,7 @@ pub(crate) fn deprecated_import(
return; return;
} }
let members: Vec<Alias> = names.iter().map(std::clone::Clone::clone).collect(); let members: Vec<Alias> = names.iter().map(Clone::clone).collect();
let fixer = ImportReplacer::new( let fixer = ImportReplacer::new(
stmt, stmt,
module, module,

2
crates/ruff_cache/src/cache_key.rs
View file

@ -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`]. /// * 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 /// * Ideally, cache keys are portable
/// ///
/// [`Hash`](std::hash::Hash) /// [`Hash`](Hash)
pub trait CacheKey { pub trait CacheKey {
fn cache_key(&self, state: &mut CacheKeyHasher); fn cache_key(&self, state: &mut CacheKeyHasher);

2
crates/ruff_macros/src/derive_message_formats.rs
View file

@ -3,7 +3,7 @@ use quote::{quote, quote_spanned, ToTokens};
use syn::spanned::Spanned; use syn::spanned::Spanned;
use syn::{Block, Expr, ItemFn, Stmt}; 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!(); let mut strings = quote!();
if let Err(err) = parse_block(&func.block, &mut strings) { if let Err(err) = parse_block(&func.block, &mut strings) {

2
crates/ruff_macros/src/lib.rs
View file

@ -24,7 +24,7 @@ pub fn derive_config(input: TokenStream) -> TokenStream {
} }
#[proc_macro_derive(CombineOptions)] #[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); let input = parse_macro_input!(input as DeriveInput);
combine_options::derive_impl(input) combine_options::derive_impl(input)

6
crates/ruff_python_ast/src/comparable.rs
View file

@ -915,7 +915,7 @@ impl<'a> From<&'a Stmt> for ComparableStmt<'a> {
body: body.iter().map(Into::into).collect(), body: body.iter().map(Into::into).collect(),
decorator_list: decorator_list.iter().map(Into::into).collect(), decorator_list: decorator_list.iter().map(Into::into).collect(),
returns: returns.as_ref().map(Into::into), 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 { Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
name, name,
@ -931,7 +931,7 @@ impl<'a> From<&'a Stmt> for ComparableStmt<'a> {
body: body.iter().map(Into::into).collect(), body: body.iter().map(Into::into).collect(),
decorator_list: decorator_list.iter().map(Into::into).collect(), decorator_list: decorator_list.iter().map(Into::into).collect(),
returns: returns.as_ref().map(Into::into), 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 { Stmt::ClassDef(ast::StmtClassDef {
name, name,
@ -967,7 +967,7 @@ impl<'a> From<&'a Stmt> for ComparableStmt<'a> {
}) => Self::Assign { }) => Self::Assign {
targets: targets.iter().map(Into::into).collect(), targets: targets.iter().map(Into::into).collect(),
value: value.into(), 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 { Stmt::AugAssign(ast::StmtAugAssign {
target, target,

4
crates/ruff_python_ast/src/source_code/line_index.rs
View file

@ -295,8 +295,8 @@ impl OneIndexed {
} }
} }
impl std::fmt::Display for OneIndexed { impl fmt::Display for OneIndexed {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
std::fmt::Debug::fmt(&self.0.get(), f) std::fmt::Debug::fmt(&self.0.get(), f)
} }
} }

533
crates/ruff_python_formatter/src/cst/mod.rs
View file

@ -71,12 +71,12 @@ pub enum ExprContext {
Del, Del,
} }
impl From<rustpython_parser::ast::ExprContext> for ExprContext { impl From<ast::ExprContext> for ExprContext {
fn from(context: rustpython_parser::ast::ExprContext) -> Self { fn from(context: ast::ExprContext) -> Self {
match context { match context {
rustpython_parser::ast::ExprContext::Load => Self::Load, ast::ExprContext::Load => Self::Load,
rustpython_parser::ast::ExprContext::Store => Self::Store, ast::ExprContext::Store => Self::Store,
rustpython_parser::ast::ExprContext::Del => Self::Del, ast::ExprContext::Del => Self::Del,
} }
} }
} }
@ -87,11 +87,11 @@ pub enum BoolOpKind {
Or, Or,
} }
impl From<&rustpython_parser::ast::Boolop> for BoolOpKind { impl From<&ast::Boolop> for BoolOpKind {
fn from(op: &rustpython_parser::ast::Boolop) -> Self { fn from(op: &ast::Boolop) -> Self {
match op { match op {
rustpython_parser::ast::Boolop::And => Self::And, ast::Boolop::And => Self::And,
rustpython_parser::ast::Boolop::Or => Self::Or, ast::Boolop::Or => Self::Or,
} }
} }
} }
@ -117,22 +117,22 @@ pub enum OperatorKind {
pub(crate) type Operator = Attributed<OperatorKind>; pub(crate) type Operator = Attributed<OperatorKind>;
impl From<&rustpython_parser::ast::Operator> for OperatorKind { impl From<&ast::Operator> for OperatorKind {
fn from(op: &rustpython_parser::ast::Operator) -> Self { fn from(op: &ast::Operator) -> Self {
match op { match op {
rustpython_parser::ast::Operator::Add => Self::Add, ast::Operator::Add => Self::Add,
rustpython_parser::ast::Operator::Sub => Self::Sub, ast::Operator::Sub => Self::Sub,
rustpython_parser::ast::Operator::Mult => Self::Mult, ast::Operator::Mult => Self::Mult,
rustpython_parser::ast::Operator::MatMult => Self::MatMult, ast::Operator::MatMult => Self::MatMult,
rustpython_parser::ast::Operator::Div => Self::Div, ast::Operator::Div => Self::Div,
rustpython_parser::ast::Operator::Mod => Self::Mod, ast::Operator::Mod => Self::Mod,
rustpython_parser::ast::Operator::Pow => Self::Pow, ast::Operator::Pow => Self::Pow,
rustpython_parser::ast::Operator::LShift => Self::LShift, ast::Operator::LShift => Self::LShift,
rustpython_parser::ast::Operator::RShift => Self::RShift, ast::Operator::RShift => Self::RShift,
rustpython_parser::ast::Operator::BitOr => Self::BitOr, ast::Operator::BitOr => Self::BitOr,
rustpython_parser::ast::Operator::BitXor => Self::BitXor, ast::Operator::BitXor => Self::BitXor,
rustpython_parser::ast::Operator::BitAnd => Self::BitAnd, ast::Operator::BitAnd => Self::BitAnd,
rustpython_parser::ast::Operator::FloorDiv => Self::FloorDiv, ast::Operator::FloorDiv => Self::FloorDiv,
} }
} }
} }
@ -147,13 +147,13 @@ pub enum UnaryOpKind {
pub(crate) type UnaryOp = Attributed<UnaryOpKind>; pub(crate) type UnaryOp = Attributed<UnaryOpKind>;
impl From<&rustpython_parser::ast::Unaryop> for UnaryOpKind { impl From<&ast::Unaryop> for UnaryOpKind {
fn from(op: &rustpython_parser::ast::Unaryop) -> Self { fn from(op: &ast::Unaryop) -> Self {
match op { match op {
rustpython_parser::ast::Unaryop::Invert => Self::Invert, ast::Unaryop::Invert => Self::Invert,
rustpython_parser::ast::Unaryop::Not => Self::Not, ast::Unaryop::Not => Self::Not,
rustpython_parser::ast::Unaryop::UAdd => Self::UAdd, ast::Unaryop::UAdd => Self::UAdd,
rustpython_parser::ast::Unaryop::USub => Self::USub, ast::Unaryop::USub => Self::USub,
} }
} }
} }
@ -174,27 +174,27 @@ pub enum CmpOpKind {
pub(crate) type CmpOp = Attributed<CmpOpKind>; pub(crate) type CmpOp = Attributed<CmpOpKind>;
impl From<&rustpython_parser::ast::Cmpop> for CmpOpKind { impl From<&ast::Cmpop> for CmpOpKind {
fn from(op: &rustpython_parser::ast::Cmpop) -> Self { fn from(op: &ast::Cmpop) -> Self {
match op { match op {
rustpython_parser::ast::Cmpop::Eq => Self::Eq, ast::Cmpop::Eq => Self::Eq,
rustpython_parser::ast::Cmpop::NotEq => Self::NotEq, ast::Cmpop::NotEq => Self::NotEq,
rustpython_parser::ast::Cmpop::Lt => Self::Lt, ast::Cmpop::Lt => Self::Lt,
rustpython_parser::ast::Cmpop::LtE => Self::LtE, ast::Cmpop::LtE => Self::LtE,
rustpython_parser::ast::Cmpop::Gt => Self::Gt, ast::Cmpop::Gt => Self::Gt,
rustpython_parser::ast::Cmpop::GtE => Self::GtE, ast::Cmpop::GtE => Self::GtE,
rustpython_parser::ast::Cmpop::Is => Self::Is, ast::Cmpop::Is => Self::Is,
rustpython_parser::ast::Cmpop::IsNot => Self::IsNot, ast::Cmpop::IsNot => Self::IsNot,
rustpython_parser::ast::Cmpop::In => Self::In, ast::Cmpop::In => Self::In,
rustpython_parser::ast::Cmpop::NotIn => Self::NotIn, ast::Cmpop::NotIn => Self::NotIn,
} }
} }
} }
pub(crate) type Body = Attributed<Vec<Stmt>>; pub(crate) type Body = Attributed<Vec<Stmt>>;
impl From<(Vec<rustpython_parser::ast::Stmt>, &Locator<'_>)> for Body { impl From<(Vec<ast::Stmt>, &Locator<'_>)> for Body {
fn from((body, locator): (Vec<rustpython_parser::ast::Stmt>, &Locator)) -> Self { fn from((body, locator): (Vec<ast::Stmt>, &Locator)) -> Self {
Body { Body {
range: body.first().unwrap().range(), range: body.first().unwrap().range(),
node: body node: body
@ -570,16 +570,13 @@ pub enum PatternKind {
pub(crate) type Pattern = Attributed<PatternKind>; pub(crate) type Pattern = Attributed<PatternKind>;
impl From<(rustpython_parser::ast::Alias, &Locator<'_>)> for Alias { impl From<(ast::Alias, &Locator<'_>)> for Alias {
fn from((alias, _locator): (rustpython_parser::ast::Alias, &Locator)) -> Self { fn from((alias, _locator): (ast::Alias, &Locator)) -> Self {
Alias { Alias {
range: alias.range(), range: alias.range(),
node: AliasData { node: AliasData {
name: alias.name.to_string(), name: alias.name.to_string(),
asname: alias asname: alias.asname.as_ref().map(ast::Identifier::to_string),
.asname
.as_ref()
.map(rustpython_parser::ast::Identifier::to_string),
}, },
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, 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 { impl From<(ast::Withitem, &Locator<'_>)> for Withitem {
fn from((withitem, locator): (rustpython_parser::ast::Withitem, &Locator)) -> Self { fn from((withitem, locator): (ast::Withitem, &Locator)) -> Self {
Withitem { Withitem {
context_expr: (withitem.context_expr, locator).into(), context_expr: (withitem.context_expr, locator).into(),
optional_vars: withitem 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 { impl From<(ast::Excepthandler, &Locator<'_>)> for Excepthandler {
fn from((excepthandler, locator): (rustpython_parser::ast::Excepthandler, &Locator)) -> Self { fn from((excepthandler, locator): (ast::Excepthandler, &Locator)) -> Self {
let rustpython_parser::ast::Excepthandler::ExceptHandler(ast::ExcepthandlerExceptHandler { let ast::Excepthandler::ExceptHandler(ast::ExcepthandlerExceptHandler {
type_, type_,
name, name,
body, body,
@ -635,35 +632,33 @@ impl From<(rustpython_parser::ast::Excepthandler, &Locator<'_>)> for Excepthandl
} }
} }
impl From<(rustpython_parser::ast::Pattern, &Locator<'_>)> for Pattern { impl From<(ast::Pattern, &Locator<'_>)> for Pattern {
fn from((pattern, locator): (rustpython_parser::ast::Pattern, &Locator)) -> Self { fn from((pattern, locator): (ast::Pattern, &Locator)) -> Self {
Pattern { Pattern {
range: pattern.range(), range: pattern.range(),
node: match pattern { node: match pattern {
rustpython_parser::ast::Pattern::MatchValue( ast::Pattern::MatchValue(ast::PatternMatchValue { value, range: _ }) => {
rustpython_parser::ast::PatternMatchValue { value, range: _ }, PatternKind::MatchValue {
) => PatternKind::MatchValue { value: Box::new((*value, locator).into()),
value: Box::new((*value, locator).into()), }
}, }
rustpython_parser::ast::Pattern::MatchSingleton( ast::Pattern::MatchSingleton(ast::PatternMatchSingleton { value, range: _ }) => {
rustpython_parser::ast::PatternMatchSingleton { value, range: _ }, PatternKind::MatchSingleton { value }
) => PatternKind::MatchSingleton { value }, }
rustpython_parser::ast::Pattern::MatchSequence( ast::Pattern::MatchSequence(ast::PatternMatchSequence { patterns, range: _ }) => {
rustpython_parser::ast::PatternMatchSequence { patterns, range: _ }, PatternKind::MatchSequence {
) => PatternKind::MatchSequence { patterns: patterns
patterns: patterns .into_iter()
.into_iter() .map(|pattern| (pattern, locator).into())
.map(|pattern| (pattern, locator).into()) .collect(),
.collect(), }
}, }
rustpython_parser::ast::Pattern::MatchMapping( ast::Pattern::MatchMapping(ast::PatternMatchMapping {
rustpython_parser::ast::PatternMatchMapping { keys,
keys, patterns,
patterns, rest,
rest, range: _,
range: _, }) => PatternKind::MatchMapping {
},
) => PatternKind::MatchMapping {
keys: keys.into_iter().map(|key| (key, locator).into()).collect(), keys: keys.into_iter().map(|key| (key, locator).into()).collect(),
patterns: patterns patterns: patterns
.into_iter() .into_iter()
@ -671,15 +666,13 @@ impl From<(rustpython_parser::ast::Pattern, &Locator<'_>)> for Pattern {
.collect(), .collect(),
rest: rest.map(Into::into), rest: rest.map(Into::into),
}, },
rustpython_parser::ast::Pattern::MatchClass( ast::Pattern::MatchClass(ast::PatternMatchClass {
rustpython_parser::ast::PatternMatchClass { cls,
cls, patterns,
patterns, kwd_attrs,
kwd_attrs, kwd_patterns,
kwd_patterns, range: _,
range: _, }) => PatternKind::MatchClass {
},
) => PatternKind::MatchClass {
cls: Box::new((*cls, locator).into()), cls: Box::new((*cls, locator).into()),
patterns: patterns patterns: patterns
.into_iter() .into_iter()
@ -691,29 +684,27 @@ impl From<(rustpython_parser::ast::Pattern, &Locator<'_>)> for Pattern {
.map(|pattern| (pattern, locator).into()) .map(|pattern| (pattern, locator).into())
.collect(), .collect(),
}, },
rustpython_parser::ast::Pattern::MatchStar( ast::Pattern::MatchStar(ast::PatternMatchStar { name, range: _ }) => {
rustpython_parser::ast::PatternMatchStar { name, range: _ }, PatternKind::MatchStar {
) => PatternKind::MatchStar { name: name.map(Into::into),
name: name.map(Into::into), }
}, }
rustpython_parser::ast::Pattern::MatchAs( ast::Pattern::MatchAs(ast::PatternMatchAs {
rustpython_parser::ast::PatternMatchAs { pattern,
pattern, name,
name, range: _,
range: _, }) => PatternKind::MatchAs {
},
) => PatternKind::MatchAs {
pattern: pattern.map(|pattern| Box::new((*pattern, locator).into())), pattern: pattern.map(|pattern| Box::new((*pattern, locator).into())),
name: name.map(Into::into), name: name.map(Into::into),
}, },
rustpython_parser::ast::Pattern::MatchOr( ast::Pattern::MatchOr(ast::PatternMatchOr { patterns, range: _ }) => {
rustpython_parser::ast::PatternMatchOr { patterns, range: _ }, PatternKind::MatchOr {
) => PatternKind::MatchOr { patterns: patterns
patterns: patterns .into_iter()
.into_iter() .map(|pattern| (pattern, locator).into())
.map(|pattern| (pattern, locator).into()) .collect(),
.collect(), }
}, }
}, },
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, 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 { impl From<(ast::MatchCase, &Locator<'_>)> for MatchCase {
fn from((match_case, locator): (rustpython_parser::ast::MatchCase, &Locator)) -> Self { fn from((match_case, locator): (ast::MatchCase, &Locator)) -> Self {
// Find the start and end of the `body`. // Find the start and end of the `body`.
let body = { let body = {
let body_range = expand_indented_block( 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 { impl From<(ast::Stmt, &Locator<'_>)> for Stmt {
fn from((stmt, locator): (rustpython_parser::ast::Stmt, &Locator)) -> Self { fn from((stmt, locator): (ast::Stmt, &Locator)) -> Self {
match stmt { match stmt {
rustpython_parser::ast::Stmt::Expr(ast::StmtExpr { value, range }) => Stmt { ast::Stmt::Expr(ast::StmtExpr { value, range }) => Stmt {
range, range,
node: StmtKind::Expr { node: StmtKind::Expr {
value: Box::new((*value, locator).into()), value: Box::new((*value, locator).into()),
@ -763,13 +754,13 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Pass(ast::StmtPass { range }) => Stmt { ast::Stmt::Pass(ast::StmtPass { range }) => Stmt {
range, range,
node: StmtKind::Pass, node: StmtKind::Pass,
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Return(ast::StmtReturn { value, range }) => Stmt { ast::Stmt::Return(ast::StmtReturn { value, range }) => Stmt {
range, range,
node: StmtKind::Return { node: StmtKind::Return {
value: value.map(|v| (*v, locator).into()), value: value.map(|v| (*v, locator).into()),
@ -777,7 +768,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Assign(ast::StmtAssign { ast::Stmt::Assign(ast::StmtAssign {
targets, targets,
value, value,
type_comment, type_comment,
@ -795,7 +786,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::ClassDef(ast::StmtClassDef { ast::Stmt::ClassDef(ast::StmtClassDef {
name, name,
bases, bases,
keywords, keywords,
@ -840,7 +831,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::If(ast::StmtIf { ast::Stmt::If(ast::StmtIf {
test, test,
body, body,
orelse, 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, range,
node: StmtKind::Assert { node: StmtKind::Assert {
test: Box::new((*test, locator).into()), test: Box::new((*test, locator).into()),
@ -937,7 +928,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::FunctionDef(ast::StmtFunctionDef { ast::Stmt::FunctionDef(ast::StmtFunctionDef {
name, name,
args, args,
body, body,
@ -983,7 +974,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { ast::Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
name, name,
args, args,
body, body,
@ -1029,7 +1020,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::Delete(ast::StmtDelete { targets, range }) => Stmt { ast::Stmt::Delete(ast::StmtDelete { targets, range }) => Stmt {
range, range,
node: StmtKind::Delete { node: StmtKind::Delete {
targets: targets targets: targets
@ -1040,7 +1031,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::AugAssign(ast::StmtAugAssign { ast::Stmt::AugAssign(ast::StmtAugAssign {
target, target,
op, op,
value, value,
@ -1050,45 +1041,19 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
node: StmtKind::AugAssign { node: StmtKind::AugAssign {
op: { op: {
let target_tok = match &op { let target_tok = match &op {
rustpython_parser::ast::Operator::Add => { ast::Operator::Add => rustpython_parser::Tok::PlusEqual,
rustpython_parser::Tok::PlusEqual ast::Operator::Sub => rustpython_parser::Tok::MinusEqual,
} ast::Operator::Mult => rustpython_parser::Tok::StarEqual,
rustpython_parser::ast::Operator::Sub => { ast::Operator::MatMult => rustpython_parser::Tok::AtEqual,
rustpython_parser::Tok::MinusEqual ast::Operator::Div => rustpython_parser::Tok::SlashEqual,
} ast::Operator::Mod => rustpython_parser::Tok::PercentEqual,
rustpython_parser::ast::Operator::Mult => { ast::Operator::Pow => rustpython_parser::Tok::DoubleStarEqual,
rustpython_parser::Tok::StarEqual ast::Operator::LShift => rustpython_parser::Tok::LeftShiftEqual,
} ast::Operator::RShift => rustpython_parser::Tok::RightShiftEqual,
rustpython_parser::ast::Operator::MatMult => { ast::Operator::BitOr => rustpython_parser::Tok::VbarEqual,
rustpython_parser::Tok::AtEqual ast::Operator::BitXor => rustpython_parser::Tok::CircumflexEqual,
} ast::Operator::BitAnd => rustpython_parser::Tok::AmperEqual,
rustpython_parser::ast::Operator::Div => { ast::Operator::FloorDiv => rustpython_parser::Tok::DoubleSlashEqual,
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
}
}; };
let op_range = let op_range =
find_tok(TextRange::new(target.end(), value.end()), locator, |tok| { 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![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::AnnAssign(ast::StmtAnnAssign { ast::Stmt::AnnAssign(ast::StmtAnnAssign {
target, target,
annotation, annotation,
value, value,
@ -1119,7 +1084,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::For(ast::StmtFor { ast::Stmt::For(ast::StmtFor {
target, target,
iter, iter,
body, body,
@ -1170,7 +1135,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::AsyncFor(ast::StmtAsyncFor { ast::Stmt::AsyncFor(ast::StmtAsyncFor {
target, target,
iter, iter,
body, body,
@ -1221,7 +1186,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::While(ast::StmtWhile { ast::Stmt::While(ast::StmtWhile {
test, test,
body, body,
orelse, orelse,
@ -1268,7 +1233,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::With(ast::StmtWith { ast::Stmt::With(ast::StmtWith {
items, items,
body, body,
type_comment, type_comment,
@ -1303,7 +1268,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::AsyncWith(ast::StmtAsyncWith { ast::Stmt::AsyncWith(ast::StmtAsyncWith {
items, items,
body, body,
type_comment, type_comment,
@ -1338,7 +1303,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::Match(ast::StmtMatch { ast::Stmt::Match(ast::StmtMatch {
subject, subject,
cases, cases,
range, range,
@ -1354,7 +1319,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Raise(ast::StmtRaise { exc, cause, range }) => Stmt { ast::Stmt::Raise(ast::StmtRaise { exc, cause, range }) => Stmt {
range, range,
node: StmtKind::Raise { node: StmtKind::Raise {
exc: exc.map(|exc| Box::new((*exc, locator).into())), exc: exc.map(|exc| Box::new((*exc, locator).into())),
@ -1363,7 +1328,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Try(ast::StmtTry { ast::Stmt::Try(ast::StmtTry {
body, body,
handlers, handlers,
orelse, orelse,
@ -1449,7 +1414,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::TryStar(ast::StmtTryStar { ast::Stmt::TryStar(ast::StmtTryStar {
body, body,
handlers, handlers,
orelse, orelse,
@ -1535,7 +1500,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
} }
} }
rustpython_parser::ast::Stmt::Import(ast::StmtImport { names, range }) => Stmt { ast::Stmt::Import(ast::StmtImport { names, range }) => Stmt {
range, range,
node: StmtKind::Import { node: StmtKind::Import {
names: names names: names
@ -1546,7 +1511,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::ImportFrom(ast::StmtImportFrom { ast::Stmt::ImportFrom(ast::StmtImportFrom {
module, module,
names, names,
level, level,
@ -1564,7 +1529,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Global(ast::StmtGlobal { names, range }) => Stmt { ast::Stmt::Global(ast::StmtGlobal { names, range }) => Stmt {
range, range,
node: StmtKind::Global { node: StmtKind::Global {
names: names.into_iter().map(Into::into).collect(), names: names.into_iter().map(Into::into).collect(),
@ -1572,7 +1537,7 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Nonlocal(ast::StmtNonlocal { names, range }) => Stmt { ast::Stmt::Nonlocal(ast::StmtNonlocal { names, range }) => Stmt {
range, range,
node: StmtKind::Nonlocal { node: StmtKind::Nonlocal {
names: names.into_iter().map(Into::into).collect(), names: names.into_iter().map(Into::into).collect(),
@ -1580,13 +1545,13 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Break(ast::StmtBreak { range }) => Stmt { ast::Stmt::Break(ast::StmtBreak { range }) => Stmt {
range, range,
node: StmtKind::Break, node: StmtKind::Break,
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Stmt::Continue(ast::StmtContinue { range }) => Stmt { ast::Stmt::Continue(ast::StmtContinue { range }) => Stmt {
range, range,
node: StmtKind::Continue, node: StmtKind::Continue,
trivia: vec![], trivia: vec![],
@ -1596,8 +1561,8 @@ impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
} }
} }
impl From<(rustpython_parser::ast::Keyword, &Locator<'_>)> for Keyword { impl From<(ast::Keyword, &Locator<'_>)> for Keyword {
fn from((keyword, locator): (rustpython_parser::ast::Keyword, &Locator)) -> Self { fn from((keyword, locator): (ast::Keyword, &Locator)) -> Self {
Keyword { Keyword {
range: keyword.range(), range: keyword.range(),
node: KeywordData { node: KeywordData {
@ -1610,8 +1575,8 @@ impl From<(rustpython_parser::ast::Keyword, &Locator<'_>)> for Keyword {
} }
} }
impl From<(rustpython_parser::ast::Arg, &Locator<'_>)> for Arg { impl From<(ast::Arg, &Locator<'_>)> for Arg {
fn from((arg, locator): (rustpython_parser::ast::Arg, &Locator)) -> Self { fn from((arg, locator): (ast::Arg, &Locator)) -> Self {
Arg { Arg {
range: arg.range(), range: arg.range(),
node: ArgData { node: ArgData {
@ -1625,8 +1590,8 @@ impl From<(rustpython_parser::ast::Arg, &Locator<'_>)> for Arg {
} }
} }
impl From<(rustpython_parser::ast::Arguments, &Locator<'_>)> for Arguments { impl From<(ast::Arguments, &Locator<'_>)> for Arguments {
fn from((arguments, locator): (rustpython_parser::ast::Arguments, &Locator)) -> Self { fn from((arguments, locator): (ast::Arguments, &Locator)) -> Self {
Arguments { Arguments {
posonlyargs: arguments posonlyargs: arguments
.posonlyargs .posonlyargs
@ -1663,8 +1628,8 @@ impl From<(rustpython_parser::ast::Arguments, &Locator<'_>)> for Arguments {
} }
} }
impl From<(rustpython_parser::ast::Comprehension, &Locator<'_>)> for Comprehension { impl From<(ast::Comprehension, &Locator<'_>)> for Comprehension {
fn from((comprehension, locator): (rustpython_parser::ast::Comprehension, &Locator)) -> Self { fn from((comprehension, locator): (ast::Comprehension, &Locator)) -> Self {
Comprehension { Comprehension {
target: (comprehension.target, locator).into(), target: (comprehension.target, locator).into(),
iter: (comprehension.iter, 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 { impl From<(ast::Expr, &Locator<'_>)> for Expr {
fn from((expr, locator): (rustpython_parser::ast::Expr, &Locator)) -> Self { fn from((expr, locator): (ast::Expr, &Locator)) -> Self {
match expr { match expr {
rustpython_parser::ast::Expr::Name(ast::ExprName { id, ctx, range }) => Expr { ast::Expr::Name(ast::ExprName { id, ctx, range }) => Expr {
range, range,
node: ExprKind::Name { node: ExprKind::Name {
id: id.into(), id: id.into(),
@ -1690,7 +1655,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::BoolOp(ast::ExprBoolOp { op, values, range }) => Expr { ast::Expr::BoolOp(ast::ExprBoolOp { op, values, range }) => Expr {
range, range,
node: ExprKind::BoolOp { node: ExprKind::BoolOp {
ops: values ops: values
@ -1698,8 +1663,8 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
.tuple_windows() .tuple_windows()
.map(|(left, right)| { .map(|(left, right)| {
let target_tok = match &op { let target_tok = match &op {
rustpython_parser::ast::Boolop::And => rustpython_parser::Tok::And, ast::Boolop::And => rustpython_parser::Tok::And,
rustpython_parser::ast::Boolop::Or => rustpython_parser::Tok::Or, ast::Boolop::Or => rustpython_parser::Tok::Or,
}; };
let op_range = find_tok( let op_range = find_tok(
TextRange::new(left.end(), right.start()), TextRange::new(left.end(), right.start()),
@ -1717,7 +1682,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::NamedExpr(ast::ExprNamedExpr { ast::Expr::NamedExpr(ast::ExprNamedExpr {
target, target,
value, value,
range, range,
@ -1730,7 +1695,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::BinOp(ast::ExprBinOp { ast::Expr::BinOp(ast::ExprBinOp {
left, left,
op, op,
right, right,
@ -1740,33 +1705,19 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
node: ExprKind::BinOp { node: ExprKind::BinOp {
op: { op: {
let target_tok = match &op { let target_tok = match &op {
rustpython_parser::ast::Operator::Add => rustpython_parser::Tok::Plus, ast::Operator::Add => rustpython_parser::Tok::Plus,
rustpython_parser::ast::Operator::Sub => rustpython_parser::Tok::Minus, ast::Operator::Sub => rustpython_parser::Tok::Minus,
rustpython_parser::ast::Operator::Mult => rustpython_parser::Tok::Star, ast::Operator::Mult => rustpython_parser::Tok::Star,
rustpython_parser::ast::Operator::MatMult => rustpython_parser::Tok::At, ast::Operator::MatMult => rustpython_parser::Tok::At,
rustpython_parser::ast::Operator::Div => rustpython_parser::Tok::Slash, ast::Operator::Div => rustpython_parser::Tok::Slash,
rustpython_parser::ast::Operator::Mod => { ast::Operator::Mod => rustpython_parser::Tok::Percent,
rustpython_parser::Tok::Percent ast::Operator::Pow => rustpython_parser::Tok::DoubleStar,
} ast::Operator::LShift => rustpython_parser::Tok::LeftShift,
rustpython_parser::ast::Operator::Pow => { ast::Operator::RShift => rustpython_parser::Tok::RightShift,
rustpython_parser::Tok::DoubleStar ast::Operator::BitOr => rustpython_parser::Tok::Vbar,
} ast::Operator::BitXor => rustpython_parser::Tok::CircumFlex,
rustpython_parser::ast::Operator::LShift => { ast::Operator::BitAnd => rustpython_parser::Tok::Amper,
rustpython_parser::Tok::LeftShift ast::Operator::FloorDiv => rustpython_parser::Tok::DoubleSlash,
}
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
}
}; };
let op_range = let op_range =
find_tok(TextRange::new(left.end(), right.start()), locator, |tok| { 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![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::UnaryOp(ast::ExprUnaryOp { op, operand, range }) => { ast::Expr::UnaryOp(ast::ExprUnaryOp { op, operand, range }) => Expr {
Expr { range,
range, node: ExprKind::UnaryOp {
node: ExprKind::UnaryOp { op: {
op: { let target_tok = match &op {
let target_tok = match &op { ast::Unaryop::Invert => rustpython_parser::Tok::Tilde,
rustpython_parser::ast::Unaryop::Invert => { ast::Unaryop::Not => rustpython_parser::Tok::Not,
rustpython_parser::Tok::Tilde ast::Unaryop::UAdd => rustpython_parser::Tok::Plus,
} ast::Unaryop::USub => rustpython_parser::Tok::Minus,
rustpython_parser::ast::Unaryop::Not => rustpython_parser::Tok::Not, };
rustpython_parser::ast::Unaryop::UAdd => { let op_range = find_tok(
rustpython_parser::Tok::Plus TextRange::new(range.start(), operand.start()),
} locator,
rustpython_parser::ast::Unaryop::USub => { |tok| tok == target_tok,
rustpython_parser::Tok::Minus );
} UnaryOp::new(op_range, (&op).into())
};
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()),
}, },
trivia: vec![], operand: Box::new((*operand, locator).into()),
parentheses: Parenthesize::Never, },
} trivia: vec![],
} parentheses: Parenthesize::Never,
rustpython_parser::ast::Expr::Lambda(ast::ExprLambda { args, body, range }) => Expr { },
ast::Expr::Lambda(ast::ExprLambda { args, body, range }) => Expr {
range, range,
node: ExprKind::Lambda { node: ExprKind::Lambda {
args: Box::new((*args, locator).into()), args: Box::new((*args, locator).into()),
@ -1819,7 +1762,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::IfExp(ast::ExprIfExp { ast::Expr::IfExp(ast::ExprIfExp {
test, test,
body, body,
orelse, orelse,
@ -1834,7 +1777,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Dict(ast::ExprDict { ast::Expr::Dict(ast::ExprDict {
keys, keys,
values, values,
range, range,
@ -1853,7 +1796,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Set(ast::ExprSet { elts, range }) => Expr { ast::Expr::Set(ast::ExprSet { elts, range }) => Expr {
range, range,
node: ExprKind::Set { node: ExprKind::Set {
elts: elts elts: elts
@ -1864,7 +1807,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::ListComp(ast::ExprListComp { ast::Expr::ListComp(ast::ExprListComp {
elt, elt,
generators, generators,
range, range,
@ -1880,7 +1823,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::SetComp(ast::ExprSetComp { ast::Expr::SetComp(ast::ExprSetComp {
elt, elt,
generators, generators,
range, range,
@ -1896,7 +1839,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::DictComp(ast::ExprDictComp { ast::Expr::DictComp(ast::ExprDictComp {
key, key,
value, value,
generators, generators,
@ -1914,7 +1857,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::GeneratorExp(ast::ExprGeneratorExp { ast::Expr::GeneratorExp(ast::ExprGeneratorExp {
elt, elt,
generators, generators,
range, range,
@ -1930,7 +1873,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Await(ast::ExprAwait { value, range }) => Expr { ast::Expr::Await(ast::ExprAwait { value, range }) => Expr {
range, range,
node: ExprKind::Await { node: ExprKind::Await {
value: Box::new((*value, locator).into()), value: Box::new((*value, locator).into()),
@ -1938,7 +1881,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Yield(ast::ExprYield { value, range }) => Expr { ast::Expr::Yield(ast::ExprYield { value, range }) => Expr {
range, range,
node: ExprKind::Yield { node: ExprKind::Yield {
value: value.map(|v| Box::new((*v, locator).into())), value: value.map(|v| Box::new((*v, locator).into())),
@ -1946,7 +1889,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::YieldFrom(ast::ExprYieldFrom { value, range }) => Expr { ast::Expr::YieldFrom(ast::ExprYieldFrom { value, range }) => Expr {
range, range,
node: ExprKind::YieldFrom { node: ExprKind::YieldFrom {
value: Box::new((*value, locator).into()), value: Box::new((*value, locator).into()),
@ -1954,7 +1897,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Compare(ast::ExprCompare { ast::Expr::Compare(ast::ExprCompare {
left, left,
ops, ops,
comparators, comparators,
@ -1968,28 +1911,18 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
.zip(ops.into_iter()) .zip(ops.into_iter())
.map(|((left, right), op)| { .map(|((left, right), op)| {
let target_tok = match &op { let target_tok = match &op {
rustpython_parser::ast::Cmpop::Eq => { ast::Cmpop::Eq => rustpython_parser::Tok::EqEqual,
rustpython_parser::Tok::EqEqual ast::Cmpop::NotEq => rustpython_parser::Tok::NotEqual,
} ast::Cmpop::Lt => rustpython_parser::Tok::Less,
rustpython_parser::ast::Cmpop::NotEq => { ast::Cmpop::LtE => rustpython_parser::Tok::LessEqual,
rustpython_parser::Tok::NotEqual ast::Cmpop::Gt => rustpython_parser::Tok::Greater,
} ast::Cmpop::GtE => rustpython_parser::Tok::GreaterEqual,
rustpython_parser::ast::Cmpop::Lt => rustpython_parser::Tok::Less, ast::Cmpop::Is => rustpython_parser::Tok::Is,
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,
// TODO(charlie): Break this into two tokens. // TODO(charlie): Break this into two tokens.
rustpython_parser::ast::Cmpop::IsNot => rustpython_parser::Tok::Is, ast::Cmpop::IsNot => rustpython_parser::Tok::Is,
rustpython_parser::ast::Cmpop::In => rustpython_parser::Tok::In, ast::Cmpop::In => rustpython_parser::Tok::In,
// TODO(charlie): Break this into two tokens. // 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( let op_range = find_tok(
TextRange::new(left.end(), right.start()), TextRange::new(left.end(), right.start()),
@ -2008,7 +1941,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Call(ast::ExprCall { ast::Expr::Call(ast::ExprCall {
func, func,
args, args,
keywords, keywords,
@ -2029,7 +1962,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::FormattedValue(ast::ExprFormattedValue { ast::Expr::FormattedValue(ast::ExprFormattedValue {
value, value,
conversion, conversion,
format_spec, format_spec,
@ -2044,7 +1977,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::JoinedStr(ast::ExprJoinedStr { values, range }) => Expr { ast::Expr::JoinedStr(ast::ExprJoinedStr { values, range }) => Expr {
range, range,
node: ExprKind::JoinedStr { node: ExprKind::JoinedStr {
values: values values: values
@ -2055,15 +1988,13 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Constant(ast::ExprConstant { value, kind, range }) => { ast::Expr::Constant(ast::ExprConstant { value, kind, range }) => Expr {
Expr { range,
range, node: ExprKind::Constant { value, kind },
node: ExprKind::Constant { value, kind }, trivia: vec![],
trivia: vec![], parentheses: Parenthesize::Never,
parentheses: Parenthesize::Never, },
} ast::Expr::Attribute(ast::ExprAttribute {
}
rustpython_parser::ast::Expr::Attribute(ast::ExprAttribute {
value, value,
attr, attr,
ctx, ctx,
@ -2078,7 +2009,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Subscript(ast::ExprSubscript { ast::Expr::Subscript(ast::ExprSubscript {
value, value,
slice, slice,
ctx, ctx,
@ -2093,7 +2024,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Starred(ast::ExprStarred { value, ctx, range }) => Expr { ast::Expr::Starred(ast::ExprStarred { value, ctx, range }) => Expr {
range, range,
node: ExprKind::Starred { node: ExprKind::Starred {
value: Box::new((*value, locator).into()), value: Box::new((*value, locator).into()),
@ -2102,7 +2033,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::List(ast::ExprList { elts, ctx, range }) => Expr { ast::Expr::List(ast::ExprList { elts, ctx, range }) => Expr {
range, range,
node: ExprKind::List { node: ExprKind::List {
elts: elts elts: elts
@ -2114,7 +2045,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Tuple(ast::ExprTuple { elts, ctx, range }) => Expr { ast::Expr::Tuple(ast::ExprTuple { elts, ctx, range }) => Expr {
range, range,
node: ExprKind::Tuple { node: ExprKind::Tuple {
elts: elts elts: elts
@ -2126,7 +2057,7 @@ impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
trivia: vec![], trivia: vec![],
parentheses: Parenthesize::Never, parentheses: Parenthesize::Never,
}, },
rustpython_parser::ast::Expr::Slice(ast::ExprSlice { ast::Expr::Slice(ast::ExprSlice {
lower, lower,
upper, upper,
step, step,