[syntax-errors] Store to or delete __debug__

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -551,14 +551,16 @@ impl SemanticSyntaxContext for Checker<'_> {
             | SemanticSyntaxErrorKind::DuplicateTypeParameter
             | SemanticSyntaxErrorKind::MultipleCaseAssignment(_)
             | SemanticSyntaxErrorKind::IrrefutableCasePattern(_)
+            | SemanticSyntaxErrorKind::WriteToDebug(_)
                 if self.settings.preview.is_enabled() =>
             {
                 self.semantic_errors.borrow_mut().push(error);
             }
             SemanticSyntaxErrorKind::ReboundComprehensionVariable
             | SemanticSyntaxErrorKind::DuplicateTypeParameter
             | SemanticSyntaxErrorKind::MultipleCaseAssignment(_)
-            | SemanticSyntaxErrorKind::IrrefutableCasePattern(_) => {}
+            | SemanticSyntaxErrorKind::IrrefutableCasePattern(_)
+            | SemanticSyntaxErrorKind::WriteToDebug(_) => {}
         }
     }
 }

crates/ruff_python_parser/resources/inline/err/debug_shadow_class.py

@@ -0,0 +1,2 @@
+class __debug__: ...  # class name
+class C[__debug__]: ...  # type parameter name

crates/ruff_python_parser/resources/inline/err/debug_shadow_function.py

@@ -0,0 +1,3 @@
+def __debug__(): ...  # function name
+def f[__debug__](): ...  # type parameter name
+def f(__debug__): ...  # parameter name

crates/ruff_python_parser/resources/inline/err/debug_shadow_import.py

@@ -0,0 +1,4 @@
+import __debug__
+import debug as __debug__
+from x import __debug__
+from x import debug as __debug__

crates/ruff_python_parser/resources/inline/err/debug_shadow_match.py

@@ -0,0 +1,2 @@
+match x:
+    case __debug__: ...

crates/ruff_python_parser/resources/inline/err/debug_shadow_try.py

@@ -0,0 +1,2 @@
+try: ...
+except Exception as __debug__: ...

crates/ruff_python_parser/resources/inline/err/debug_shadow_type_alias.py

@@ -0,0 +1,2 @@
+type __debug__ = list[int]  # visited as an Expr but still flagged
+type Debug[__debug__] = str

crates/ruff_python_parser/resources/inline/err/debug_shadow_with.py

@@ -0,0 +1 @@
+with open("foo.txt") as __debug__: ...

crates/ruff_python_parser/resources/inline/err/del_debug_py39.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.9"}
+del __debug__

crates/ruff_python_parser/resources/inline/err/write_to_debug_expr.py

@@ -0,0 +1,4 @@
+del __debug__
+del x, y, __debug__, z
+__debug__ = 1
+x, y, __debug__, z = 1, 2, 3, 4

crates/ruff_python_parser/resources/inline/ok/debug_rename_import.py

@@ -0,0 +1,3 @@
+import __debug__ as debug
+from __debug__ import Some
+from x import __debug__ as debug

crates/ruff_python_parser/resources/inline/ok/del_debug_py38.py

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.8"}
+del __debug__

crates/ruff_python_parser/resources/inline/ok/read_from_debug.py

@@ -0,0 +1,2 @@
+if __debug__: ...
+x = __debug__

crates/ruff_python_parser/src/parser/options.rs

@@ -34,6 +34,10 @@ impl ParseOptions {
         self.target_version = target_version;
         self
     }
+
+    pub fn target_version(&self) -> PythonVersion {
+        self.target_version
+    }
 }
 
 impl From<Mode> for ParseOptions {

crates/ruff_python_parser/src/semantic_errors.rs

@@ -9,7 +9,8 @@ use std::fmt::Display;
 use ruff_python_ast::{
     self as ast,
     visitor::{walk_expr, Visitor},
-    Expr, IrrefutablePatternKind, Pattern, PythonVersion, Stmt, StmtExpr, StmtImportFrom,
+    Expr, ExprContext, IrrefutablePatternKind, Pattern, PythonVersion, Stmt, StmtExpr,
+    StmtImportFrom,
 };
 use ruff_text_size::{Ranged, TextRange};
 use rustc_hash::FxHashSet;
@@ -74,6 +75,105 @@ impl SemanticSyntaxChecker {
             }
             _ => {}
         }
