mirror of
https://github.com/RustPython/Parser.git
synced 2025-07-15 00:55:22 +00:00
Refactor ast to hold data as seperated type
This commit is contained in:
Jeong YunWon
parent
9f1a538eba
commit
6d7358090b
111 changed files with 23485 additions and 20218 deletions
|
|
@ -71,7 +71,7 @@ impl<'a> Unparser<'a> {
|
|||
}};
|
||||
}
|
||||
match &ast.node {
|
||||
ExprKind::BoolOp { op, values } => {
|
||||
ExprKind::BoolOp(crate::ExprBoolOp { op, values }) => {
|
||||
let (op, prec) = op_prec!(bin, op, Boolop, And("and", AND), Or("or", OR));
|
||||
group_if!(prec, {
|
||||
let mut first = true;
|
||||
|
|
@ -81,14 +81,14 @@ impl<'a> Unparser<'a> {
|
|||
}
|
||||
})
|
||||
}
|
||||
ExprKind::NamedExpr { target, value } => {
|
||||
ExprKind::NamedExpr(crate::ExprNamedExpr { target, value }) => {
|
||||
group_if!(precedence::TUPLE, {
|
||||
self.unparse_expr(target, precedence::ATOM)?;
|
||||
self.p(" := ")?;
|
||||
self.unparse_expr(value, precedence::ATOM)?;
|
||||
})
|
||||
}
|
||||
ExprKind::BinOp { left, op, right } => {
|
||||
ExprKind::BinOp(crate::ExprBinOp { left, op, right }) => {
|
||||
let right_associative = matches!(op, Operator::Pow);
|
||||
let (op, prec) = op_prec!(
|
||||
bin,
|
||||
|
|
@ -114,7 +114,7 @@ impl<'a> Unparser<'a> {
|
|||
self.unparse_expr(right, prec + !right_associative as u8)?;
|
||||
})
|
||||
}
|
||||
ExprKind::UnaryOp { op, operand } => {
|
||||
ExprKind::UnaryOp(crate::ExprUnaryOp { op, operand }) => {
|
||||
let (op, prec) = op_prec!(
|
||||
un,
|
||||
op,
|
||||
|
|
@ -129,7 +129,7 @@ impl<'a> Unparser<'a> {
|
|||
self.unparse_expr(operand, prec)?;
|
||||
})
|
||||
}
|
||||
ExprKind::Lambda { args, body } => {
|
||||
ExprKind::Lambda(crate::ExprLambda { args, body }) => {
|
||||
group_if!(precedence::TEST, {
|
||||
let pos = args.args.len() + args.posonlyargs.len();
|
||||
self.p(if pos > 0 { "lambda " } else { "lambda" })?;
|
||||
|
|
@ -137,7 +137,7 @@ impl<'a> Unparser<'a> {
|
|||
write!(self, ": {}", **body)?;
|
||||
})
|
||||
}
|
||||
ExprKind::IfExp { test, body, orelse } => {
|
||||
ExprKind::IfExp(crate::ExprIfExp { test, body, orelse }) => {
|
||||
group_if!(precedence::TEST, {
|
||||
self.unparse_expr(body, precedence::TEST + 1)?;
|
||||
self.p(" if ")?;
|
||||
|
|
@ -146,7 +146,7 @@ impl<'a> Unparser<'a> {
|
|||
self.unparse_expr(orelse, precedence::TEST)?;
|
||||
})
|
||||
}
|
||||
ExprKind::Dict { keys, values } => {
|
||||
ExprKind::Dict(crate::ExprDict { keys, values }) => {
|
||||
self.p("{")?;
|
||||
let mut first = true;
|
||||
let (packed, unpacked) = values.split_at(keys.len());
|
||||
|
|
@ -164,7 +164,7 @@ impl<'a> Unparser<'a> {
|
|||
}
|
||||
self.p("}")?;
|
||||
}
|
||||
ExprKind::Set { elts } => {
|
||||
ExprKind::Set(crate::ExprSet { elts }) => {
|
||||
self.p("{")?;
|
||||
let mut first = true;
|
||||
for v in elts {
|
||||
|
|
@ -173,23 +173,23 @@ impl<'a> Unparser<'a> {
|
|||
}
|
||||
self.p("}")?;
|
||||
}
|
||||
ExprKind::ListComp { elt, generators } => {
|
||||
ExprKind::ListComp(crate::ExprListComp { elt, generators }) => {
|
||||
self.p("[")?;
|
||||
self.unparse_expr(elt, precedence::TEST)?;
|
||||
self.unparse_comp(generators)?;
|
||||
self.p("]")?;
|
||||
}
|
||||
ExprKind::SetComp { elt, generators } => {
|
||||
ExprKind::SetComp(crate::ExprSetComp { elt, generators }) => {
|
||||
self.p("{")?;
|
||||
self.unparse_expr(elt, precedence::TEST)?;
|
||||
self.unparse_comp(generators)?;
|
||||
self.p("}")?;
|
||||
}
|
||||
ExprKind::DictComp {
|
||||
ExprKind::DictComp(crate::ExprDictComp {
|
||||
key,
|
||||
value,
|
||||
generators,
|
||||
} => {
|
||||
}) => {
|
||||
self.p("{")?;
|
||||
self.unparse_expr(key, precedence::TEST)?;
|
||||
self.p(": ")?;
|
||||
|
|
@ -197,33 +197,33 @@ impl<'a> Unparser<'a> {
|
|||
self.unparse_comp(generators)?;
|
||||
self.p("}")?;
|
||||
}
|
||||
ExprKind::GeneratorExp { elt, generators } => {
|
||||
ExprKind::GeneratorExp(crate::ExprGeneratorExp { elt, generators }) => {
|
||||
self.p("(")?;
|
||||
self.unparse_expr(elt, precedence::TEST)?;
|
||||
self.unparse_comp(generators)?;
|
||||
self.p(")")?;
|
||||
}
|
||||
ExprKind::Await { value } => {
|
||||
ExprKind::Await(crate::ExprAwait { value }) => {
|
||||
group_if!(precedence::AWAIT, {
|
||||
self.p("await ")?;
|
||||
self.unparse_expr(value, precedence::ATOM)?;
|
||||
})
|
||||
}
|
||||
ExprKind::Yield { value } => {
|
||||
ExprKind::Yield(crate::ExprYield { value }) => {
|
||||
if let Some(value) = value {
|
||||
write!(self, "(yield {})", **value)?;
|
||||
} else {
|
||||
self.p("(yield)")?;
|
||||
}
|
||||
}
|
||||
ExprKind::YieldFrom { value } => {
|
||||
ExprKind::YieldFrom(crate::ExprYieldFrom { value }) => {
|
||||
write!(self, "(yield from {})", **value)?;
|
||||
}
|
||||
ExprKind::Compare {
|
||||
ExprKind::Compare(crate::ExprCompare {
|
||||
left,
|
||||
ops,
|
||||
comparators,
|
||||
} => {
|
||||
}) => {
|
||||
group_if!(precedence::CMP, {
|
||||
let new_lvl = precedence::CMP + 1;
|
||||
self.unparse_expr(left, new_lvl)?;
|
||||
|
|
@ -245,16 +245,16 @@ impl<'a> Unparser<'a> {
|
|||
}
|
||||
})
|
||||
}
|
||||
ExprKind::Call {
|
||||
ExprKind::Call(crate::ExprCall {
|
||||
func,
|
||||
args,
|
||||
keywords,
|
||||
} => {
|
||||
}) => {
|
||||
self.unparse_expr(func, precedence::ATOM)?;
|
||||
self.p("(")?;
|
||||
if let (
|
||||
[Expr {
|
||||
node: ExprKind::GeneratorExp { elt, generators },
|
||||
node: ExprKind::GeneratorExp(crate::ExprGeneratorExp { elt, generators }),
|
||||
..
|
||||
}],
|
||||
[],
|
||||
|
|
@ -282,13 +282,15 @@ impl<'a> Unparser<'a> {
|
|||
}
|
||||
self.p(")")?;
|
||||
}
|
||||
ExprKind::FormattedValue {
|
||||
ExprKind::FormattedValue(crate::ExprFormattedValue {
|
||||
value,
|
||||
conversion,
|
||||
format_spec,
|
||||
} => self.unparse_formatted(value, *conversion, format_spec.as_deref())?,
|
||||
ExprKind::JoinedStr { values } => self.unparse_joined_str(values, false)?,
|
||||
ExprKind::Constant { value, kind } => {
|
||||
}) => self.unparse_formatted(value, *conversion, format_spec.as_deref())?,
|
||||
ExprKind::JoinedStr(crate::ExprJoinedStr { values }) => {
|
||||
self.unparse_joined_str(values, false)?
|
||||
}
|
||||
ExprKind::Constant(crate::ExprConstant { value, kind }) => {
|
||||
if let Some(kind) = kind {
|
||||
self.p(kind)?;
|
||||
}
|
||||
|
|
@ -304,12 +306,12 @@ impl<'a> Unparser<'a> {
|
|||
_ => fmt::Display::fmt(value, &mut self.f)?,
|
||||
}
|
||||
}
|
||||
ExprKind::Attribute { value, attr, .. } => {
|
||||
ExprKind::Attribute(crate::ExprAttribute { value, attr, .. }) => {
|
||||
self.unparse_expr(value, precedence::ATOM)?;
|
||||
let period = if let ExprKind::Constant {
|
||||
let period = if let ExprKind::Constant(crate::ExprConstant {
|
||||
value: Constant::Int(_),
|
||||
..
|
||||
} = &value.node
|
||||
}) = &value.node
|
||||
{
|
||||
" ."
|
||||
} else {
|
||||
|
|
@ -318,10 +320,10 @@ impl<'a> Unparser<'a> {
|
|||
self.p(period)?;
|
||||
self.p(attr)?;
|
||||
}
|
||||
ExprKind::Subscript { value, slice, .. } => {
|
||||
ExprKind::Subscript(crate::ExprSubscript { value, slice, .. }) => {
|
||||
self.unparse_expr(value, precedence::ATOM)?;
|
||||
let mut lvl = precedence::TUPLE;
|
||||
if let ExprKind::Tuple { elts, .. } = &slice.node {
|
||||
if let ExprKind::Tuple(crate::ExprTuple { elts, .. }) = &slice.node {
|
||||
if elts
|
||||
.iter()
|
||||
.any(|expr| matches!(expr.node, ExprKind::Starred { .. }))
|
||||
|
|
@ -333,12 +335,12 @@ impl<'a> Unparser<'a> {
|
|||
self.unparse_expr(slice, lvl)?;
|
||||
self.p("]")?;
|
||||
}
|
||||
ExprKind::Starred { value, .. } => {
|
||||
ExprKind::Starred(crate::ExprStarred { value, .. }) => {
|
||||
self.p("*")?;
|
||||
self.unparse_expr(value, precedence::EXPR)?;
|
||||
}
|
||||
ExprKind::Name { id, .. } => self.p(id)?,
|
||||
ExprKind::List { elts, .. } => {
|
||||
ExprKind::Name(crate::ExprName { id, .. }) => self.p(id)?,
|
||||
ExprKind::List(crate::ExprList { elts, .. }) => {
|
||||
self.p("[")?;
|
||||
let mut first = true;
|
||||
for elt in elts {
|
||||
|
|
@ -347,7 +349,7 @@ impl<'a> Unparser<'a> {
|
|||
}
|
||||
self.p("]")?;
|
||||
}
|
||||
ExprKind::Tuple { elts, .. } => {
|
||||
ExprKind::Tuple(crate::ExprTuple { elts, .. }) => {
|
||||
if elts.is_empty() {
|
||||
self.p("()")?;
|
||||
} else {
|
||||
|
|
@ -361,7 +363,7 @@ impl<'a> Unparser<'a> {
|
|||
})
|
||||
}
|
||||
}
|
||||
ExprKind::Slice { lower, upper, step } => {
|
||||
ExprKind::Slice(crate::ExprSlice { lower, upper, step }) => {
|
||||
if let Some(lower) = lower {
|
||||
self.unparse_expr(lower, precedence::TEST)?;
|
||||
}
|
||||
|
|
@ -483,19 +485,21 @@ impl<'a> Unparser<'a> {
|
|||
|
||||
fn unparse_fstring_elem<U>(&mut self, expr: &Expr<U>, is_spec: bool) -> fmt::Result {
|
||||
match &expr.node {
|
||||
ExprKind::Constant { value, .. } => {
|
||||
ExprKind::Constant(crate::ExprConstant { value, .. }) => {
|
||||
if let Constant::Str(s) = value {
|
||||
self.unparse_fstring_str(s)
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
ExprKind::JoinedStr { values } => self.unparse_joined_str(values, is_spec),
|
||||
ExprKind::FormattedValue {
|
||||
ExprKind::JoinedStr(crate::ExprJoinedStr { values }) => {
|
||||
self.unparse_joined_str(values, is_spec)
|
||||
}
|
||||
ExprKind::FormattedValue(crate::ExprFormattedValue {
|
||||
value,
|
||||
conversion,
|
||||
format_spec,
|
||||
} => self.unparse_formatted(value, *conversion, format_spec.as_deref()),
|
||||
}) => self.unparse_formatted(value, *conversion, format_spec.as_deref()),
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue