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

Delete type-ignore node

Browse source 
<!--
Thank you for contributing to Ruff! To help us out with reviewing, please consider the following:

- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title?
- Does this pull request include references to any relevant issues?
-->

## Summary

This PR removes the type ignore node from the AST because our parser doesn't support it, and just having it around is confusing.

<!-- What's the purpose of the change? What does it do, and why? -->

## Test Plan

`cargo build`

<!-- How was it tested? -->
This commit is contained in:
Micha Reiser 2023-08-01 12:34:50 +02:00 • committed by GitHub
parent c6986ac95d
commit 4ad5903ef6
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 13 additions and 391 deletions
Download patch file Download diff file Expand all files Collapse all files

261
crates/ruff_python_ast/src/node.rs
View file

@ -1,7 +1,7 @@
use crate::{ use crate::{
self as ast, Alias, Arg, ArgWithDefault, Arguments, Comprehension, Decorator, ExceptHandler, self as ast, Alias, Arg, ArgWithDefault, Arguments, Comprehension, Decorator, ExceptHandler,
Expr, Keyword, MatchCase, Mod, Pattern, Ranged, Stmt, TypeIgnore, TypeParam, Expr, Keyword, MatchCase, Mod, Pattern, Ranged, Stmt, TypeParam, TypeParamParamSpec,
TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, WithItem, TypeParamTypeVar, TypeParamTypeVarTuple, WithItem,
}; };
use ruff_text_size::TextRange; use ruff_text_size::TextRange;
use std::ptr::NonNull; use std::ptr::NonNull;
@ -91,7 +91,6 @@ pub enum AnyNode {
PatternMatchStar(ast::PatternMatchStar), PatternMatchStar(ast::PatternMatchStar),
PatternMatchAs(ast::PatternMatchAs), PatternMatchAs(ast::PatternMatchAs),
PatternMatchOr(ast::PatternMatchOr), PatternMatchOr(ast::PatternMatchOr),
TypeIgnoreTypeIgnore(ast::TypeIgnoreTypeIgnore),
Comprehension(Comprehension), Comprehension(Comprehension),
Arguments(Arguments), Arguments(Arguments),
Arg(Arg), Arg(Arg),
@ -181,7 +180,6 @@ impl AnyNode {
| AnyNode::PatternMatchStar(_) | AnyNode::PatternMatchStar(_)
| AnyNode::PatternMatchAs(_) | AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_) | AnyNode::PatternMatchOr(_)
| AnyNode::TypeIgnoreTypeIgnore(_)
| AnyNode::Comprehension(_) | AnyNode::Comprehension(_)
| AnyNode::Arguments(_) | AnyNode::Arguments(_)
| AnyNode::Arg(_) | AnyNode::Arg(_)
@ -271,7 +269,6 @@ impl AnyNode {
| AnyNode::PatternMatchStar(_) | AnyNode::PatternMatchStar(_)
| AnyNode::PatternMatchAs(_) | AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_) | AnyNode::PatternMatchOr(_)
| AnyNode::TypeIgnoreTypeIgnore(_)
| AnyNode::Comprehension(_) | AnyNode::Comprehension(_)
| AnyNode::Arguments(_) | AnyNode::Arguments(_)
| AnyNode::Arg(_) | AnyNode::Arg(_)
@ -361,7 +358,6 @@ impl AnyNode {
| AnyNode::PatternMatchStar(_) | AnyNode::PatternMatchStar(_)
| AnyNode::PatternMatchAs(_) | AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_) | AnyNode::PatternMatchOr(_)
| AnyNode::TypeIgnoreTypeIgnore(_)
| AnyNode::Comprehension(_) | AnyNode::Comprehension(_)
| AnyNode::Arguments(_) | AnyNode::Arguments(_)
| AnyNode::Arg(_) | AnyNode::Arg(_)
@ -451,7 +447,6 @@ impl AnyNode {
| AnyNode::ExprSlice(_) | AnyNode::ExprSlice(_)
| AnyNode::ExprLineMagic(_) | AnyNode::ExprLineMagic(_)
| AnyNode::ExceptHandlerExceptHandler(_) | AnyNode::ExceptHandlerExceptHandler(_)
| AnyNode::TypeIgnoreTypeIgnore(_)
| AnyNode::Comprehension(_) | AnyNode::Comprehension(_)
| AnyNode::Arguments(_) | AnyNode::Arguments(_)
| AnyNode::Arg(_) | AnyNode::Arg(_)
@ -541,97 +536,6 @@ impl AnyNode {
| AnyNode::PatternMatchStar(_) | AnyNode::PatternMatchStar(_)
| AnyNode::PatternMatchAs(_) | AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_) | AnyNode::PatternMatchOr(_)
| AnyNode::TypeIgnoreTypeIgnore(_)
| AnyNode::Comprehension(_)
| AnyNode::Arguments(_)
| AnyNode::Arg(_)
| AnyNode::ArgWithDefault(_)
| AnyNode::Keyword(_)
| AnyNode::Alias(_)
| AnyNode::WithItem(_)
| AnyNode::MatchCase(_)
| AnyNode::Decorator(_)
| AnyNode::TypeParamTypeVar(_)
| AnyNode::TypeParamTypeVarTuple(_)
| AnyNode::TypeParamParamSpec(_)
| AnyNode::ElifElseClause(_) => None,
}
}
pub fn type_ignore(self) -> Option<TypeIgnore> {
match self {
AnyNode::TypeIgnoreTypeIgnore(node) => Some(TypeIgnore::TypeIgnore(node)),
AnyNode::ModModule(_)
| AnyNode::ModInteractive(_)
| AnyNode::ModExpression(_)
| AnyNode::ModFunctionType(_)
| AnyNode::StmtFunctionDef(_)
| AnyNode::StmtAsyncFunctionDef(_)
| AnyNode::StmtClassDef(_)
| AnyNode::StmtReturn(_)
| AnyNode::StmtDelete(_)
| AnyNode::StmtTypeAlias(_)
| AnyNode::StmtAssign(_)
| AnyNode::StmtAugAssign(_)
| AnyNode::StmtAnnAssign(_)
| AnyNode::StmtFor(_)
| AnyNode::StmtAsyncFor(_)
| AnyNode::StmtWhile(_)
| AnyNode::StmtIf(_)
| AnyNode::StmtWith(_)
| AnyNode::StmtAsyncWith(_)
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
| AnyNode::StmtTryStar(_)
| AnyNode::StmtAssert(_)
| AnyNode::StmtImport(_)
| AnyNode::StmtImportFrom(_)
| AnyNode::StmtGlobal(_)
| AnyNode::StmtNonlocal(_)
| AnyNode::StmtExpr(_)
| AnyNode::StmtPass(_)
| AnyNode::StmtBreak(_)
| AnyNode::StmtContinue(_)
| AnyNode::StmtLineMagic(_)
| AnyNode::ExprBoolOp(_)
| AnyNode::ExprNamedExpr(_)
| AnyNode::ExprBinOp(_)
| AnyNode::ExprUnaryOp(_)
| AnyNode::ExprLambda(_)
| AnyNode::ExprIfExp(_)
| AnyNode::ExprDict(_)
| AnyNode::ExprSet(_)
| AnyNode::ExprListComp(_)
| AnyNode::ExprSetComp(_)
| AnyNode::ExprDictComp(_)
| AnyNode::ExprGeneratorExp(_)
| AnyNode::ExprAwait(_)
| AnyNode::ExprYield(_)
| AnyNode::ExprYieldFrom(_)
| AnyNode::ExprCompare(_)
| AnyNode::ExprCall(_)
| AnyNode::ExprFormattedValue(_)
| AnyNode::ExprJoinedStr(_)
| AnyNode::ExprConstant(_)
| AnyNode::ExprAttribute(_)
| AnyNode::ExprSubscript(_)
| AnyNode::ExprStarred(_)
| AnyNode::ExprName(_)
| AnyNode::ExprList(_)
| AnyNode::ExprTuple(_)
| AnyNode::ExprSlice(_)
| AnyNode::ExprLineMagic(_)
| AnyNode::PatternMatchValue(_)
| AnyNode::PatternMatchSingleton(_)
| AnyNode::PatternMatchSequence(_)
| AnyNode::PatternMatchMapping(_)
| AnyNode::PatternMatchClass(_)
| AnyNode::PatternMatchStar(_)
| AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_)
| AnyNode::ExceptHandlerExceptHandler(_)
| AnyNode::Comprehension(_) | AnyNode::Comprehension(_)
| AnyNode::Arguments(_) | AnyNode::Arguments(_)
| AnyNode::Arg(_) | AnyNode::Arg(_)
@ -668,10 +572,6 @@ impl AnyNode {
self.as_ref().is_except_handler() self.as_ref().is_except_handler()
} }
pub const fn is_type_ignore(&self) -> bool {
self.as_ref().is_type_ignore()
}
pub const fn as_ref(&self) -> AnyNodeRef { pub const fn as_ref(&self) -> AnyNodeRef {
match self { match self {
Self::ModModule(node) => AnyNodeRef::ModModule(node), Self::ModModule(node) => AnyNodeRef::ModModule(node),
@ -744,7 +644,6 @@ impl AnyNode {
Self::PatternMatchStar(node) => AnyNodeRef::PatternMatchStar(node), Self::PatternMatchStar(node) => AnyNodeRef::PatternMatchStar(node),
Self::PatternMatchAs(node) => AnyNodeRef::PatternMatchAs(node), Self::PatternMatchAs(node) => AnyNodeRef::PatternMatchAs(node),
Self::PatternMatchOr(node) => AnyNodeRef::PatternMatchOr(node), Self::PatternMatchOr(node) => AnyNodeRef::PatternMatchOr(node),
Self::TypeIgnoreTypeIgnore(node) => AnyNodeRef::TypeIgnoreTypeIgnore(node),
Self::Comprehension(node) => AnyNodeRef::Comprehension(node), Self::Comprehension(node) => AnyNodeRef::Comprehension(node),
Self::Arguments(node) => AnyNodeRef::Arguments(node), Self::Arguments(node) => AnyNodeRef::Arguments(node),
Self::Arg(node) => AnyNodeRef::Arg(node), Self::Arg(node) => AnyNodeRef::Arg(node),
@ -2755,34 +2654,6 @@ impl AstNode for ast::PatternMatchOr {
AnyNode::from(self) AnyNode::from(self)
} }
} }
impl AstNode for ast::TypeIgnoreTypeIgnore {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::TypeIgnoreTypeIgnore(node) = kind {
Some(node)
} else {
None
}
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::TypeIgnoreTypeIgnore(node) = kind {
Some(node)
} else {
None
}
}
fn as_any_node_ref(&self) -> AnyNodeRef {
AnyNodeRef::from(self)
}
fn into_any_node(self) -> AnyNode {
AnyNode::from(self)
}
}
impl AstNode for Comprehension { impl AstNode for Comprehension {
fn cast(kind: AnyNode) -> Option<Self> fn cast(kind: AnyNode) -> Option<Self>
@ -3226,14 +3097,6 @@ impl From<ExceptHandler> for AnyNode {
} }
} }
impl From<TypeIgnore> for AnyNode {
fn from(ignore: TypeIgnore) -> Self {
match ignore {
TypeIgnore::TypeIgnore(ignore) => AnyNode::TypeIgnoreTypeIgnore(ignore),
}
}
}
impl From<ast::ModModule> for AnyNode { impl From<ast::ModModule> for AnyNode {
fn from(node: ast::ModModule) -> Self { fn from(node: ast::ModModule) -> Self {
AnyNode::ModModule(node) AnyNode::ModModule(node)
@ -3660,12 +3523,6 @@ impl From<ast::PatternMatchOr> for AnyNode {
} }
} }
impl From<ast::TypeIgnoreTypeIgnore> for AnyNode {
fn from(node: ast::TypeIgnoreTypeIgnore) -> Self {
AnyNode::TypeIgnoreTypeIgnore(node)
}
}
impl From<Comprehension> for AnyNode { impl From<Comprehension> for AnyNode {
fn from(node: Comprehension) -> Self { fn from(node: Comprehension) -> Self {
AnyNode::Comprehension(node) AnyNode::Comprehension(node)
@ -3802,7 +3659,6 @@ impl Ranged for AnyNode {
AnyNode::PatternMatchStar(node) => node.range(), AnyNode::PatternMatchStar(node) => node.range(),
AnyNode::PatternMatchAs(node) => node.range(), AnyNode::PatternMatchAs(node) => node.range(),
AnyNode::PatternMatchOr(node) => node.range(), AnyNode::PatternMatchOr(node) => node.range(),
AnyNode::TypeIgnoreTypeIgnore(node) => node.range(),
AnyNode::Comprehension(node) => node.range(), AnyNode::Comprehension(node) => node.range(),
AnyNode::Arguments(node) => node.range(), AnyNode::Arguments(node) => node.range(),
AnyNode::Arg(node) => node.range(), AnyNode::Arg(node) => node.range(),
@ -3892,7 +3748,6 @@ pub enum AnyNodeRef<'a> {
PatternMatchStar(&'a ast::PatternMatchStar), PatternMatchStar(&'a ast::PatternMatchStar),
PatternMatchAs(&'a ast::PatternMatchAs), PatternMatchAs(&'a ast::PatternMatchAs),
PatternMatchOr(&'a ast::PatternMatchOr), PatternMatchOr(&'a ast::PatternMatchOr),
TypeIgnoreTypeIgnore(&'a ast::TypeIgnoreTypeIgnore),
Comprehension(&'a Comprehension), Comprehension(&'a Comprehension),
Arguments(&'a Arguments), Arguments(&'a Arguments),
Arg(&'a Arg), Arg(&'a Arg),
@ -3981,7 +3836,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::PatternMatchStar(node) => NonNull::from(*node).cast(), AnyNodeRef::PatternMatchStar(node) => NonNull::from(*node).cast(),
AnyNodeRef::PatternMatchAs(node) => NonNull::from(*node).cast(), AnyNodeRef::PatternMatchAs(node) => NonNull::from(*node).cast(),
AnyNodeRef::PatternMatchOr(node) => NonNull::from(*node).cast(), AnyNodeRef::PatternMatchOr(node) => NonNull::from(*node).cast(),
AnyNodeRef::TypeIgnoreTypeIgnore(node) => NonNull::from(*node).cast(),
AnyNodeRef::Comprehension(node) => NonNull::from(*node).cast(), AnyNodeRef::Comprehension(node) => NonNull::from(*node).cast(),
AnyNodeRef::Arguments(node) => NonNull::from(*node).cast(), AnyNodeRef::Arguments(node) => NonNull::from(*node).cast(),
AnyNodeRef::Arg(node) => NonNull::from(*node).cast(), AnyNodeRef::Arg(node) => NonNull::from(*node).cast(),
@ -4076,7 +3930,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::PatternMatchStar(_) => NodeKind::PatternMatchStar, AnyNodeRef::PatternMatchStar(_) => NodeKind::PatternMatchStar,
AnyNodeRef::PatternMatchAs(_) => NodeKind::PatternMatchAs, AnyNodeRef::PatternMatchAs(_) => NodeKind::PatternMatchAs,
AnyNodeRef::PatternMatchOr(_) => NodeKind::PatternMatchOr, AnyNodeRef::PatternMatchOr(_) => NodeKind::PatternMatchOr,
AnyNodeRef::TypeIgnoreTypeIgnore(_) => NodeKind::TypeIgnoreTypeIgnore,
AnyNodeRef::Comprehension(_) => NodeKind::Comprehension, AnyNodeRef::Comprehension(_) => NodeKind::Comprehension,
AnyNodeRef::Arguments(_) => NodeKind::Arguments, AnyNodeRef::Arguments(_) => NodeKind::Arguments,
AnyNodeRef::Arg(_) => NodeKind::Arg, AnyNodeRef::Arg(_) => NodeKind::Arg,
@ -4166,7 +4019,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::PatternMatchStar(_) | AnyNodeRef::PatternMatchStar(_)
| AnyNodeRef::PatternMatchAs(_) | AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_) | AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::TypeIgnoreTypeIgnore(_)
| AnyNodeRef::Comprehension(_) | AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_) | AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_) | AnyNodeRef::Arg(_)
@ -4256,7 +4108,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::PatternMatchStar(_) | AnyNodeRef::PatternMatchStar(_)
| AnyNodeRef::PatternMatchAs(_) | AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_) | AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::TypeIgnoreTypeIgnore(_)
| AnyNodeRef::Comprehension(_) | AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_) | AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_) | AnyNodeRef::Arg(_)
@ -4346,7 +4197,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::PatternMatchStar(_) | AnyNodeRef::PatternMatchStar(_)
| AnyNodeRef::PatternMatchAs(_) | AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_) | AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::TypeIgnoreTypeIgnore(_)
| AnyNodeRef::Comprehension(_) | AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_) | AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_) | AnyNodeRef::Arg(_)
@ -4436,7 +4286,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::ExprSlice(_) | AnyNodeRef::ExprSlice(_)
| AnyNodeRef::ExprLineMagic(_) | AnyNodeRef::ExprLineMagic(_)
| AnyNodeRef::ExceptHandlerExceptHandler(_) | AnyNodeRef::ExceptHandlerExceptHandler(_)
| AnyNodeRef::TypeIgnoreTypeIgnore(_)
| AnyNodeRef::Comprehension(_) | AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_) | AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_) | AnyNodeRef::Arg(_)
@ -4526,97 +4375,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::PatternMatchStar(_) | AnyNodeRef::PatternMatchStar(_)
| AnyNodeRef::PatternMatchAs(_) | AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_) | AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::TypeIgnoreTypeIgnore(_)
| AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_)
| AnyNodeRef::ArgWithDefault(_)
| AnyNodeRef::Keyword(_)
| AnyNodeRef::Alias(_)
| AnyNodeRef::WithItem(_)
| AnyNodeRef::MatchCase(_)
| AnyNodeRef::Decorator(_)
| AnyNodeRef::TypeParamTypeVar(_)
| AnyNodeRef::TypeParamTypeVarTuple(_)
| AnyNodeRef::TypeParamParamSpec(_)
| AnyNodeRef::ElifElseClause(_) => false,
}
}
pub const fn is_type_ignore(self) -> bool {
match self {
AnyNodeRef::TypeIgnoreTypeIgnore(_) => true,
AnyNodeRef::ModModule(_)
| AnyNodeRef::ModInteractive(_)
| AnyNodeRef::ModExpression(_)
| AnyNodeRef::ModFunctionType(_)
| AnyNodeRef::StmtFunctionDef(_)
| AnyNodeRef::StmtAsyncFunctionDef(_)
| AnyNodeRef::StmtClassDef(_)
| AnyNodeRef::StmtReturn(_)
| AnyNodeRef::StmtDelete(_)
| AnyNodeRef::StmtTypeAlias(_)
| AnyNodeRef::StmtAssign(_)
| AnyNodeRef::StmtAugAssign(_)
| AnyNodeRef::StmtAnnAssign(_)
| AnyNodeRef::StmtFor(_)
| AnyNodeRef::StmtAsyncFor(_)
| AnyNodeRef::StmtWhile(_)
| AnyNodeRef::StmtIf(_)
| AnyNodeRef::StmtWith(_)
| AnyNodeRef::StmtAsyncWith(_)
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
| AnyNodeRef::StmtTryStar(_)
| AnyNodeRef::StmtAssert(_)
| AnyNodeRef::StmtImport(_)
| AnyNodeRef::StmtImportFrom(_)
| AnyNodeRef::StmtGlobal(_)
| AnyNodeRef::StmtNonlocal(_)
| AnyNodeRef::StmtExpr(_)
| AnyNodeRef::StmtPass(_)
| AnyNodeRef::StmtBreak(_)
| AnyNodeRef::StmtContinue(_)
| AnyNodeRef::StmtLineMagic(_)
| AnyNodeRef::ExprBoolOp(_)
| AnyNodeRef::ExprNamedExpr(_)
| AnyNodeRef::ExprBinOp(_)
| AnyNodeRef::ExprUnaryOp(_)
| AnyNodeRef::ExprLambda(_)
| AnyNodeRef::ExprIfExp(_)
| AnyNodeRef::ExprDict(_)
| AnyNodeRef::ExprSet(_)
| AnyNodeRef::ExprListComp(_)
| AnyNodeRef::ExprSetComp(_)
| AnyNodeRef::ExprDictComp(_)
| AnyNodeRef::ExprGeneratorExp(_)
| AnyNodeRef::ExprAwait(_)
| AnyNodeRef::ExprYield(_)
| AnyNodeRef::ExprYieldFrom(_)
| AnyNodeRef::ExprCompare(_)
| AnyNodeRef::ExprCall(_)
| AnyNodeRef::ExprFormattedValue(_)
| AnyNodeRef::ExprJoinedStr(_)
| AnyNodeRef::ExprConstant(_)
| AnyNodeRef::ExprAttribute(_)
| AnyNodeRef::ExprSubscript(_)
| AnyNodeRef::ExprStarred(_)
| AnyNodeRef::ExprName(_)
| AnyNodeRef::ExprList(_)
| AnyNodeRef::ExprTuple(_)
| AnyNodeRef::ExprSlice(_)
| AnyNodeRef::ExprLineMagic(_)
| AnyNodeRef::PatternMatchValue(_)
| AnyNodeRef::PatternMatchSingleton(_)
| AnyNodeRef::PatternMatchSequence(_)
| AnyNodeRef::PatternMatchMapping(_)
| AnyNodeRef::PatternMatchClass(_)
| AnyNodeRef::PatternMatchStar(_)
| AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::ExceptHandlerExceptHandler(_)
| AnyNodeRef::Comprehension(_) | AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_) | AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_) | AnyNodeRef::Arg(_)
@ -5090,12 +4848,6 @@ impl<'a> From<&'a ast::PatternMatchOr> for AnyNodeRef<'a> {
} }
} }
impl<'a> From<&'a ast::TypeIgnoreTypeIgnore> for AnyNodeRef<'a> {
fn from(node: &'a ast::TypeIgnoreTypeIgnore) -> Self {
AnyNodeRef::TypeIgnoreTypeIgnore(node)
}
}
impl<'a> From<&'a Decorator> for AnyNodeRef<'a> { impl<'a> From<&'a Decorator> for AnyNodeRef<'a> {
fn from(node: &'a Decorator) -> Self { fn from(node: &'a Decorator) -> Self {
AnyNodeRef::Decorator(node) AnyNodeRef::Decorator(node)
@ -5237,14 +4989,6 @@ impl<'a> From<&'a ExceptHandler> for AnyNodeRef<'a> {
} }
} }
impl<'a> From<&'a TypeIgnore> for AnyNodeRef<'a> {
fn from(ignore: &'a TypeIgnore) -> Self {
match ignore {
TypeIgnore::TypeIgnore(ignore) => AnyNodeRef::TypeIgnoreTypeIgnore(ignore),
}
}
}
impl<'a> From<&'a Comprehension> for AnyNodeRef<'a> { impl<'a> From<&'a Comprehension> for AnyNodeRef<'a> {
fn from(node: &'a Comprehension) -> Self { fn from(node: &'a Comprehension) -> Self {
AnyNodeRef::Comprehension(node) AnyNodeRef::Comprehension(node)
@ -5359,7 +5103,6 @@ impl Ranged for AnyNodeRef<'_> {
AnyNodeRef::PatternMatchStar(node) => node.range(), AnyNodeRef::PatternMatchStar(node) => node.range(),
AnyNodeRef::PatternMatchAs(node) => node.range(), AnyNodeRef::PatternMatchAs(node) => node.range(),
AnyNodeRef::PatternMatchOr(node) => node.range(), AnyNodeRef::PatternMatchOr(node) => node.range(),
AnyNodeRef::TypeIgnoreTypeIgnore(node) => node.range(),
AnyNodeRef::Comprehension(node) => node.range(), AnyNodeRef::Comprehension(node) => node.range(),
AnyNodeRef::Arguments(node) => node.range(), AnyNodeRef::Arguments(node) => node.range(),
AnyNodeRef::Arg(node) => node.range(), AnyNodeRef::Arg(node) => node.range(),

35
crates/ruff_python_ast/src/nodes.rs
View file

@ -20,7 +20,6 @@ pub enum Mod {
pub struct ModModule { pub struct ModModule {
pub range: TextRange, pub range: TextRange,
pub body: Vec<Stmt>, pub body: Vec<Stmt>,
pub type_ignores: Vec<TypeIgnore>,
} }
impl From<ModModule> for Mod { impl From<ModModule> for Mod {
@ -2037,26 +2036,6 @@ impl From<PatternMatchOr> for Pattern {
} }
} }
/// See also [type_ignore](https://docs.python.org/3/library/ast.html#ast.type_ignore)
#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum TypeIgnore {
TypeIgnore(TypeIgnoreTypeIgnore),
}
/// See also [TypeIgnore](https://docs.python.org/3/library/ast.html#ast.TypeIgnore)
#[derive(Clone, Debug, PartialEq)]
pub struct TypeIgnoreTypeIgnore {
pub range: TextRange,
pub lineno: Int,
pub tag: String,
}
impl From<TypeIgnoreTypeIgnore> for TypeIgnore {
fn from(payload: TypeIgnoreTypeIgnore) -> Self {
TypeIgnore::TypeIgnore(payload)
}
}
/// See also [type_param](https://docs.python.org/3/library/ast.html#ast.type_param) /// See also [type_param](https://docs.python.org/3/library/ast.html#ast.type_param)
#[derive(Clone, Debug, PartialEq, is_macro::Is)] #[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum TypeParam { pub enum TypeParam {
@ -2993,18 +2972,6 @@ impl Ranged for crate::Pattern {
} }
} }
impl Ranged for crate::nodes::TypeIgnoreTypeIgnore {
fn range(&self) -> TextRange {
self.range
}
}
impl Ranged for crate::TypeIgnore {
fn range(&self) -> TextRange {
match self {
Self::TypeIgnore(node) => node.range(),
}
}
}
impl Ranged for crate::nodes::TypeParamTypeVar { impl Ranged for crate::nodes::TypeParamTypeVar {
fn range(&self) -> TextRange { fn range(&self) -> TextRange {
self.range self.range
@ -3055,5 +3022,5 @@ mod size_assertions {
assert_eq_size!(Expr, [u8; 80]); assert_eq_size!(Expr, [u8; 80]);
assert_eq_size!(Constant, [u8; 32]); assert_eq_size!(Constant, [u8; 32]);
assert_eq_size!(Pattern, [u8; 96]); assert_eq_size!(Pattern, [u8; 96]);
assert_eq_size!(Mod, [u8; 64]); assert_eq_size!(Mod, [u8; 48]);
} }

22
crates/ruff_python_ast/src/visitor/preorder.rs
View file

@ -1,7 +1,7 @@
use crate::{ use crate::{
self as ast, Alias, Arg, ArgWithDefault, Arguments, BoolOp, CmpOp, Comprehension, Constant, self as ast, Alias, Arg, ArgWithDefault, Arguments, BoolOp, CmpOp, Comprehension, Constant,
Decorator, ElifElseClause, ExceptHandler, Expr, Keyword, MatchCase, Mod, Operator, Pattern, Decorator, ElifElseClause, ExceptHandler, Expr, Keyword, MatchCase, Mod, Operator, Pattern,
Stmt, TypeIgnore, TypeParam, TypeParamTypeVar, UnaryOp, WithItem, Stmt, TypeParam, TypeParamTypeVar, UnaryOp, WithItem,
}; };
/// Visitor that traverses all nodes recursively in pre-order. /// Visitor that traverses all nodes recursively in pre-order.
@ -96,10 +96,6 @@ pub trait PreorderVisitor<'a> {
walk_body(self, body); walk_body(self, body);
} }
fn visit_type_ignore(&mut self, type_ignore: &'a TypeIgnore) {
walk_type_ignore(self, type_ignore);
}
fn visit_elif_else_clause(&mut self, elif_else_clause: &'a ElifElseClause) { fn visit_elif_else_clause(&mut self, elif_else_clause: &'a ElifElseClause) {
walk_elif_else_clause(self, elif_else_clause); walk_elif_else_clause(self, elif_else_clause);
} }
@ -110,15 +106,8 @@ where
V: PreorderVisitor<'a> + ?Sized, V: PreorderVisitor<'a> + ?Sized,
{ {
match module { match module {
Mod::Module(ast::ModModule { Mod::Module(ast::ModModule { body, range: _ }) => {
body,
range: _,
type_ignores,
}) => {
visitor.visit_body(body); visitor.visit_body(body);
for ignore in type_ignores {
visitor.visit_type_ignore(ignore);
}
} }
Mod::Interactive(ast::ModInteractive { body, range: _ }) => visitor.visit_body(body), Mod::Interactive(ast::ModInteractive { body, range: _ }) => visitor.visit_body(body),
Mod::Expression(ast::ModExpression { body, range: _ }) => visitor.visit_expr(body), Mod::Expression(ast::ModExpression { body, range: _ }) => visitor.visit_expr(body),
@ -941,13 +930,6 @@ where
} }
} }
#[inline]
pub fn walk_type_ignore<'a, V>(_visitor: &mut V, _type_ignore: &'a TypeIgnore)
where
V: PreorderVisitor<'a> + ?Sized,
{
}
pub fn walk_bool_op<'a, V>(_visitor: &mut V, _bool_op: &'a BoolOp) pub fn walk_bool_op<'a, V>(_visitor: &mut V, _bool_op: &'a BoolOp)
where where
V: PreorderVisitor<'a> + ?Sized, V: PreorderVisitor<'a> + ?Sized,

