language-servers/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-10-02 06:42:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Use dedicated structs for excepthandler variants (#5065)

Browse source 
## Summary

Oversight from #5042.
This commit is contained in:
Charlie Marsh 2023-06-13 18:37:06 -04:00 • committed by GitHub
parent 1895011ac2
commit c2fa568b46
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 47 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -27,8 +27,8 @@ pub enum ComparableBoolop {
Or, Or,
} }
impl From<&ast::Boolop> for ComparableBoolop { impl From<ast::Boolop> for ComparableBoolop {
fn from(op: &ast::Boolop) -> Self { fn from(op: ast::Boolop) -> Self {
match op { match op {
ast::Boolop::And => Self::And, ast::Boolop::And => Self::And,
ast::Boolop::Or => Self::Or, ast::Boolop::Or => Self::Or,
@ -53,8 +53,8 @@ pub enum ComparableOperator {
FloorDiv, FloorDiv,
} }
impl From<&ast::Operator> for ComparableOperator { impl From<ast::Operator> for ComparableOperator {
fn from(op: &ast::Operator) -> Self { fn from(op: ast::Operator) -> Self {
match op { match op {
ast::Operator::Add => Self::Add, ast::Operator::Add => Self::Add,
ast::Operator::Sub => Self::Sub, ast::Operator::Sub => Self::Sub,
@ -81,8 +81,8 @@ pub enum ComparableUnaryop {
USub, USub,
} }
impl From<&ast::Unaryop> for ComparableUnaryop { impl From<ast::Unaryop> for ComparableUnaryop {
fn from(op: &ast::Unaryop) -> Self { fn from(op: ast::Unaryop) -> Self {
match op { match op {
ast::Unaryop::Invert => Self::Invert, ast::Unaryop::Invert => Self::Invert,
ast::Unaryop::Not => Self::Not, ast::Unaryop::Not => Self::Not,
@ -106,8 +106,8 @@ pub enum ComparableCmpop {
NotIn, NotIn,
} }
impl From<&ast::Cmpop> for ComparableCmpop { impl From<ast::Cmpop> for ComparableCmpop {
fn from(op: &ast::Cmpop) -> Self { fn from(op: ast::Cmpop) -> Self {
match op { match op {
ast::Cmpop::Eq => Self::Eq, ast::Cmpop::Eq => Self::Eq,
ast::Cmpop::NotEq => Self::NotEq, ast::Cmpop::NotEq => Self::NotEq,
@ -125,8 +125,8 @@ impl From<&ast::Cmpop> for ComparableCmpop {
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableAlias<'a> { pub struct ComparableAlias<'a> {
pub name: &'a str, name: &'a str,
pub asname: Option<&'a str>, asname: Option<&'a str>,
} }
impl<'a> From<&'a ast::Alias> for ComparableAlias<'a> { impl<'a> From<&'a ast::Alias> for ComparableAlias<'a> {
@ -140,8 +140,8 @@ impl<'a> From<&'a ast::Alias> for ComparableAlias<'a> {
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableWithitem<'a> { pub struct ComparableWithitem<'a> {
pub context_expr: ComparableExpr<'a>, context_expr: ComparableExpr<'a>,
pub optional_vars: Option<ComparableExpr<'a>>, optional_vars: Option<ComparableExpr<'a>>,
} }
impl<'a> From<&'a ast::Withitem> for ComparableWithitem<'a> { impl<'a> From<&'a ast::Withitem> for ComparableWithitem<'a> {
@ -280,9 +280,9 @@ impl<'a> From<&'a Box<ast::Pattern>> for Box<ComparablePattern<'a>> {
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableMatchCase<'a> { pub struct ComparableMatchCase<'a> {
pub pattern: ComparablePattern<'a>, pattern: ComparablePattern<'a>,
pub guard: Option<ComparableExpr<'a>>, guard: Option<ComparableExpr<'a>>,
pub body: Vec<ComparableStmt<'a>>, body: Vec<ComparableStmt<'a>>,
} }
impl<'a> From<&'a ast::MatchCase> for ComparableMatchCase<'a> { impl<'a> From<&'a ast::MatchCase> for ComparableMatchCase<'a> {
@ -297,7 +297,7 @@ impl<'a> From<&'a ast::MatchCase> for ComparableMatchCase<'a> {
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableDecorator<'a> { pub struct ComparableDecorator<'a> {
pub expression: ComparableExpr<'a>, expression: ComparableExpr<'a>,
} }
impl<'a> From<&'a ast::Decorator> for ComparableDecorator<'a> { impl<'a> From<&'a ast::Decorator> for ComparableDecorator<'a> {
@ -342,13 +342,13 @@ impl<'a> From<&'a ast::Constant> for ComparableConstant<'a> {
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableArguments<'a> { pub struct ComparableArguments<'a> {
pub posonlyargs: Vec<ComparableArg<'a>>, posonlyargs: Vec<ComparableArg<'a>>,
pub args: Vec<ComparableArg<'a>>, args: Vec<ComparableArg<'a>>,
pub vararg: Option<ComparableArg<'a>>, vararg: Option<ComparableArg<'a>>,
pub kwonlyargs: Vec<ComparableArg<'a>>, kwonlyargs: Vec<ComparableArg<'a>>,
pub kw_defaults: Vec<ComparableExpr<'a>>, kw_defaults: Vec<ComparableExpr<'a>>,
pub kwarg: Option<ComparableArg<'a>>, kwarg: Option<ComparableArg<'a>>,
pub defaults: Vec<ComparableExpr<'a>>, defaults: Vec<ComparableExpr<'a>>,
} }
impl<'a> From<&'a ast::Arguments> for ComparableArguments<'a> { impl<'a> From<&'a ast::Arguments> for ComparableArguments<'a> {
@ -379,9 +379,9 @@ impl<'a> From<&'a Box<ast::Arg>> for ComparableArg<'a> {
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableArg<'a> { pub struct ComparableArg<'a> {
pub arg: &'a str, arg: &'a str,
pub annotation: Option<Box<ComparableExpr<'a>>>, annotation: Option<Box<ComparableExpr<'a>>>,
pub type_comment: Option<&'a str>, type_comment: Option<&'a str>,
} }
impl<'a> From<&'a ast::Arg> for ComparableArg<'a> { impl<'a> From<&'a ast::Arg> for ComparableArg<'a> {
@ -396,8 +396,8 @@ impl<'a> From<&'a ast::Arg> for ComparableArg<'a> {
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableKeyword<'a> { pub struct ComparableKeyword<'a> {
pub arg: Option<&'a str>, arg: Option<&'a str>,
pub value: ComparableExpr<'a>, value: ComparableExpr<'a>,
} }
impl<'a> From<&'a ast::Keyword> for ComparableKeyword<'a> { impl<'a> From<&'a ast::Keyword> for ComparableKeyword<'a> {
@ -411,10 +411,10 @@ impl<'a> From<&'a ast::Keyword> for ComparableKeyword<'a> {
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableComprehension<'a> { pub struct ComparableComprehension<'a> {
pub target: ComparableExpr<'a>, target: ComparableExpr<'a>,
pub iter: ComparableExpr<'a>, iter: ComparableExpr<'a>,
pub ifs: Vec<ComparableExpr<'a>>, ifs: Vec<ComparableExpr<'a>>,
pub is_async: bool, is_async: bool,
} }
impl<'a> From<&'a ast::Comprehension> for ComparableComprehension<'a> { impl<'a> From<&'a ast::Comprehension> for ComparableComprehension<'a> {
@ -428,13 +428,16 @@ impl<'a> From<&'a ast::Comprehension> for ComparableComprehension<'a> {
} }
} }
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ExcepthandlerExceptHandler<'a> {
type_: Option<Box<ComparableExpr<'a>>>,
name: Option<&'a str>,
body: Vec<ComparableStmt<'a>>,
}
#[derive(Debug, PartialEq, Eq, Hash)] #[derive(Debug, PartialEq, Eq, Hash)]
pub enum ComparableExcepthandler<'a> { pub enum ComparableExcepthandler<'a> {
ExceptHandler { ExceptHandler(ExcepthandlerExceptHandler<'a>),
type_: Option<ComparableExpr<'a>>,
name: Option<&'a str>,
body: Vec<ComparableStmt<'a>>,
},
} }
impl<'a> From<&'a ast::Excepthandler> for ComparableExcepthandler<'a> { impl<'a> From<&'a ast::Excepthandler> for ComparableExcepthandler<'a> {
@ -445,11 +448,11 @@ impl<'a> From<&'a ast::Excepthandler> for ComparableExcepthandler<'a> {
body, body,
.. ..
}) = excepthandler; }) = excepthandler;
Self::ExceptHandler { Self::ExceptHandler(ExcepthandlerExceptHandler {
type_: type_.as_ref().map(Into::into), type_: type_.as_ref().map(Into::into),
name: name.as_deref(), name: name.as_deref(),
body: body.iter().map(Into::into).collect(), body: body.iter().map(Into::into).collect(),
} })
} }
} }
@ -670,7 +673,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
values, values,
range: _range, range: _range,
}) => Self::BoolOp(ExprBoolOp { }) => Self::BoolOp(ExprBoolOp {
op: op.into(), op: (*op).into(),
values: values.iter().map(Into::into).collect(), values: values.iter().map(Into::into).collect(),
}), }),
ast::Expr::NamedExpr(ast::ExprNamedExpr { ast::Expr::NamedExpr(ast::ExprNamedExpr {
@ -688,7 +691,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
range: _range, range: _range,
}) => Self::BinOp(ExprBinOp { }) => Self::BinOp(ExprBinOp {
left: left.into(), left: left.into(),
op: op.into(), op: (*op).into(),
right: right.into(), right: right.into(),
}), }),
ast::Expr::UnaryOp(ast::ExprUnaryOp { ast::Expr::UnaryOp(ast::ExprUnaryOp {
@ -696,7 +699,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
operand, operand,
range: _range, range: _range,
}) => Self::UnaryOp(ExprUnaryOp { }) => Self::UnaryOp(ExprUnaryOp {
op: op.into(), op: (*op).into(),
operand: operand.into(), operand: operand.into(),
}), }),
ast::Expr::Lambda(ast::ExprLambda { ast::Expr::Lambda(ast::ExprLambda {
@ -793,7 +796,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
range: _range, range: _range,
}) => Self::Compare(ExprCompare { }) => Self::Compare(ExprCompare {
left: left.into(), left: left.into(),
ops: ops.iter().map(Into::into).collect(), ops: ops.iter().copied().map(Into::into).collect(),
comparators: comparators.iter().map(Into::into).collect(), comparators: comparators.iter().map(Into::into).collect(),
}), }),
ast::Expr::Call(ast::ExprCall { ast::Expr::Call(ast::ExprCall {
@ -1173,7 +1176,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
range: _range, range: _range,
}) => Self::AugAssign(StmtAugAssign { }) => Self::AugAssign(StmtAugAssign {
target: target.into(), target: target.into(),
op: op.into(), op: (*op).into(),
value: value.into(), value: value.into(),
}), }),
ast::Stmt::AnnAssign(ast::StmtAnnAssign { ast::Stmt::AnnAssign(ast::StmtAnnAssign {