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

Make Locator available in AST-to-CST conversion pass (#3194)

Browse source
This commit is contained in:
Charlie Marsh 2023-02-23 19:43:03 -05:00 • committed by GitHub
parent 198b301baf
commit eb15371453
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 316 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

437
crates/ruff_python_formatter/src/cst.rs
View file

@ -2,6 +2,7 @@
use rustpython_parser::ast::{Constant, Location};
use crate::core::locator::Locator;
use crate::trivia::{Parenthesize, Trivia};
type Ident = String;
@ -506,8 +507,8 @@ pub enum PatternKind {
pub type Pattern = Located<PatternKind>;
impl From<rustpython_parser::ast::Alias> for Alias {
fn from(alias: rustpython_parser::ast::Alias) -> Self {
impl From<(rustpython_parser::ast::Alias, &Locator<'_>)> for Alias {
fn from((alias, _locator): (rustpython_parser::ast::Alias, &Locator)) -> Self {
Alias {
location: alias.location,
end_location: alias.end_location,
@ -521,26 +522,31 @@ impl From<rustpython_parser::ast::Alias> for Alias {
}
}
impl From<rustpython_parser::ast::Withitem> for Withitem {
fn from(withitem: rustpython_parser::ast::Withitem) -> Self {
impl From<(rustpython_parser::ast::Withitem, &Locator<'_>)> for Withitem {
fn from((withitem, locator): (rustpython_parser::ast::Withitem, &Locator)) -> Self {
Withitem {
context_expr: withitem.context_expr.into(),
optional_vars: withitem.optional_vars.map(|v| Box::new((*v).into())),
context_expr: (withitem.context_expr, locator).into(),
optional_vars: withitem
.optional_vars
.map(|v| Box::new((*v, locator).into())),
}
}
}
impl From<rustpython_parser::ast::Excepthandler> for Excepthandler {
fn from(excepthandler: rustpython_parser::ast::Excepthandler) -> Self {
impl From<(rustpython_parser::ast::Excepthandler, &Locator<'_>)> for Excepthandler {
fn from((excepthandler, locator): (rustpython_parser::ast::Excepthandler, &Locator)) -> Self {
let rustpython_parser::ast::ExcepthandlerKind::ExceptHandler { type_, name, body } =
excepthandler.node;
Excepthandler {
location: excepthandler.location,
end_location: excepthandler.end_location,
node: ExcepthandlerKind::ExceptHandler {
type_: type_.map(|type_| Box::new((*type_).into())),
type_: type_.map(|type_| Box::new((*type_, locator).into())),
name,
body: body.into_iter().map(Into::into).collect(),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -548,14 +554,14 @@ impl From<rustpython_parser::ast::Excepthandler> for Excepthandler {
}
}
impl From<rustpython_parser::ast::Stmt> for Stmt {
fn from(stmt: rustpython_parser::ast::Stmt) -> Self {
impl From<(rustpython_parser::ast::Stmt, &Locator<'_>)> for Stmt {
fn from((stmt, locator): (rustpython_parser::ast::Stmt, &Locator)) -> Self {
match stmt.node {
rustpython_parser::ast::StmtKind::Expr { value } => Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::Expr {
value: Box::new((*value).into()),
value: Box::new((*value, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -571,7 +577,7 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::Return {
value: value.map(|v| (*v).into()),
value: value.map(|v| (*v, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -584,8 +590,11 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::Assign {
targets: targets.into_iter().map(Into::into).collect(),
value: Box::new((*value).into()),
targets: targets
.into_iter()
.map(|node| (node, locator).into())
.collect(),
value: Box::new((*value, locator).into()),
type_comment,
},
trivia: vec![],
@ -602,10 +611,22 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
end_location: stmt.end_location,
node: StmtKind::ClassDef {
name,
bases: bases.into_iter().map(Into::into).collect(),
keywords: keywords.into_iter().map(Into::into).collect(),
body: body.into_iter().map(Into::into).collect(),
decorator_list: decorator_list.into_iter().map(Into::into).collect(),
bases: bases
.into_iter()
.map(|node| (node, locator).into())
.collect(),
keywords: keywords
.into_iter()
.map(|node| (node, locator).into())
.collect(),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
decorator_list: decorator_list
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -624,10 +645,16 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
end_location: stmt.end_location,
node: StmtKind::FunctionDef {
name,
args: Box::new((*args).into()),
body: body.into_iter().map(Into::into).collect(),
decorator_list: decorator_list.into_iter().map(Into::into).collect(),
returns: returns.map(|r| Box::new((*r).into())),
args: Box::new((*args, locator).into()),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
decorator_list: decorator_list
.into_iter()
.map(|node| (node, locator).into())
.collect(),
returns: returns.map(|r| Box::new((*r, locator).into())),
type_comment,
},
trivia: vec![],
@ -637,9 +664,15 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::If {
test: Box::new((*test).into()),
body: body.into_iter().map(Into::into).collect(),
orelse: orelse.into_iter().map(Into::into).collect(),
test: Box::new((*test, locator).into()),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
orelse: orelse
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -648,8 +681,8 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::Assert {
test: Box::new((*test).into()),
msg: msg.map(|msg| Box::new((*msg).into())),
test: Box::new((*test, locator).into()),
msg: msg.map(|node| Box::new((*node, locator).into())),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -666,10 +699,16 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
end_location: stmt.end_location,
node: StmtKind::AsyncFunctionDef {
name,
args: Box::new((*args).into()),
body: body.into_iter().map(Into::into).collect(),
decorator_list: decorator_list.into_iter().map(Into::into).collect(),
returns: returns.map(|r| Box::new((*r).into())),
args: Box::new((*args, locator).into()),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
decorator_list: decorator_list
.into_iter()
.map(|node| (node, locator).into())
.collect(),
returns: returns.map(|r| Box::new((*r, locator).into())),
type_comment,
},
trivia: vec![],
@ -679,7 +718,10 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::Delete {
targets: targets.into_iter().map(Into::into).collect(),
targets: targets
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -688,9 +730,9 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::AugAssign {
target: Box::new((*target).into()),
target: Box::new((*target, locator).into()),
op: op.into(),
value: Box::new((*value).into()),
value: Box::new((*value, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -704,9 +746,9 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::AnnAssign {
target: Box::new((*target).into()),
annotation: Box::new((*annotation).into()),
value: value.map(|v| Box::new((*v).into())),
target: Box::new((*target, locator).into()),
annotation: Box::new((*annotation, locator).into()),
value: value.map(|node| Box::new((*node, locator).into())),
simple,
},
trivia: vec![],
@ -722,10 +764,16 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::For {
target: Box::new((*target).into()),
iter: Box::new((*iter).into()),
body: body.into_iter().map(Into::into).collect(),
orelse: orelse.into_iter().map(Into::into).collect(),
target: Box::new((*target, locator).into()),
iter: Box::new((*iter, locator).into()),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
orelse: orelse
.into_iter()
.map(|node| (node, locator).into())
.collect(),
type_comment,
},
trivia: vec![],
@ -741,10 +789,16 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::AsyncFor {
target: Box::new((*target).into()),
iter: Box::new((*iter).into()),
body: body.into_iter().map(Into::into).collect(),
orelse: orelse.into_iter().map(Into::into).collect(),
target: Box::new((*target, locator).into()),
iter: Box::new((*iter, locator).into()),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
orelse: orelse
.into_iter()
.map(|node| (node, locator).into())
.collect(),
type_comment,
},
trivia: vec![],
@ -754,9 +808,15 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::While {
test: Box::new((*test).into()),
body: body.into_iter().map(Into::into).collect(),
orelse: orelse.into_iter().map(Into::into).collect(),
test: Box::new((*test, locator).into()),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
orelse: orelse
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -769,8 +829,14 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::With {
items: items.into_iter().map(Into::into).collect(),
body: body.into_iter().map(Into::into).collect(),
items: items
.into_iter()
.map(|node| (node, locator).into())
.collect(),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
type_comment,
},
trivia: vec![],
@ -784,8 +850,14 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::AsyncWith {
items: items.into_iter().map(Into::into).collect(),
body: body.into_iter().map(Into::into).collect(),
items: items
.into_iter()
.map(|node| (node, locator).into())
.collect(),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
type_comment,
},
trivia: vec![],
@ -798,8 +870,8 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::Raise {
exc: exc.map(|exc| Box::new((*exc).into())),
cause: cause.map(|cause| Box::new((*cause).into())),
exc: exc.map(|exc| Box::new((*exc, locator).into())),
cause: cause.map(|cause| Box::new((*cause, locator).into())),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -813,10 +885,22 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::Try {
body: body.into_iter().map(Into::into).collect(),
handlers: handlers.into_iter().map(Into::into).collect(),
orelse: orelse.into_iter().map(Into::into).collect(),
finalbody: finalbody.into_iter().map(Into::into).collect(),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
handlers: handlers
.into_iter()
.map(|node| (node, locator).into())
.collect(),
orelse: orelse
.into_iter()
.map(|node| (node, locator).into())
.collect(),
finalbody: finalbody
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -830,10 +914,22 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::TryStar {
body: body.into_iter().map(Into::into).collect(),
handlers: handlers.into_iter().map(Into::into).collect(),
orelse: orelse.into_iter().map(Into::into).collect(),
finalbody: finalbody.into_iter().map(Into::into).collect(),
body: body
.into_iter()
.map(|node| (node, locator).into())
.collect(),
handlers: handlers
.into_iter()
.map(|node| (node, locator).into())
.collect(),
orelse: orelse
.into_iter()
.map(|node| (node, locator).into())
.collect(),
finalbody: finalbody
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -842,7 +938,10 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
location: stmt.location,
end_location: stmt.end_location,
node: StmtKind::Import {
names: names.into_iter().map(Into::into).collect(),
names: names
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -856,7 +955,10 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
end_location: stmt.end_location,
node: StmtKind::ImportFrom {
module,
names: names.into_iter().map(Into::into).collect(),
names: names
.into_iter()
.map(|node| (node, locator).into())
.collect(),
level,
},
trivia: vec![],
@ -894,14 +996,14 @@ impl From<rustpython_parser::ast::Stmt> for Stmt {
}
}
impl From<rustpython_parser::ast::Keyword> for Keyword {
fn from(keyword: rustpython_parser::ast::Keyword) -> Self {
impl From<(rustpython_parser::ast::Keyword, &Locator<'_>)> for Keyword {
fn from((keyword, locator): (rustpython_parser::ast::Keyword, &Locator)) -> Self {
Keyword {
location: keyword.location,
end_location: keyword.end_location,
node: KeywordData {
arg: keyword.node.arg,
value: keyword.node.value.into(),
value: (keyword.node.value, locator).into(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -909,14 +1011,17 @@ impl From<rustpython_parser::ast::Keyword> for Keyword {
}
}
impl From<rustpython_parser::ast::Arg> for Arg {
fn from(arg: rustpython_parser::ast::Arg) -> Self {
impl From<(rustpython_parser::ast::Arg, &Locator<'_>)> for Arg {
fn from((arg, locator): (rustpython_parser::ast::Arg, &Locator)) -> Self {
Arg {
location: arg.location,
end_location: arg.end_location,
node: ArgData {
arg: arg.node.arg,
annotation: arg.node.annotation.map(|a| Box::new((*a).into())),
annotation: arg
.node
.annotation
.map(|node| Box::new((*node, locator).into())),
type_comment: arg.node.type_comment,
},
trivia: vec![],
@ -925,33 +1030,61 @@ impl From<rustpython_parser::ast::Arg> for Arg {
}
}
impl From<rustpython_parser::ast::Arguments> for Arguments {
fn from(arguments: rustpython_parser::ast::Arguments) -> Self {
impl From<(rustpython_parser::ast::Arguments, &Locator<'_>)> for Arguments {
fn from((arguments, locator): (rustpython_parser::ast::Arguments, &Locator)) -> Self {
Arguments {
posonlyargs: arguments.posonlyargs.into_iter().map(Into::into).collect(),
args: arguments.args.into_iter().map(Into::into).collect(),
vararg: arguments.vararg.map(|v| Box::new((*v).into())),
kwonlyargs: arguments.kwonlyargs.into_iter().map(Into::into).collect(),
kw_defaults: arguments.kw_defaults.into_iter().map(Into::into).collect(),
kwarg: arguments.kwarg.map(|k| Box::new((*k).into())),
defaults: arguments.defaults.into_iter().map(Into::into).collect(),
posonlyargs: arguments
.posonlyargs
.into_iter()
.map(|node| (node, locator).into())
.collect(),
args: arguments
.args
.into_iter()
.map(|node| (node, locator).into())
.collect(),
vararg: arguments
.vararg
.map(|node| Box::new((*node, locator).into())),
kwonlyargs: arguments
.kwonlyargs
.into_iter()
.map(|node| (node, locator).into())
.collect(),
kw_defaults: arguments
.kw_defaults
.into_iter()
.map(|node| (node, locator).into())
.collect(),
kwarg: arguments
.kwarg
.map(|node| Box::new((*node, locator).into())),
defaults: arguments
.defaults
.into_iter()
.map(|node| (node, locator).into())
.collect(),
}
}
}
impl From<rustpython_parser::ast::Comprehension> for Comprehension {
fn from(comprehension: rustpython_parser::ast::Comprehension) -> Self {
impl From<(rustpython_parser::ast::Comprehension, &Locator<'_>)> for Comprehension {
fn from((comprehension, locator): (rustpython_parser::ast::Comprehension, &Locator)) -> Self {
Comprehension {
target: comprehension.target.into(),
iter: comprehension.iter.into(),
ifs: comprehension.ifs.into_iter().map(Into::into).collect(),
target: (comprehension.target, locator).into(),
iter: (comprehension.iter, locator).into(),
ifs: comprehension
.ifs
.into_iter()
.map(|node| (node, locator).into())
.collect(),
is_async: comprehension.is_async,
}
}
}
impl From<rustpython_parser::ast::Expr> for Expr {
fn from(expr: rustpython_parser::ast::Expr) -> Self {
impl From<(rustpython_parser::ast::Expr, &Locator<'_>)> for Expr {
fn from((expr, locator): (rustpython_parser::ast::Expr, &Locator)) -> Self {
match expr.node {
rustpython_parser::ast::ExprKind::Name { id, ctx } => Expr {
location: expr.location,
@ -968,7 +1101,10 @@ impl From<rustpython_parser::ast::Expr> for Expr {
end_location: expr.end_location,
node: ExprKind::BoolOp {
op: op.into(),
values: values.into_iter().map(Into::into).collect(),
values: values
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -977,8 +1113,8 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::NamedExpr {
target: Box::new((*target).into()),
value: Box::new((*value).into()),
target: Box::new((*target, locator).into()),
value: Box::new((*value, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -987,9 +1123,9 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::BinOp {
left: Box::new((*left).into()),
left: Box::new((*left, locator).into()),
op: op.into(),
right: Box::new((*right).into()),
right: Box::new((*right, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -999,7 +1135,7 @@ impl From<rustpython_parser::ast::Expr> for Expr {
end_location: expr.end_location,
node: ExprKind::UnaryOp {
op: op.into(),
operand: Box::new((*operand).into()),
operand: Box::new((*operand, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1008,8 +1144,8 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Lambda {
args: Box::new((*args).into()),
body: Box::new((*body).into()),
args: Box::new((*args, locator).into()),
body: Box::new((*body, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1018,9 +1154,9 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::IfExp {
test: Box::new((*test).into()),
body: Box::new((*body).into()),
orelse: Box::new((*orelse).into()),
test: Box::new((*test, locator).into()),
body: Box::new((*body, locator).into()),
orelse: Box::new((*orelse, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1029,8 +1165,14 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Dict {
keys: keys.into_iter().map(|key| key.map(Into::into)).collect(),
values: values.into_iter().map(Into::into).collect(),
keys: keys
.into_iter()
.map(|key| key.map(|node| (node, locator).into()))
.collect(),
values: values
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1039,7 +1181,10 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Set {
elts: elts.into_iter().map(Into::into).collect(),
elts: elts
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1048,8 +1193,11 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::ListComp {
elt: Box::new((*elt).into()),
generators: generators.into_iter().map(Into::into).collect(),
elt: Box::new((*elt, locator).into()),
generators: generators
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1058,8 +1206,11 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::SetComp {
elt: Box::new((*elt).into()),
generators: generators.into_iter().map(Into::into).collect(),
elt: Box::new((*elt, locator).into()),
generators: generators
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1072,9 +1223,12 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::DictComp {
key: Box::new((*key).into()),
value: Box::new((*value).into()),
generators: generators.into_iter().map(Into::into).collect(),
key: Box::new((*key, locator).into()),
value: Box::new((*value, locator).into()),
generators: generators
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1083,8 +1237,11 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::GeneratorExp {
elt: Box::new((*elt).into()),
generators: generators.into_iter().map(Into::into).collect(),
elt: Box::new((*elt, locator).into()),
generators: generators
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1093,7 +1250,7 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Await {
value: Box::new((*value).into()),
value: Box::new((*value, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1102,7 +1259,7 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Yield {
value: value.map(|v| Box::new((*v).into())),
value: value.map(|v| Box::new((*v, locator).into())),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1111,7 +1268,7 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::YieldFrom {
value: Box::new((*value).into()),
value: Box::new((*value, locator).into()),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1124,9 +1281,12 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Compare {
left: Box::new((*left).into()),
left: Box::new((*left, locator).into()),
ops: ops.into_iter().map(Into::into).collect(),
comparators: comparators.into_iter().map(Into::into).collect(),
comparators: comparators
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1139,9 +1299,15 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Call {
func: Box::new((*func).into()),
args: args.into_iter().map(Into::into).collect(),
keywords: keywords.into_iter().map(Into::into).collect(),
func: Box::new((*func, locator).into()),
args: args
.into_iter()
.map(|node| (node, locator).into())
.collect(),
keywords: keywords
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1154,9 +1320,9 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::FormattedValue {
value: Box::new((*value).into()),
value: Box::new((*value, locator).into()),
conversion,
format_spec: format_spec.map(|f| Box::new((*f).into())),
format_spec: format_spec.map(|f| Box::new((*f, locator).into())),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1165,7 +1331,10 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::JoinedStr {
values: values.into_iter().map(Into::into).collect(),
values: values
.into_iter()
.map(|node| (node, locator).into())
.collect(),
},
trivia: vec![],
parentheses: Parenthesize::Never,
@ -1181,7 +1350,7 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Attribute {
value: Box::new((*value).into()),
value: Box::new((*value, locator).into()),
attr,
ctx: ctx.into(),
},
@ -1192,8 +1361,8 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Subscript {
value: Box::new((*value).into()),
slice: Box::new((*slice).into()),
value: Box::new((*value, locator).into()),
slice: Box::new((*slice, locator).into()),
ctx: ctx.into(),
},
trivia: vec![],
@ -1203,7 +1372,7 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Starred {
value: Box::new((*value).into()),
value: Box::new((*value, locator).into()),
ctx: ctx.into(),
},
trivia: vec![],
@ -1213,7 +1382,10 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::List {
elts: elts.into_iter().map(Into::into).collect(),
elts: elts
.into_iter()
.map(|node| (node, locator).into())
.collect(),
ctx: ctx.into(),
},
trivia: vec![],
@ -1223,7 +1395,10 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Tuple {
elts: elts.into_iter().map(Into::into).collect(),
elts: elts
.into_iter()
.map(|node| (node, locator).into())
.collect(),
ctx: ctx.into(),
},
trivia: vec![],
@ -1233,9 +1408,9 @@ impl From<rustpython_parser::ast::Expr> for Expr {
location: expr.location,
end_location: expr.end_location,
node: ExprKind::Slice {
lower: lower.map(|l| Box::new((*l).into())),
upper: upper.map(|u| Box::new((*u).into())),
step: step.map(|s| Box::new((*s).into())),
lower: lower.map(|node| Box::new((*node, locator).into())),
upper: upper.map(|node| Box::new((*node, locator).into())),
step: step.map(|node| Box::new((*node, locator).into())),
},
trivia: vec![],
parentheses: Parenthesize::Never,

15
crates/ruff_python_formatter/src/lib.rs
View file

@ -1,7 +1,8 @@
use anyhow::Result;
use ruff_formatter::{format, Formatted, IndentStyle, SimpleFormatOptions};
use rustpython_parser::lexer::LexResult;
use ruff_formatter::{format, Formatted, IndentStyle, SimpleFormatOptions};
use crate::attachment::attach;
use crate::context::ASTFormatContext;
use crate::core::locator::Locator;
@ -35,7 +36,10 @@ pub fn fmt(contents: &str) -> Result<Formatted<ASTFormatContext>> {
let python_ast = ruff_rustpython::parse_program_tokens(tokens, "<filename>")?;
// Convert to a CST.
let mut python_cst: Vec<Stmt> = python_ast.into_iter().map(Into::into).collect();
let mut python_cst: Vec<Stmt> = python_ast
.into_iter()
.map(|stmt| (stmt, &locator).into())
.collect();
// Attach trivia.
attach(&mut python_cst, trivia);
@ -57,15 +61,16 @@ pub fn fmt(contents: &str) -> Result<Formatted<ASTFormatContext>> {
#[cfg(test)]
mod tests {
use std::fmt::{Formatter, Write};
use std::fs;
use std::path::Path;
use anyhow::Result;
use similar::TextDiff;
use ruff_testing_macros::fixture;
use crate::fmt;
use ruff_testing_macros::fixture;
use similar::TextDiff;
use std::fmt::{Formatter, Write};
#[fixture(
pattern = "resources/test/fixtures/black/**/*.py",