From 1d8df1305ae326073b32eaadff0a57340d1e8ca1 Mon Sep 17 00:00:00 2001 From: Zanie Date: Tue, 18 Jul 2023 09:49:25 -0500 Subject: [PATCH 1/2] Implement `Comparable` for type aliases and parameters --- crates/ruff_python_ast/src/comparable.rs | 83 ++++++++++++++++++++++-- 1 file changed, 76 insertions(+), 7 deletions(-) diff --git a/crates/ruff_python_ast/src/comparable.rs b/crates/ruff_python_ast/src/comparable.rs index 5ebc6468ba8bb..7a08b0ead581d 100644 --- a/crates/ruff_python_ast/src/comparable.rs +++ b/crates/ruff_python_ast/src/comparable.rs @@ -935,6 +935,7 @@ pub struct StmtFunctionDef<'a> { args: ComparableArguments<'a>, body: Vec>, decorator_list: Vec>, + type_params: Vec>, returns: Option>, type_comment: Option<&'a str>, } @@ -945,6 +946,7 @@ pub struct StmtAsyncFunctionDef<'a> { args: ComparableArguments<'a>, body: Vec>, decorator_list: Vec>, + type_params: Vec>, returns: Option>, type_comment: Option<&'a str>, } @@ -956,6 +958,7 @@ pub struct StmtClassDef<'a> { keywords: Vec>, body: Vec>, decorator_list: Vec>, + type_params: Vec>, } #[derive(Debug, PartialEq, Eq, Hash)] @@ -968,6 +971,59 @@ pub struct StmtDelete<'a> { targets: Vec>, } +#[derive(Debug, PartialEq, Eq, Hash)] +pub struct StmtTypeAlias<'a> { + pub name: Box>, + pub type_params: Vec>, + pub value: Box>, +} + +#[derive(Debug, PartialEq, Eq, Hash)] +pub enum ComparableTypeParam<'a> { + TypeVar(TypeParamTypeVar<'a>), + ParamSpec(TypeParamParamSpec<'a>), + TypeVarTuple(TypeParamTypeVarTuple<'a>), +} + +impl<'a> From<&'a ast::TypeParam> for ComparableTypeParam<'a> { + fn from(type_param: &'a ast::TypeParam) -> Self { + match type_param { + ast::TypeParam::TypeVar(ast::TypeParamTypeVar { name, bound, .. }) => { + Self::TypeVar(TypeParamTypeVar { + name: name.as_str(), + bound: bound.as_ref().map(Into::into), + }) + } + ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, .. }) => { + Self::TypeVarTuple(TypeParamTypeVarTuple { + name: name.as_str(), + }) + } + ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, .. }) => { + Self::ParamSpec(TypeParamParamSpec { + name: name.as_str(), + }) + } + } + } +} + +#[derive(Debug, PartialEq, Eq, Hash)] +pub struct TypeParamTypeVar<'a> { + pub name: &'a str, + pub bound: Option>>, +} + +#[derive(Debug, PartialEq, Eq, Hash)] +pub struct TypeParamParamSpec<'a> { + pub name: &'a str, +} + +#[derive(Debug, PartialEq, Eq, Hash)] +pub struct TypeParamTypeVarTuple<'a> { + pub name: &'a str, +} + #[derive(Debug, PartialEq, Eq, Hash)] pub struct StmtAssign<'a> { targets: Vec>, @@ -1117,6 +1173,7 @@ pub enum ComparableStmt<'a> { Raise(StmtRaise<'a>), Try(StmtTry<'a>), TryStar(StmtTryStar<'a>), + TypeAlias(StmtTypeAlias<'a>), Assert(StmtAssert<'a>), Import(StmtImport<'a>), ImportFrom(StmtImportFrom<'a>), @@ -1138,8 +1195,8 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> { decorator_list, returns, type_comment, - range: _, - type_params: _, + type_params, + range: _range, }) => Self::FunctionDef(StmtFunctionDef { name: name.as_str(), args: args.into(), @@ -1147,6 +1204,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> { decorator_list: decorator_list.iter().map(Into::into).collect(), returns: returns.as_ref().map(Into::into), type_comment: type_comment.as_ref().map(String::as_str), + type_params: type_params.iter().map(Into::into).collect(), }), ast::Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { name, @@ -1155,8 +1213,8 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> { decorator_list, returns, type_comment, - range: _, - type_params: _, + type_params, + range: _range, }) => Self::AsyncFunctionDef(StmtAsyncFunctionDef { name: name.as_str(), args: args.into(), @@ -1164,6 +1222,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> { decorator_list: decorator_list.iter().map(Into::into).collect(), returns: returns.as_ref().map(Into::into), type_comment: type_comment.as_ref().map(String::as_str), + type_params: type_params.iter().map(Into::into).collect(), }), ast::Stmt::ClassDef(ast::StmtClassDef { name, @@ -1171,14 +1230,15 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> { keywords, body, decorator_list, - range: _, - type_params: _, + type_params, + range: _range, }) => Self::ClassDef(StmtClassDef { name: name.as_str(), bases: bases.iter().map(Into::into).collect(), keywords: keywords.iter().map(Into::into).collect(), body: body.iter().map(Into::into).collect(), decorator_list: decorator_list.iter().map(Into::into).collect(), + type_params: type_params.iter().map(Into::into).collect(), }), ast::Stmt::Return(ast::StmtReturn { value, @@ -1192,6 +1252,16 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> { }) => Self::Delete(StmtDelete { targets: targets.iter().map(Into::into).collect(), }), + ast::Stmt::TypeAlias(ast::StmtTypeAlias { + range: _range, + name, + type_params, + value, + }) => Self::TypeAlias(StmtTypeAlias { + name: name.into(), + type_params: type_params.iter().map(Into::into).collect(), + value: value.into(), + }), ast::Stmt::Assign(ast::StmtAssign { targets, value, @@ -1377,7 +1447,6 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> { ast::Stmt::Pass(_) => Self::Pass, ast::Stmt::Break(_) => Self::Break, ast::Stmt::Continue(_) => Self::Continue, - ast::Stmt::TypeAlias(_) => todo!(), } } } From ab52f1ad1cac08861b3d05b67e6e38fc65aed1bc Mon Sep 17 00:00:00 2001 From: Zanie Date: Tue, 18 Jul 2023 12:04:35 -0500 Subject: [PATCH 2/2] Explicitly consume `range` --- crates/ruff_python_ast/src/comparable.rs | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/crates/ruff_python_ast/src/comparable.rs b/crates/ruff_python_ast/src/comparable.rs index 7a08b0ead581d..af78faf2a4d59 100644 --- a/crates/ruff_python_ast/src/comparable.rs +++ b/crates/ruff_python_ast/src/comparable.rs @@ -988,18 +988,20 @@ pub enum ComparableTypeParam<'a> { impl<'a> From<&'a ast::TypeParam> for ComparableTypeParam<'a> { fn from(type_param: &'a ast::TypeParam) -> Self { match type_param { - ast::TypeParam::TypeVar(ast::TypeParamTypeVar { name, bound, .. }) => { - Self::TypeVar(TypeParamTypeVar { - name: name.as_str(), - bound: bound.as_ref().map(Into::into), - }) - } - ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, .. }) => { + ast::TypeParam::TypeVar(ast::TypeParamTypeVar { + name, + bound, + range: _, + }) => Self::TypeVar(TypeParamTypeVar { + name: name.as_str(), + bound: bound.as_ref().map(Into::into), + }), + ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, range: _ }) => { Self::TypeVarTuple(TypeParamTypeVarTuple { name: name.as_str(), }) } - ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, .. }) => { + ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, range: _ }) => { Self::ParamSpec(TypeParamParamSpec { name: name.as_str(), })