Merge branch 'main' into brent/syntax-decorators-39

Author: ntBre

Cargo.lock

@@ -15,7 +15,7 @@ use red_knot_project::watch::ProjectWatcher;
 use red_knot_project::{watch, Db};
 use red_knot_project::{ProjectDatabase, ProjectMetadata};
 use red_knot_server::run_server;
-use ruff_db::diagnostic::{Diagnostic, DisplayDiagnosticConfig, Severity};
+use ruff_db::diagnostic::{DisplayDiagnosticConfig, OldDiagnosticTrait, Severity};
 use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
 use salsa::plumbing::ZalsaDatabase;
 
@@ -354,8 +354,7 @@ enum MainLoopMessage {
     CheckWorkspace,
     CheckCompleted {
         /// The diagnostics that were found during the check.
-        result: Vec<Box<dyn Diagnostic>>,
-
+        result: Vec<Box<dyn OldDiagnosticTrait>>,
         revision: u64,
     },
     ApplyChanges(Vec<watch::ChangeEvent>),

crates/red_knot/src/main.rs

@@ -5,7 +5,7 @@ use crate::DEFAULT_LINT_REGISTRY;
 use crate::{Project, ProjectMetadata};
 use red_knot_python_semantic::lint::{LintRegistry, RuleSelection};
 use red_knot_python_semantic::{Db as SemanticDb, Program};
-use ruff_db::diagnostic::Diagnostic;
+use ruff_db::diagnostic::OldDiagnosticTrait;
 use ruff_db::files::{File, Files};
 use ruff_db::system::System;
 use ruff_db::vendored::VendoredFileSystem;
@@ -55,11 +55,11 @@ impl ProjectDatabase {
     }
 
     /// Checks all open files in the project and its dependencies.
-    pub fn check(&self) -> Result<Vec<Box<dyn Diagnostic>>, Cancelled> {
+    pub fn check(&self) -> Result<Vec<Box<dyn OldDiagnosticTrait>>, Cancelled> {
         self.with_db(|db| db.project().check(db))
     }
 
-    pub fn check_file(&self, file: File) -> Result<Vec<Box<dyn Diagnostic>>, Cancelled> {
+    pub fn check_file(&self, file: File) -> Result<Vec<Box<dyn OldDiagnosticTrait>>, Cancelled> {
         let _span = tracing::debug_span!("check_file", file=%file.path(self)).entered();
 
         self.with_db(|db| self.project().check_file(db, file))

crates/red_knot_project/src/db.rs

@@ -9,7 +9,7 @@ pub use metadata::{ProjectDiscoveryError, ProjectMetadata};
 use red_knot_python_semantic::lint::{LintRegistry, LintRegistryBuilder, RuleSelection};
 use red_knot_python_semantic::register_lints;
 use red_knot_python_semantic::types::check_types;
-use ruff_db::diagnostic::{Diagnostic, DiagnosticId, ParseDiagnostic, Severity, Span};
+use ruff_db::diagnostic::{DiagnosticId, OldDiagnosticTrait, OldParseDiagnostic, Severity, Span};
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
 use ruff_db::source::{source_text, SourceTextError};
@@ -163,22 +163,22 @@ impl Project {
     }
 
     /// Checks all open files in the project and its dependencies.
-    pub(crate) fn check(self, db: &ProjectDatabase) -> Vec<Box<dyn Diagnostic>> {
+    pub(crate) fn check(self, db: &ProjectDatabase) -> Vec<Box<dyn OldDiagnosticTrait>> {
         let project_span = tracing::debug_span!("Project::check");
         let _span = project_span.enter();
 
         tracing::debug!("Checking project '{name}'", name = self.name(db));
 
-        let mut diagnostics: Vec<Box<dyn Diagnostic>> = Vec::new();
+        let mut diagnostics: Vec<Box<dyn OldDiagnosticTrait>> = Vec::new();
         diagnostics.extend(self.settings_diagnostics(db).iter().map(|diagnostic| {
-            let diagnostic: Box<dyn Diagnostic> = Box::new(diagnostic.clone());
+            let diagnostic: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic.clone());
             diagnostic
         }));
 
         let files = ProjectFiles::new(db, self);
 
         diagnostics.extend(files.diagnostics().iter().cloned().map(|diagnostic| {
-            let diagnostic: Box<dyn Diagnostic> = Box::new(diagnostic);
+            let diagnostic: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic);
             diagnostic
         }));
 
@@ -207,12 +207,12 @@ impl Project {
         Arc::into_inner(result).unwrap().into_inner().unwrap()
     }
 
-    pub(crate) fn check_file(self, db: &dyn Db, file: File) -> Vec<Box<dyn Diagnostic>> {
+    pub(crate) fn check_file(self, db: &dyn Db, file: File) -> Vec<Box<dyn OldDiagnosticTrait>> {
         let mut file_diagnostics: Vec<_> = self
             .settings_diagnostics(db)
             .iter()
             .map(|diagnostic| {
-                let diagnostic: Box<dyn Diagnostic> = Box::new(diagnostic.clone());
+                let diagnostic: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic.clone());
                 diagnostic
             })
             .collect();
@@ -397,8 +397,8 @@ impl Project {
     }
 }
 
-fn check_file_impl(db: &dyn Db, file: File) -> Vec<Box<dyn Diagnostic>> {
-    let mut diagnostics: Vec<Box<dyn Diagnostic>> = Vec::new();
+fn check_file_impl(db: &dyn Db, file: File) -> Vec<Box<dyn OldDiagnosticTrait>> {
+    let mut diagnostics: Vec<Box<dyn OldDiagnosticTrait>> = Vec::new();
 
     // Abort checking if there are IO errors.
     let source = source_text(db.upcast(), file);
@@ -413,12 +413,13 @@ fn check_file_impl(db: &dyn Db, file: File) -> Vec<Box<dyn Diagnostic>> {
 
     let parsed = parsed_module(db.upcast(), file);
     diagnostics.extend(parsed.errors().iter().map(|error| {
-        let diagnostic: Box<dyn Diagnostic> = Box::new(ParseDiagnostic::new(file, error.clone()));
+        let diagnostic: Box<dyn OldDiagnosticTrait> =
+            Box::new(OldParseDiagnostic::new(file, error.clone()));
         diagnostic
     }));
 
     diagnostics.extend(check_types(db.upcast(), file).iter().map(|diagnostic| {
-        let boxed: Box<dyn Diagnostic> = Box::new(diagnostic.clone());
+        let boxed: Box<dyn OldDiagnosticTrait> = Box::new(diagnostic.clone());
         boxed
     }));
 
@@ -492,7 +493,7 @@ pub struct IOErrorDiagnostic {
     error: IOErrorKind,
 }
 
-impl Diagnostic for IOErrorDiagnostic {
+impl OldDiagnosticTrait for IOErrorDiagnostic {
     fn id(&self) -> DiagnosticId {
         DiagnosticId::Io
     }
@@ -524,7 +525,7 @@ mod tests {
     use crate::db::tests::TestDb;
     use crate::{check_file_impl, ProjectMetadata};
     use red_knot_python_semantic::types::check_types;
-    use ruff_db::diagnostic::Diagnostic;
+    use ruff_db::diagnostic::OldDiagnosticTrait;
     use ruff_db::files::system_path_to_file;
     use ruff_db::source::source_text;
     use ruff_db::system::{DbWithTestSystem, SystemPath, SystemPathBuf};

crates/red_knot_project/src/lib.rs

@@ -2,7 +2,7 @@ use crate::metadata::value::{RangedValue, RelativePathBuf, ValueSource, ValueSou
 use crate::Db;
 use red_knot_python_semantic::lint::{GetLintError, Level, LintSource, RuleSelection};
 use red_knot_python_semantic::{ProgramSettings, PythonPath, PythonPlatform, SearchPathSettings};
-use ruff_db::diagnostic::{Diagnostic, DiagnosticId, Severity, Span};
+use ruff_db::diagnostic::{DiagnosticId, OldDiagnosticTrait, Severity, Span};
 use ruff_db::files::system_path_to_file;
 use ruff_db::system::{System, SystemPath};
 use ruff_macros::Combine;
@@ -376,7 +376,7 @@ impl OptionDiagnostic {
     }
 }
 
-impl Diagnostic for OptionDiagnostic {
+impl OldDiagnosticTrait for OptionDiagnostic {
     fn id(&self) -> DiagnosticId {
         self.id
     }

crates/red_knot_project/src/metadata/options.rs

@@ -26,29 +26,126 @@ from typing import TYPE_CHECKING as TC
 reveal_type(TC)  # revealed: Literal[True]
 ```
 
-### Must originate from `typing`
+### `typing_extensions` re-export
 
-Make sure we only use our special handling for `typing.TYPE_CHECKING` and not for other constants
-with the same name:
+This should behave in the same way as `typing.TYPE_CHECKING`:
 
-`constants.py`:
+```py
+from typing_extensions import TYPE_CHECKING
+
+reveal_type(TYPE_CHECKING)  # revealed: Literal[True]
+```
+
+## User-defined `TYPE_CHECKING`
+
+If we set `TYPE_CHECKING = False` directly instead of importing it from the `typing` module, it will
+still be treated as `True` during type checking. This behavior is for compatibility with other major
+type checkers, e.g. mypy and pyright.
+
+### With no type annotation
+
+```py
+TYPE_CHECKING = False
+reveal_type(TYPE_CHECKING)  # revealed: Literal[True]
+if TYPE_CHECKING:
+    type_checking = True
+if not TYPE_CHECKING:
+    runtime = True
+
+# type_checking is treated as unconditionally assigned.
+reveal_type(type_checking)  # revealed: Literal[True]
+# error: [unresolved-reference]
+reveal_type(runtime)  # revealed: Unknown
+```
+
+### With a type annotation
+
+We can also define `TYPE_CHECKING` with a type annotation. The type must be one to which `bool` can
+be assigned. Even in this case, the type of `TYPE_CHECKING` is still inferred to be `Literal[True]`.
 
 ```py
 TYPE_CHECKING: bool = False
+reveal_type(TYPE_CHECKING)  # revealed: Literal[True]
+if TYPE_CHECKING:
+    type_checking = True
+if not TYPE_CHECKING:
+    runtime = True
+
+reveal_type(type_checking)  # revealed: Literal[True]
+# error: [unresolved-reference]
+reveal_type(runtime)  # revealed: Unknown
+```
+
+### Importing user-defined `TYPE_CHECKING`
+
+`constants.py`:
+
+```py
+TYPE_CHECKING = False
+```
+
+`stub.pyi`:
+
+```pyi
+TYPE_CHECKING: bool
+# or
+TYPE_CHECKING: bool = ...
 ```
 
 ```py
 from constants import TYPE_CHECKING
 
-reveal_type(TYPE_CHECKING)  # revealed: bool
+reveal_type(TYPE_CHECKING)  # revealed: Literal[True]
+
+from stub import TYPE_CHECKING
+
+reveal_type(TYPE_CHECKING)  # revealed: Literal[True]
 ```
 
-### `typing_extensions` re-export
+### Invalid assignment to `TYPE_CHECKING`
 
-This should behave in the same way as `typing.TYPE_CHECKING`:
+Only `False` can be assigned to `TYPE_CHECKING`; any assignment other than `False` will result in an
+error. A type annotation to which `bool` is not assignable is also an error.
 
 ```py
-from typing_extensions import TYPE_CHECKING
+from typing import Literal
 
-reveal_type(TYPE_CHECKING)  # revealed: Literal[True]
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING = True
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: bool = True
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: int = 1
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: str = "str"
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: str = False
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: Literal[False] = False
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: Literal[True] = False
+```
+
+The same rules apply in a stub file:
+
+```pyi
+from typing import Literal
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: str
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: str = False
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: Literal[False] = ...
+
+# error: [invalid-type-checking-constant]
+TYPE_CHECKING: object = "str"
 ```

crates/red_knot_python_semantic/resources/mdtest/known_constants.md

@@ -458,8 +458,14 @@ fn symbol_by_id<'db>(
             // a diagnostic if we see it being modified externally. In type inference, we
             // can assign a "narrow" type to it even if it is not *declared*. This means, we
             // do not have to call [`widen_type_for_undeclared_public_symbol`].
-            let is_considered_non_modifiable =
-                symbol_table(db, scope).symbol(symbol_id).name() == "__slots__";
+            //
+            // `TYPE_CHECKING` is a special variable that should only be assigned `False`
+            // at runtime, but is always considered `True` in type checking.
+            // See mdtest/known_constants.md#user-defined-type_checking for details.
+            let is_considered_non_modifiable = matches!(
+                symbol_table(db, scope).symbol(symbol_id).name().as_str(),
+                "__slots__" | "TYPE_CHECKING"
+            );
 
             widen_type_for_undeclared_public_symbol(db, inferred, is_considered_non_modifiable)
                 .into()
@@ -500,14 +506,6 @@ fn symbol_impl<'db>(
 ) -> Symbol<'db> {
     let _span = tracing::trace_span!("symbol", ?name).entered();
 
-    // We don't need to check for `typing_extensions` here, because `typing_extensions.TYPE_CHECKING`
-    // is just a re-export of `typing.TYPE_CHECKING`.
-    if name == "TYPE_CHECKING"
-        && file_to_module(db, scope.file(db))
-            .is_some_and(|module| module.is_known(KnownModule::Typing))
-    {
-        return Symbol::bound(Type::BooleanLiteral(true));
-    }
     if name == "platform"
         && file_to_module(db, scope.file(db))
             .is_some_and(|module| module.is_known(KnownModule::Sys))

crates/red_knot_python_semantic/src/symbol.rs

@@ -6,7 +6,7 @@ use crate::types::diagnostic::{
 };
 use crate::types::signatures::Parameter;
 use crate::types::{todo_type, CallableType, UnionType};
-use ruff_db::diagnostic::{SecondaryDiagnosticMessage, Span};
+use ruff_db::diagnostic::{OldSecondaryDiagnosticMessage, Span};
 use ruff_python_ast as ast;
 use ruff_text_size::Ranged;
 
@@ -388,7 +388,7 @@ impl<'db> CallBindingError<'db> {
                 if let Some(span) =
                     Self::parameter_span_from_index(context.db(), callable_ty, parameter.index)
                 {
-                    messages.push(SecondaryDiagnosticMessage::new(
+                    messages.push(OldSecondaryDiagnosticMessage::new(
                         span,
                         "parameter declared in function definition here",
                     ));

crates/red_knot_python_semantic/src/types/call/bind.rs

@@ -2,7 +2,7 @@ use std::fmt;
 
 use drop_bomb::DebugDropBomb;
 use ruff_db::{
-    diagnostic::{DiagnosticId, SecondaryDiagnosticMessage, Severity},
+    diagnostic::{DiagnosticId, OldSecondaryDiagnosticMessage, Severity},
     files::File,
 };
 use ruff_text_size::{Ranged, TextRange};
@@ -84,7 +84,7 @@ impl<'db> InferContext<'db> {
         lint: &'static LintMetadata,
         ranged: T,
         message: fmt::Arguments,
-        secondary_messages: Vec<SecondaryDiagnosticMessage>,
+        secondary_messages: Vec<OldSecondaryDiagnosticMessage>,
     ) where
         T: Ranged,
     {
@@ -136,7 +136,7 @@ impl<'db> InferContext<'db> {
         id: DiagnosticId,
         severity: Severity,
         message: fmt::Arguments,
-        secondary_messages: Vec<SecondaryDiagnosticMessage>,
+        secondary_messages: Vec<OldSecondaryDiagnosticMessage>,
     ) where
         T: Ranged,
     {