12
crates/ruff_python_ast/tests/preorder.rs
View file

@ -5,12 +5,12 @@ use insta::assert_snapshot;
use ruff_python_ast::node::AnyNodeRef; use ruff_python_ast::node::AnyNodeRef;
use ruff_python_ast::visitor::preorder::{ use ruff_python_ast::visitor::preorder::{
walk_alias, walk_arg, walk_arguments, walk_comprehension, walk_except_handler, walk_expr, walk_alias, walk_arg, walk_arguments, walk_comprehension, walk_except_handler, walk_expr,
walk_keyword, walk_match_case, walk_module, walk_pattern, walk_stmt, walk_type_ignore, walk_keyword, walk_match_case, walk_module, walk_pattern, walk_stmt, walk_type_param,
walk_type_param, walk_with_item, PreorderVisitor, walk_with_item, PreorderVisitor,
}; };
use ruff_python_ast::{ use ruff_python_ast::{
Alias, Arg, Arguments, BoolOp, CmpOp, Comprehension, Constant, ExceptHandler, Expr, Keyword, Alias, Arg, Arguments, BoolOp, CmpOp, Comprehension, Constant, ExceptHandler, Expr, Keyword,
MatchCase, Mod, Operator, Pattern, Stmt, TypeIgnore, TypeParam, UnaryOp, WithItem, MatchCase, Mod, Operator, Pattern, Stmt, TypeParam, UnaryOp, WithItem,
}; };
use ruff_python_parser::lexer::lex; use ruff_python_parser::lexer::lex;
use ruff_python_parser::{parse_tokens, Mode}; use ruff_python_parser::{parse_tokens, Mode};
@ -273,12 +273,6 @@ impl PreorderVisitor<'_> for RecordVisitor {
self.exit_node(); self.exit_node();
} }
fn visit_type_ignore(&mut self, type_ignore: &TypeIgnore) {
self.enter_node(type_ignore);
walk_type_ignore(self, type_ignore);
self.exit_node();
}
fn visit_type_param(&mut self, type_param: &TypeParam) { fn visit_type_param(&mut self, type_param: &TypeParam) {
self.enter_node(type_param); self.enter_node(type_param);
walk_type_param(self, type_param); walk_type_param(self, type_param);

6
crates/ruff_python_ast/tests/visitor.rs
View file

@ -144,11 +144,7 @@ where
V: Visitor<'a> + ?Sized, V: Visitor<'a> + ?Sized,
{ {
match module { match module {
ast::Mod::Module(ast::ModModule { ast::Mod::Module(ast::ModModule { body, range: _ }) => {
body,
range: _,
type_ignores: _,
}) => {
visitor.visit_body(body); visitor.visit_body(body);
} }
ast::Mod::Interactive(ast::ModInteractive { body, range: _ }) => { ast::Mod::Interactive(ast::ModInteractive { body, range: _ }) => {

40
crates/ruff_python_formatter/src/generated.rs
View file

@ -2657,46 +2657,6 @@ impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::PatternMatchOr {
} }
} }
impl FormatRule<ast::TypeIgnoreTypeIgnore, PyFormatContext<'_>>
for crate::other::type_ignore_type_ignore::FormatTypeIgnoreTypeIgnore
{
#[inline]
fn fmt(
&self,
node: &ast::TypeIgnoreTypeIgnore,
f: &mut Formatter<PyFormatContext<'_>>,
) -> FormatResult<()> {
FormatNodeRule::<ast::TypeIgnoreTypeIgnore>::fmt(self, node, f)
}
}
impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::TypeIgnoreTypeIgnore {
type Format<'a> = FormatRefWithRule<
'a,
ast::TypeIgnoreTypeIgnore,
crate::other::type_ignore_type_ignore::FormatTypeIgnoreTypeIgnore,
PyFormatContext<'ast>,
>;
fn format(&self) -> Self::Format<'_> {
FormatRefWithRule::new(
self,
crate::other::type_ignore_type_ignore::FormatTypeIgnoreTypeIgnore::default(),
)
}
}
impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::TypeIgnoreTypeIgnore {
type Format = FormatOwnedWithRule<
ast::TypeIgnoreTypeIgnore,
crate::other::type_ignore_type_ignore::FormatTypeIgnoreTypeIgnore,
PyFormatContext<'ast>,
>;
fn into_format(self) -> Self::Format {
FormatOwnedWithRule::new(
self,
crate::other::type_ignore_type_ignore::FormatTypeIgnoreTypeIgnore::default(),
)
}
}
impl FormatRule<ast::Comprehension, PyFormatContext<'_>> impl FormatRule<ast::Comprehension, PyFormatContext<'_>>
for crate::other::comprehension::FormatComprehension for crate::other::comprehension::FormatComprehension
{ {

8
crates/ruff_python_formatter/src/module/mod_module.rs
View file

@ -9,13 +9,7 @@ pub struct FormatModModule;
impl FormatNodeRule<ModModule> for FormatModModule { impl FormatNodeRule<ModModule> for FormatModModule {
fn fmt_fields(&self, item: &ModModule, f: &mut PyFormatter) -> FormatResult<()> { fn fmt_fields(&self, item: &ModModule, f: &mut PyFormatter) -> FormatResult<()> {
let ModModule { let ModModule { range: _, body } = item;
range: _,
body,
type_ignores,
} = item;
// https://docs.python.org/3/library/ast.html#ast-helpers
debug_assert!(type_ignores.is_empty());
write!( write!(
f, f,
[ [

1
crates/ruff_python_formatter/src/other/mod.rs
View file

@ -9,5 +9,4 @@ pub(crate) mod except_handler_except_handler;
pub(crate) mod identifier; pub(crate) mod identifier;
pub(crate) mod keyword; pub(crate) mod keyword;
pub(crate) mod match_case; pub(crate) mod match_case;
pub(crate) mod type_ignore_type_ignore;
pub(crate) mod with_item; pub(crate) mod with_item;

12
crates/ruff_python_formatter/src/other/type_ignore_type_ignore.rs
View file

@ -1,12 +0,0 @@
use crate::{not_yet_implemented, FormatNodeRule, PyFormatter};
use ruff_formatter::{write, Buffer, FormatResult};
use ruff_python_ast::TypeIgnoreTypeIgnore;
#[derive(Default)]
pub struct FormatTypeIgnoreTypeIgnore;
impl FormatNodeRule<TypeIgnoreTypeIgnore> for FormatTypeIgnoreTypeIgnore {
fn fmt_fields(&self, item: &TypeIgnoreTypeIgnore, f: &mut PyFormatter) -> FormatResult<()> {
write!(f, [not_yet_implemented(item)])
}
}

2
crates/ruff_python_parser/src/python.lalrpop
View file

@ -21,7 +21,7 @@ grammar(mode: Mode);
// For each public entry point, a full parse table is generated. // For each public entry point, a full parse table is generated.
// By having only a single pub function, we reduce this to one. // By having only a single pub function, we reduce this to one.
pub(crate) Top: ast::Mod = { pub(crate) Top: ast::Mod = {
<start:@L> StartModule <body:Program> <end:@R> => ast::ModModule { body, type_ignores: vec![], range: (start..end).into() }.into(), <start:@L> StartModule <body:Program> <end:@R> => ast::ModModule { body, range: (start..end).into() }.into(),
<start:@L> StartInteractive <body:Program> <end:@R> => ast::ModInteractive { body, range: (start..end).into() }.into(), <start:@L> StartInteractive <body:Program> <end:@R> => ast::ModInteractive { body, range: (start..end).into() }.into(),
<start:@L> StartExpression <body:TestList> ("\n")* <end:@R> => ast::ModExpression { body: Box::new(body), range: (start..end).into() }.into() <start:@L> StartExpression <body:TestList> ("\n")* <end:@R> => ast::ModExpression { body: Box::new(body), range: (start..end).into() }.into()
}; };

4
crates/ruff_python_parser/src/python.rs
View file

@ -1,5 +1,5 @@
// auto-generated: "lalrpop 0.20.0" // auto-generated: "lalrpop 0.20.0"
// sha3: bf0ea34f78939474a89bc0d4b6e7c14f370a2d2cd2ca8b98bd5aefdae0e1d5f1 // sha3: 76f8cd8ac95bef60488dc5962346273abca535cd4aa194edd11cda998a4b211e
use num_bigint::BigInt; use num_bigint::BigInt;
use ruff_text_size::TextSize; use ruff_text_size::TextSize;
use ruff_python_ast::{self as ast, Ranged, MagicKind}; use ruff_python_ast::{self as ast, Ranged, MagicKind};
@ -30770,7 +30770,7 @@ fn __action1<
(_, end, _): (TextSize, TextSize, TextSize), (_, end, _): (TextSize, TextSize, TextSize),
) -> ast::Mod ) -> ast::Mod
{ {
ast::ModModule { body, type_ignores: vec![], range: (start..end).into() }.into() ast::ModModule { body, range: (start..end).into() }.into()
} }
#[allow(unused_variables)] #[allow(unused_variables)]

1
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__jupyter_magic.snap
View file

@ -347,6 +347,5 @@ Module(
}, },
), ),
], ],
type_ignores: [],
}, },
) )