Implementation for new Jupyter Magic AST nodes

crates/ruff/src/rules/ruff/rules/unreachable.rs

@@ -671,11 +671,13 @@ impl<'stmt> BasicBlocksBuilder<'stmt> {
                         | Expr::Await(_)
                         | Expr::Yield(_)
                         | Expr::YieldFrom(_) => self.unconditional_next_block(after),
+                        Expr::LineMagic(_) => todo!(),
                     }
                 }
                 // The tough branches are done, here is an easy one.
                 Stmt::Return(_) => NextBlock::Terminate,
                 Stmt::TypeAlias(_) => todo!(),
+                Stmt::LineMagic(_) => todo!(),
             };
 
             // Include any statements in the block that don't divert the control flow.
@@ -922,6 +924,7 @@ fn needs_next_block(stmts: &[Stmt]) -> bool {
         | Stmt::TryStar(_)
         | Stmt::Assert(_) => true,
         Stmt::TypeAlias(_) => todo!(),
+        Stmt::LineMagic(_) => todo!(),
     }
 }
 
@@ -957,6 +960,7 @@ fn is_control_flow_stmt(stmt: &Stmt) -> bool {
         | Stmt::Break(_)
         | Stmt::Continue(_) => true,
         Stmt::TypeAlias(_) => todo!(),
+        Stmt::LineMagic(_) => todo!(),
     }
 }
 

crates/ruff_python_ast/src/comparable.rs

@@ -652,6 +652,12 @@ pub struct ExprSlice<'a> {
     step: Option<Box<ComparableExpr<'a>>>,
 }
 
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct ExprLineMagic<'a> {
+    kind: ast::MagicKind,
+    value: &'a str,
+}
+
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub enum ComparableExpr<'a> {
     BoolOp(ExprBoolOp<'a>),
@@ -681,6 +687,7 @@ pub enum ComparableExpr<'a> {
     List(ExprList<'a>),
     Tuple(ExprTuple<'a>),
     Slice(ExprSlice<'a>),
+    LineMagic(ExprLineMagic<'a>),
 }
 
 impl<'a> From<&'a Box<ast::Expr>> for Box<ComparableExpr<'a>> {
@@ -925,6 +932,14 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
                 upper: upper.as_ref().map(Into::into),
                 step: step.as_ref().map(Into::into),
             }),
+            ast::Expr::LineMagic(ast::ExprLineMagic {
+                kind,
+                value,
+                range: _range,
+            }) => Self::LineMagic(ExprLineMagic {
+                kind: *kind,
+                value: value.as_str(),
+            }),
         }
     }
 }
@@ -1155,6 +1170,12 @@ pub struct StmtExpr<'a> {
     value: ComparableExpr<'a>,
 }
 
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct StmtLineMagic<'a> {
+    kind: ast::MagicKind,
+    value: &'a str,
+}
+
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub enum ComparableStmt<'a> {
     FunctionDef(StmtFunctionDef<'a>),
@@ -1181,6 +1202,7 @@ pub enum ComparableStmt<'a> {
     ImportFrom(StmtImportFrom<'a>),
     Global(StmtGlobal<'a>),
     Nonlocal(StmtNonlocal<'a>),
+    LineMagic(StmtLineMagic<'a>),
     Expr(StmtExpr<'a>),
     Pass,
     Break,
@@ -1440,6 +1462,14 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
             }) => Self::Nonlocal(StmtNonlocal {
                 names: names.iter().map(ast::Identifier::as_str).collect(),
             }),
+            ast::Stmt::LineMagic(ast::StmtLineMagic {
+                kind,
+                value,
+                range: _range,
+            }) => Self::LineMagic(StmtLineMagic {
+                kind: *kind,
+                value: value.as_str(),
+            }),
             ast::Stmt::Expr(ast::StmtExpr {
                 value,
                 range: _range,

crates/ruff_python_ast/src/helpers.rs

@@ -262,6 +262,7 @@ where
                     .map_or(false, |value| any_over_expr(value, func))
         }
         Expr::Name(_) | Expr::Constant(_) => false,
+        Expr::LineMagic(_) => false,
     }
 }
 
@@ -564,6 +565,7 @@ where
             range: _range,
         }) => any_over_expr(value, func),
         Stmt::Pass(_) | Stmt::Break(_) | Stmt::Continue(_) => false,
+        Stmt::LineMagic(_) => false,
     }
 }