+
+        Self::debug_shadowing(stmt, ctx);
+    }
+
+    /// Check for [`SemanticSyntaxErrorKind::WriteToDebug`] in `stmt`.
+    fn debug_shadowing<Ctx: SemanticSyntaxContext>(stmt: &ast::Stmt, ctx: &Ctx) {
+        match stmt {
+            Stmt::FunctionDef(ast::StmtFunctionDef {
+                name,
+                type_params,
+                parameters,
+                ..
+            }) => {
+                // test_err debug_shadow_function
+                // def __debug__(): ...  # function name
+                // def f[__debug__](): ...  # type parameter name
+                // def f(__debug__): ...  # parameter name
+                Self::check_identifier(name, ctx);
+                if let Some(type_params) = type_params {
+                    for type_param in type_params.iter() {
+                        Self::check_identifier(type_param.name(), ctx);
+                    }
+                }
+                for parameter in parameters {
+                    Self::check_identifier(parameter.name(), ctx);
+                }
+            }
+            Stmt::ClassDef(ast::StmtClassDef {
+                name, type_params, ..
+            }) => {
+                // test_err debug_shadow_class
+                // class __debug__: ...  # class name
+                // class C[__debug__]: ...  # type parameter name
+                Self::check_identifier(name, ctx);
+                if let Some(type_params) = type_params {
+                    for type_param in type_params.iter() {
+                        Self::check_identifier(type_param.name(), ctx);
+                    }
+                }
+            }
+            Stmt::TypeAlias(ast::StmtTypeAlias {
+                type_params: Some(type_params),
+                ..
+            }) => {
+                // test_err debug_shadow_type_alias
+                // type __debug__ = list[int]  # visited as an Expr but still flagged
+                // type Debug[__debug__] = str
+                for type_param in type_params.iter() {
+                    Self::check_identifier(type_param.name(), ctx);
+                }
+            }
+            Stmt::Import(ast::StmtImport { names, .. })
+            | Stmt::ImportFrom(ast::StmtImportFrom { names, .. }) => {
+                // test_err debug_shadow_import
+                // import __debug__
+                // import debug as __debug__
+                // from x import __debug__
+                // from x import debug as __debug__
+
+                // test_ok debug_rename_import
+                // import __debug__ as debug
+                // from __debug__ import Some
+                // from x import __debug__ as debug
+                for name in names {
+                    match &name.asname {
+                        Some(asname) => Self::check_identifier(asname, ctx),
+                        None => Self::check_identifier(&name.name, ctx),
+                    }
+                }
+            }
+            Stmt::Try(ast::StmtTry { handlers, .. }) => {
+                // test_err debug_shadow_try
+                // try: ...
+                // except Exception as __debug__: ...
+                for handler in handlers
+                    .iter()
+                    .filter_map(ast::ExceptHandler::as_except_handler)
+                {
+                    if let Some(name) = &handler.name {
+                        Self::check_identifier(name, ctx);
+                    }
+                }
+            }
+            // test_err debug_shadow_with
+            // with open("foo.txt") as __debug__: ...
+            _ => {}
+        }
+    }
+
+    /// Check if `ident` is equal to `__debug__` and emit a
+    /// [`SemanticSyntaxErrorKind::WriteToDebug`] if so.
+    fn check_identifier<Ctx: SemanticSyntaxContext>(ident: &ast::Identifier, ctx: &Ctx) {
+        if ident.id == "__debug__" {
+            Self::add_error(
+                ctx,
+                SemanticSyntaxErrorKind::WriteToDebug(WriteToDebugKind::Store),
+                ident.range,
+            );
+        }
     }
 
     fn duplicate_type_parameter_name<Ctx: SemanticSyntaxContext>(
@@ -207,6 +307,51 @@ impl SemanticSyntaxChecker {
                 Self::check_generator_expr(key, generators, ctx);
                 Self::check_generator_expr(value, generators, ctx);
             }
+            Expr::Name(ast::ExprName {
+                range,
+                id,
+                ctx: expr_ctx,
+            }) => {
+                // test_err write_to_debug_expr
+                // del __debug__
+                // del x, y, __debug__, z
+                // __debug__ = 1
+                // x, y, __debug__, z = 1, 2, 3, 4
+
+                // test_err del_debug_py39
+                // # parse_options: {"target-version": "3.9"}
+                // del __debug__
+
+                // test_ok del_debug_py38
+                // # parse_options: {"target-version": "3.8"}
+                // del __debug__
+
+                // test_ok read_from_debug
+                // if __debug__: ...
+                // x = __debug__
+                if id == "__debug__" {
+                    match expr_ctx {
+                        ExprContext::Store => Self::add_error(
+                            ctx,
+                            SemanticSyntaxErrorKind::WriteToDebug(WriteToDebugKind::Store),
+                            *range,
+                        ),
+                        ExprContext::Del => {
+                            let version = ctx.python_version();
+                            if version >= PythonVersion::PY39 {
+                                Self::add_error(
+                                    ctx,
+                                    SemanticSyntaxErrorKind::WriteToDebug(
+                                        WriteToDebugKind::Delete(version),
+                                    ),
+                                    *range,
+                                );
+                            }
+                        }
+                        _ => {}
+                    };
+                }
+            }
             _ => {}
         }
     }
@@ -292,6 +437,12 @@ impl Display for SemanticSyntaxError {
                     f.write_str("wildcard makes remaining patterns unreachable")
                 }
             },
+            SemanticSyntaxErrorKind::WriteToDebug(kind) => match kind {
+                WriteToDebugKind::Store => f.write_str("cannot assign to `__debug__`"),
+                WriteToDebugKind::Delete(python_version) => {
+                    write!(f, "cannot delete `__debug__` on Python {python_version} (syntax was removed in 3.9)")
+                }
+            },
         }
     }
 }
@@ -370,6 +521,30 @@ pub enum SemanticSyntaxErrorKind {
     ///
     /// [Python reference]: https://docs.python.org/3/reference/compound_stmts.html#irrefutable-case-blocks
     IrrefutableCasePattern(IrrefutablePatternKind),
+
+    /// Represents a write to `__debug__`. This includes simple assignments and deletions as well
+    /// other kinds of statements that can introduce bindings, such as type parameters in functions,
+    /// classes, and aliases, `match` arms, and imports, among others.
+    ///
+    /// ## Examples
+    ///
+    /// ```python
+    /// del __debug__
+    /// __debug__ = False
+    /// def f(__debug__): ...
+    /// class C[__debug__]: ...
+    /// ```
+    ///
+    /// See [BPO 45000] for more information.
+    ///
+    /// [BPO 45000]: https://github.com/python/cpython/issues/89163
+    WriteToDebug(WriteToDebugKind),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum WriteToDebugKind {
+    Store,
+    Delete(PythonVersion),
 }
 
 /// Searches for the first named expression (`x := y`) rebinding one of the `iteration_variables` in
@@ -480,6 +655,10 @@ impl<'a, Ctx: SemanticSyntaxContext> MultipleCaseAssignmentVisitor<'a, Ctx> {
                 ident.range(),
             );
         }
+        // test_err debug_shadow_match
+        // match x:
+        //     case __debug__: ...
+        SemanticSyntaxChecker::check_identifier(ident, self.ctx);
     }
 }
 

crates/ruff_python_parser/tests/fixtures.rs

@@ -42,7 +42,7 @@ fn test_valid_syntax(input_path: &Path) {
     let options = extract_options(&source).unwrap_or_else(|| {
         ParseOptions::from(Mode::Module).with_target_version(PythonVersion::latest())
     });
-    let parsed = parse_unchecked(&source, options);
+    let parsed = parse_unchecked(&source, options.clone());
 
     if parsed.has_syntax_errors() {
         let line_index = LineIndex::from_source_text(&source);
@@ -88,7 +88,9 @@ fn test_valid_syntax(input_path: &Path) {
 
     let parsed = parsed.try_into_module().expect("Parsed with Mode::Module");
 
-    let mut visitor = SemanticSyntaxCheckerVisitor::new(TestContext::default());
+    let mut visitor = SemanticSyntaxCheckerVisitor::new(
+        TestContext::default().with_python_version(options.target_version()),
+    );
 
     for stmt in parsed.suite() {
         visitor.visit_stmt(stmt);
@@ -134,7 +136,7 @@ fn test_invalid_syntax(input_path: &Path) {
     let options = extract_options(&source).unwrap_or_else(|| {
         ParseOptions::from(Mode::Module).with_target_version(PythonVersion::latest())
     });
-    let parsed = parse_unchecked(&source, options);
+    let parsed = parse_unchecked(&source, options.clone());
 
     validate_tokens(parsed.tokens(), source.text_len(), input_path);
     validate_ast(parsed.syntax(), source.text_len(), input_path);
@@ -182,7 +184,9 @@ fn test_invalid_syntax(input_path: &Path) {
 
     let parsed = parsed.try_into_module().expect("Parsed with Mode::Module");
 
-    let mut visitor = SemanticSyntaxCheckerVisitor::new(TestContext::default());
+    let mut visitor = SemanticSyntaxCheckerVisitor::new(
+        TestContext::default().with_python_version(options.target_version()),
+    );
 
     for stmt in parsed.suite() {
         visitor.visit_stmt(stmt);
@@ -461,6 +465,15 @@ impl<'ast> SourceOrderVisitor<'ast> for ValidateAstVisitor<'ast> {
 #[derive(Debug, Default)]
 struct TestContext {
     diagnostics: RefCell<Vec<SemanticSyntaxError>>,
+    python_version: PythonVersion,
+}
+
+impl TestContext {
+    #[must_use]
+    fn with_python_version(mut self, python_version: PythonVersion) -> Self {
+        self.python_version = python_version;
+        self
+    }
 }
 
 impl SemanticSyntaxContext for TestContext {
@@ -469,7 +482,7 @@ impl SemanticSyntaxContext for TestContext {
     }
 
     fn python_version(&self) -> PythonVersion {
-        PythonVersion::default()
+        self.python_version
     }
 
     fn report_semantic_error(&self, error: SemanticSyntaxError) {