[red-knot] T is disjoint from ~T

Related to https://github.com/astral-sh/ruff-vscode/pull/684.

.github/workflows/ci.yaml

@@ -280,7 +280,7 @@ jobs:
 
   cargo-build-msrv:
     name: "cargo build (msrv)"
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-latest-8
     needs: determine_changes
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-test') && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 20

CHANGELOG.md

@@ -1,5 +1,64 @@
 # Changelog
 
+## 0.9.5
+
+### Preview features
+
+- Recognize all symbols named `TYPE_CHECKING` for `in_type_checking_block` ([#15719](https://github.com/astral-sh/ruff/pull/15719))
+- \[`flake8-comprehensions`\] Handle builtins at top of file correctly for `unnecessary-dict-comprehension-for-iterable` (`C420`) ([#15837](https://github.com/astral-sh/ruff/pull/15837))
+- \[`flake8-logging`\] `.exception()` and `exc_info=` outside exception handlers (`LOG004`, `LOG014`) ([#15799](https://github.com/astral-sh/ruff/pull/15799))
+- \[`flake8-pyi`\] Fix incorrect behaviour of `custom-typevar-return-type` preview-mode autofix if `typing` was already imported (`PYI019`) ([#15853](https://github.com/astral-sh/ruff/pull/15853))
+- \[`flake8-pyi`\] Fix more complex cases (`PYI019`) ([#15821](https://github.com/astral-sh/ruff/pull/15821))
+- \[`flake8-pyi`\] Make `PYI019` autofixable for `.py` files in preview mode as well as stubs ([#15889](https://github.com/astral-sh/ruff/pull/15889))
+- \[`flake8-pyi`\] Remove type parameter correctly when it is the last (`PYI019`) ([#15854](https://github.com/astral-sh/ruff/pull/15854))
+- \[`pylint`\] Fix missing parens in unsafe fix for `unnecessary-dunder-call` (`PLC2801`) ([#15762](https://github.com/astral-sh/ruff/pull/15762))
+- \[`pyupgrade`\] Better messages and diagnostic range (`UP015`) ([#15872](https://github.com/astral-sh/ruff/pull/15872))
+- \[`pyupgrade`\] Rename private type parameters in PEP 695 generics (`UP049`) ([#15862](https://github.com/astral-sh/ruff/pull/15862))
+- \[`refurb`\] Also report non-name expressions (`FURB169`) ([#15905](https://github.com/astral-sh/ruff/pull/15905))
+- \[`refurb`\] Mark fix as unsafe if there are comments (`FURB171`) ([#15832](https://github.com/astral-sh/ruff/pull/15832))
+- \[`ruff`\] Classes with mixed type variable style (`RUF053`) ([#15841](https://github.com/astral-sh/ruff/pull/15841))
+- \[`airflow`\] `BashOperator` has been moved to `airflow.providers.standard.operators.bash.BashOperator` (`AIR302`) ([#15922](https://github.com/astral-sh/ruff/pull/15922))
+- \[`flake8-pyi`\] Add autofix for unused-private-type-var (`PYI018`) ([#15999](https://github.com/astral-sh/ruff/pull/15999))
+- \[`flake8-pyi`\] Significantly improve accuracy of `PYI019` if preview mode is enabled ([#15888](https://github.com/astral-sh/ruff/pull/15888))
+
+### Rule changes
+
+- Preserve triple quotes and prefixes for strings ([#15818](https://github.com/astral-sh/ruff/pull/15818))
+- \[`flake8-comprehensions`\] Skip when `TypeError` present from too many (kw)args for `C410`,`C411`, and `C418` ([#15838](https://github.com/astral-sh/ruff/pull/15838))
+- \[`flake8-pyi`\] Rename `PYI019` and improve its diagnostic message ([#15885](https://github.com/astral-sh/ruff/pull/15885))
+- \[`pep8-naming`\] Ignore `@override` methods (`N803`) ([#15954](https://github.com/astral-sh/ruff/pull/15954))
+- \[`pyupgrade`\] Reuse replacement logic from `UP046` and `UP047` to preserve more comments (`UP040`) ([#15840](https://github.com/astral-sh/ruff/pull/15840))
+- \[`ruff`\] Analyze deferred annotations before enforcing `mutable-(data)class-default` and `function-call-in-dataclass-default-argument` (`RUF008`,`RUF009`,`RUF012`) ([#15921](https://github.com/astral-sh/ruff/pull/15921))
+- \[`pycodestyle`\] Exempt `sys.path += ...` calls (`E402`) ([#15980](https://github.com/astral-sh/ruff/pull/15980))
+
+### Configuration
+
+- Config error only when `flake8-import-conventions` alias conflicts with `isort.required-imports` bound name ([#15918](https://github.com/astral-sh/ruff/pull/15918))
+- Workaround Even Better TOML crash related to `allOf` ([#15992](https://github.com/astral-sh/ruff/pull/15992))
+
+### Bug fixes
+
+- \[`flake8-comprehensions`\] Unnecessary `list` comprehension (rewrite as a `set` comprehension) (`C403`) - Handle extraneous parentheses around list comprehension ([#15877](https://github.com/astral-sh/ruff/pull/15877))
+- \[`flake8-comprehensions`\] Handle trailing comma in fixes for `unnecessary-generator-list/set` (`C400`,`C401`) ([#15929](https://github.com/astral-sh/ruff/pull/15929))
+- \[`flake8-pyi`\] Fix several correctness issues with `custom-type-var-return-type` (`PYI019`) ([#15851](https://github.com/astral-sh/ruff/pull/15851))
+- \[`pep8-naming`\] Consider any number of leading underscore for `N801` ([#15988](https://github.com/astral-sh/ruff/pull/15988))
+- \[`pyflakes`\] Visit forward annotations in `TypeAliasType` as types (`F401`) ([#15829](https://github.com/astral-sh/ruff/pull/15829))
+- \[`pylint`\] Correct min/max auto-fix and suggestion for (`PL1730`) ([#15930](https://github.com/astral-sh/ruff/pull/15930))
+- \[`refurb`\] Handle unparenthesized tuples correctly (`FURB122`, `FURB142`) ([#15953](https://github.com/astral-sh/ruff/pull/15953))
+- \[`refurb`\] Avoid `None | None` as well as better detection and fix (`FURB168`) ([#15779](https://github.com/astral-sh/ruff/pull/15779))
+
+### Documentation
+
+- Add deprecation warning for `ruff-lsp` related settings ([#15850](https://github.com/astral-sh/ruff/pull/15850))
+- Docs (`linter.md`): clarify that Python files are always searched for in subdirectories ([#15882](https://github.com/astral-sh/ruff/pull/15882))
+- Fix a typo in `non_pep695_generic_class.rs` ([#15946](https://github.com/astral-sh/ruff/pull/15946))
+- Improve Docs: Pylint subcategories' codes ([#15909](https://github.com/astral-sh/ruff/pull/15909))
+- Remove non-existing `lint.extendIgnore` editor setting ([#15844](https://github.com/astral-sh/ruff/pull/15844))
+- Update black deviations ([#15928](https://github.com/astral-sh/ruff/pull/15928))
+- Mention `UP049` in `UP046` and `UP047`, add `See also` section to `UP040` ([#15956](https://github.com/astral-sh/ruff/pull/15956))
+- Add instance variable examples to `RUF012` ([#15982](https://github.com/astral-sh/ruff/pull/15982))
+- Explain precedence for `ignore` and `select` config ([#15883](https://github.com/astral-sh/ruff/pull/15883))
+
 ## 0.9.4
 
 ### Preview features

Cargo.lock

@@ -2439,6 +2439,7 @@ dependencies = [
  "ruff_text_size",
  "rustc-hash 2.1.0",
  "salsa",
+ "schemars",
  "serde",
  "thiserror 2.0.11",
  "toml",
@@ -2478,6 +2479,7 @@ dependencies = [
  "ruff_text_size",
  "rustc-hash 2.1.0",
  "salsa",
+ "schemars",
  "serde",
  "smallvec",
  "static_assertions",
@@ -2518,12 +2520,14 @@ dependencies = [
  "anyhow",
  "camino",
  "colored 3.0.0",
+ "insta",
  "memchr",
  "red_knot_python_semantic",
  "red_knot_vendored",
  "regex",
  "ruff_db",
  "ruff_index",
+ "ruff_python_ast",
  "ruff_python_trivia",
  "ruff_source_file",
  "ruff_text_size",
@@ -2638,7 +2642,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.9.4"
+version = "0.9.5"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2766,6 +2770,7 @@ dependencies = [
  "ruff_text_size",
  "rustc-hash 2.1.0",
  "salsa",
+ "schemars",
  "serde",
  "tempfile",
  "thiserror 2.0.11",
@@ -2790,6 +2795,7 @@ dependencies = [
  "libcst",
  "pretty_assertions",
  "rayon",
+ "red_knot_project",
  "regex",
  "ruff",
  "ruff_diagnostics",
@@ -2870,7 +2876,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.9.4"
+version = "0.9.5"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -3188,7 +3194,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.9.4"
+version = "0.9.5"
 dependencies = [
  "console_error_panic_hook",
  "console_log",

README.md

@@ -149,8 +149,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.9.4/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.9.4/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.9.5/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.9.5/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -183,7 +183,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.9.4
+  rev: v0.9.5
   hooks:
     # Run the linter.
     - id: ruff
@@ -452,6 +452,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - ING Bank ([popmon](https://github.com/ing-bank/popmon), [probatus](https://github.com/ing-bank/probatus))
 - [Ibis](https://github.com/ibis-project/ibis)
 - [ivy](https://github.com/unifyai/ivy)
+- [JAX](https://github.com/jax-ml/jax)
 - [Jupyter](https://github.com/jupyter-server/jupyter_server)
 - [Kraken Tech](https://kraken.tech/)
 - [LangChain](https://github.com/hwchase17/langchain)

crates/red_knot/tests/cli.rs

@@ -103,10 +103,10 @@ fn cli_arguments_are_relative_to_the_current_directory() -> anyhow::Result<()> {
     exit_code: 1
     ----- stdout -----
     error: lint:unresolved-import
-     --> <temp_dir>/child/test.py:2:1
+     --> <temp_dir>/child/test.py:2:6
       |
     2 | from utils import add
-      | ^^^^^^^^^^^^^^^^^^^^^ Cannot resolve import `utils`
+      |      ^^^^^ Cannot resolve import `utils`
     3 |
     4 | stat = add(10, 15)
       |

crates/red_knot_project/Cargo.toml

@@ -28,6 +28,7 @@ pep440_rs = { workspace = true }
 rayon = { workspace = true }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }
+schemars = { workspace = true, optional = true }
 serde = { workspace = true }
 thiserror = { workspace = true }
 toml = { workspace = true }
@@ -40,8 +41,9 @@ insta = { workspace = true, features = ["redactions", "ron"] }
 
 [features]
 default = ["zstd"]
-zstd = ["red_knot_vendored/zstd"]
 deflate = ["red_knot_vendored/deflate"]
+schemars = ["dep:schemars", "ruff_db/schemars", "red_knot_python_semantic/schemars"]
+zstd = ["red_knot_vendored/zstd"]
 
 [lints]
 workspace = true

crates/red_knot_project/src/metadata/options.rs

@@ -18,13 +18,16 @@ use thiserror::Error;
 /// The options for the project.
 #[derive(Debug, Default, Clone, PartialEq, Eq, Combine, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Options {
+    /// Configures the type checking environment.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub environment: Option<EnvironmentOptions>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub src: Option<SrcOptions>,
 
+    /// Configures the enabled lints and their severity.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub rules: Option<Rules>,
 }
@@ -177,10 +180,22 @@ impl Options {
 
 #[derive(Debug, Default, Clone, Eq, PartialEq, Combine, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct EnvironmentOptions {
+    /// Specifies the version of Python that will be used to execute the source code.
+    /// The version should be specified as a string in the format `M.m` where `M` is the major version
+    /// and `m` is the minor (e.g. "3.0" or "3.6").
+    /// If a version is provided, knot will generate errors if the source code makes use of language features
+    /// that are not supported in that version.
+    /// It will also tailor its use of type stub files, which conditionalizes type definitions based on the version.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub python_version: Option<RangedValue<PythonVersion>>,
 
+    /// Specifies the target platform that will be used to execute the source code.
+    /// If specified, Red Knot will tailor its use of type stub files,
+    /// which conditionalize type definitions based on the platform.
+    ///
+    /// If no platform is specified, knot will use `all` or the current platform in the LSP use case.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub python_platform: Option<RangedValue<PythonPlatform>>,
 
@@ -204,6 +219,7 @@ pub struct EnvironmentOptions {
 
 #[derive(Debug, Default, Clone, Eq, PartialEq, Combine, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct SrcOptions {
     /// The root of the project, used for finding first-party modules.
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -212,7 +228,9 @@ pub struct SrcOptions {
 
 #[derive(Debug, Default, Clone, Eq, PartialEq, Combine, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case", transparent)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Rules {
+    #[cfg_attr(feature = "schemars", schemars(with = "schema::Rules"))]
     inner: FxHashMap<RangedValue<String>, RangedValue<Level>>,
 }
 
@@ -226,6 +244,69 @@ impl FromIterator<(RangedValue<String>, RangedValue<Level>)> for Rules {
     }
 }
 
+#[cfg(feature = "schemars")]
+mod schema {
+    use crate::DEFAULT_LINT_REGISTRY;
+    use red_knot_python_semantic::lint::Level;
+    use schemars::gen::SchemaGenerator;
+    use schemars::schema::{
+        InstanceType, Metadata, ObjectValidation, Schema, SchemaObject, SubschemaValidation,
+    };
+    use schemars::JsonSchema;
+
+    pub(super) struct Rules;
+
+    impl JsonSchema for Rules {
+        fn schema_name() -> String {
+            "Rules".to_string()
+        }
+
+        fn json_schema(gen: &mut SchemaGenerator) -> Schema {
+            let registry = &*DEFAULT_LINT_REGISTRY;
+
+            let level_schema = gen.subschema_for::<Level>();
+
+            let properties: schemars::Map<String, Schema> = registry
+                .lints()
+                .iter()
+                .map(|lint| {
+                    (
+                        lint.name().to_string(),
+                        Schema::Object(SchemaObject {
+                            metadata: Some(Box::new(Metadata {
+                                title: Some(lint.summary().to_string()),
+                                description: Some(lint.documentation()),
+                                deprecated: lint.status.is_deprecated(),
+                                default: Some(lint.default_level.to_string().into()),
+                                ..Metadata::default()
+                            })),
+                            subschemas: Some(Box::new(SubschemaValidation {
+                                one_of: Some(vec![level_schema.clone()]),
+                                ..Default::default()
+                            })),
+                            ..Default::default()
+                        }),
+                    )
+                })
+                .collect();
+
+            Schema::Object(SchemaObject {
+                instance_type: Some(InstanceType::Object.into()),
+                object: Some(Box::new(ObjectValidation {
+                    properties,
+                    // Allow unknown rules: Red Knot will warn about them.
+                    // It gives a better experience when using an older Red Knot version because
+                    // the schema will not deny rules that have been removed in newer versions.
+                    additional_properties: Some(Box::new(level_schema)),
+                    ..ObjectValidation::default()
+                })),
+
+                ..Default::default()
+            })
+        }
+    }
+}
+
 #[derive(Error, Debug)]
 pub enum KnotTomlError {
     #[error(transparent)]

crates/red_knot_project/src/metadata/value.rs

@@ -1,8 +1,9 @@
 use crate::combine::Combine;
 use crate::Db;
 use ruff_db::system::{System, SystemPath, SystemPathBuf};
+use ruff_macros::Combine;
 use ruff_text_size::{TextRange, TextSize};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Deserializer};
 use std::cell::RefCell;
 use std::cmp::Ordering;
 use std::fmt;
@@ -70,15 +71,19 @@ impl Drop for ValueSourceGuard {
 ///
 /// This ensures that two resolved configurations are identical even if the position of a value has changed
 /// or if the values were loaded from different sources.
-#[derive(Clone)]
+#[derive(Clone, serde::Serialize)]
+#[serde(transparent)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct RangedValue<T> {
     value: T,
+    #[serde(skip)]
     source: ValueSource,
 
     /// The byte range of `value` in `source`.
     ///
     /// Can be `None` because not all sources support a range.
     /// For example, arguments provided on the CLI won't have a range attached.
+    #[serde(skip)]
     range: Option<TextRange>,
 }
 
@@ -266,18 +271,6 @@ where
     }
 }
 
-impl<T> Serialize for RangedValue<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.value.serialize(serializer)
-    }
-}
-
 /// A possibly relative path in a configuration file.
 ///
 /// Relative paths in configuration files or from CLI options
@@ -286,9 +279,19 @@ where
 /// * CLI: The path is relative to the current working directory
 /// * Configuration file: The path is relative to the project's root.
 #[derive(
-    Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash,
+    Debug,
+    Clone,
+    serde::Serialize,
+    serde::Deserialize,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    Combine,
 )]
 #[serde(transparent)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct RelativePathBuf(RangedValue<SystemPathBuf>);
 
 impl RelativePathBuf {
@@ -325,13 +328,3 @@ impl RelativePathBuf {
         SystemPath::absolute(&self.0, relative_to)
     }
 }
-
-impl Combine for RelativePathBuf {
-    fn combine(self, other: Self) -> Self {
-        Self(self.0.combine(other.0))
-    }
-
-    fn combine_with(&mut self, other: Self) {
-        self.0.combine_with(other.0);
-    }
-}

crates/red_knot_project/tests/check.rs

@@ -270,6 +270,8 @@ impl SourceOrderVisitor<'_> for PullTypesVisitor<'_> {
 /// Whether or not the .py/.pyi version of this file is expected to fail
 #[rustfmt::skip]
 const KNOWN_FAILURES: &[(&str, bool, bool)] = &[
+    // related to circular references in nested functions
+    ("crates/ruff_linter/resources/test/fixtures/flake8_return/RET503.py", false, true),
     // related to circular references in class definitions
     ("crates/ruff_linter/resources/test/fixtures/pyflakes/F821_26.py", true, true),
     ("crates/ruff_linter/resources/test/fixtures/pyflakes/F821_27.py", true, true),

crates/red_knot_python_semantic/Cargo.toml

@@ -36,6 +36,7 @@ thiserror = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }
 hashbrown = { workspace = true }
+schemars = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 smallvec = { workspace = true }
 static_assertions = { workspace = true }

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -210,6 +210,8 @@ def get_str() -> str:
     return "a"
 
 class C:
+    z: int
+
     def __init__(self) -> None:
         self.x = get_int()
         self.y: int = 1
@@ -220,12 +222,44 @@ class C:
         # TODO: this redeclaration should be an error
         self.y: str = "a"
 
+        # TODO: this redeclaration should be an error
+        self.z: str = "a"
+
 c_instance = C()
 
 reveal_type(c_instance.x)  # revealed: Unknown | int | str
-
-# TODO: We should probably infer `int | str` here.
 reveal_type(c_instance.y)  # revealed: int
+reveal_type(c_instance.z)  # revealed: int
+```
+
+#### Attributes defined in multi-target assignments
+
+```py
+class C:
+    def __init__(self) -> None:
+        self.a = self.b = 1
+
+c_instance = C()
+
+reveal_type(c_instance.a)  # revealed: Unknown | Literal[1]
+reveal_type(c_instance.b)  # revealed: Unknown | Literal[1]
+```
+
+#### Augmented assignments
+
+```py
+class Weird:
+    def __iadd__(self, other: None) -> str:
+        return "a"
+
+class C:
+    def __init__(self) -> None:
+        self.w = Weird()
+        self.w += None
+
+# TODO: Mypy and pyright do not support this, but it would be great if we could
+# infer `Unknown | str` or at least `Unknown | Weird | str` here.
+reveal_type(C().w)  # revealed: Unknown | Weird
 ```
 
 #### Attributes defined in tuple unpackings
@@ -249,19 +283,24 @@ reveal_type(c_instance.b1)  # revealed: Unknown | Literal["a"]
 reveal_type(c_instance.c1)  # revealed: Unknown | int
 reveal_type(c_instance.d1)  # revealed: Unknown | str
 
-# TODO: This should be supported (no error; type should be: `Unknown | Literal[1]`)
-# error: [unresolved-attribute]
-reveal_type(c_instance.a2)  # revealed: Unknown
+reveal_type(c_instance.a2)  # revealed: Unknown | Literal[1]
 
-# TODO: This should be supported (no error; type should be: `Unknown | Literal["a"]`)
-# error: [unresolved-attribute]
-reveal_type(c_instance.b2)  # revealed: Unknown
+reveal_type(c_instance.b2)  # revealed: Unknown | Literal["a"]
 
-# TODO: Similar for these two (should be `Unknown | int` and `Unknown | str`, respectively)
-# error: [unresolved-attribute]
-reveal_type(c_instance.c2)  # revealed: Unknown
-# error: [unresolved-attribute]
-reveal_type(c_instance.d2)  # revealed: Unknown
+reveal_type(c_instance.c2)  # revealed: Unknown | int
+reveal_type(c_instance.d2)  # revealed: Unknown | str
+```
+
+#### Starred assignments
+
+```py
+class C:
+    def __init__(self) -> None:
+        self.a, *self.b = (1, 2, 3)
+
+c_instance = C()
+reveal_type(c_instance.a)  # revealed: Unknown | Literal[1]
+reveal_type(c_instance.b)  # revealed: Unknown | @Todo(starred unpacking)
 ```
 
 #### Attributes defined in for-loop (unpacking)
@@ -283,6 +322,8 @@ class TupleIterable:
     def __iter__(self) -> TupleIterator:
         return TupleIterator()
 
+class NonIterable: ...
+
 class C:
     def __init__(self):
         for self.x in IntIterable():
@@ -291,14 +332,54 @@ class C:
         for _, self.y in TupleIterable():
             pass
 
-# TODO: Pyright fully supports these, mypy detects the presence of the attributes,
-# but infers type `Any` for both of them. We should infer `int` and `str` here:
+        # TODO: We should emit a diagnostic here
+        for self.z in NonIterable():
+            pass
 
-# error: [unresolved-attribute]
-reveal_type(C().x)  # revealed: Unknown
+reveal_type(C().x)  # revealed: Unknown | int
 
+reveal_type(C().y)  # revealed: Unknown | str
+```
+
+#### Attributes defined in `with` statements
+
+```py
+class ContextManager:
+    def __enter__(self) -> int | None: ...
+    def __exit__(self, exc_type, exc_value, traceback) -> None: ...
+
+class C:
+    def __init__(self) -> None:
+        with ContextManager() as self.x:
+            pass
+
+c_instance = C()
+
+# TODO: Should be `Unknown | int | None`
 # error: [unresolved-attribute]
-reveal_type(C().y)  # revealed: Unknown
+reveal_type(c_instance.x)  # revealed: Unknown
+```
+
+#### Attributes defined in comprehensions
+
+```py
+class IntIterator:
+    def __next__(self) -> int:
+        return 1
+
+class IntIterable:
+    def __iter__(self) -> IntIterator:
+        return IntIterator()
+
+class C:
+    def __init__(self) -> None:
+        [... for self.a in IntIterable()]
+
+c_instance = C()
+
+# TODO: Should be `Unknown | int`
+# error: [unresolved-attribute]
+reveal_type(c_instance.a)  # revealed: Unknown
 ```
 
 #### Conditionally declared / bound attributes
@@ -354,6 +435,73 @@ class C:
 reveal_type(C().declared_and_bound)  # revealed: Unknown
 ```
 
+#### Static methods do not influence implicitly defined attributes
+
+```py
+class Other:
+    x: int
+
+class C:
+    @staticmethod
+    def f(other: Other) -> None:
+        other.x = 1
+
+# error: [unresolved-attribute]
+reveal_type(C.x)  # revealed: Unknown
+
+# TODO: this should raise `unresolved-attribute` as well, and the type should be `Unknown`
+reveal_type(C().x)  # revealed: Unknown | Literal[1]
+
+# This also works if `staticmethod` is aliased:
+
+my_staticmethod = staticmethod
+
+class D:
+    @my_staticmethod
+    def f(other: Other) -> None:
+        other.x = 1
+
+# error: [unresolved-attribute]
+reveal_type(D.x)  # revealed: Unknown
+
+# TODO: this should raise `unresolved-attribute` as well, and the type should be `Unknown`
+reveal_type(D().x)  # revealed: Unknown | Literal[1]
+```
+
+If `staticmethod` is something else, that should not influence the behavior:
+
+```py
+def staticmethod(f):
+    return f
+
+class C:
+    @staticmethod
+    def f(self) -> None:
+        self.x = 1
+
+reveal_type(C().x)  # revealed: Unknown | Literal[1]
+```
+
+And if `staticmethod` is fully qualified, that should also be recognized:
+
+```py
+import builtins
+
+class Other:
+    x: int
+
+class C:
+    @builtins.staticmethod
+    def f(other: Other) -> None:
+        other.x = 1
+
+# error: [unresolved-attribute]
+reveal_type(C.x)  # revealed: Unknown
+
+# TODO: this should raise `unresolved-attribute` as well, and the type should be `Unknown`
+reveal_type(C().x)  # revealed: Unknown | Literal[1]
+```
+
 #### Attributes defined in statically-known-to-be-false branches
 
 ```py
@@ -372,6 +520,15 @@ class C:
 reveal_type(C().x)  # revealed: str
 ```
 
+#### Diagnostics are reported for the right-hand side of attribute assignments
+
+```py
+class C:
+    def __init__(self) -> None:
+        # error: [too-many-positional-arguments]
+        self.x: int = len(1, 2, 3)
+```
+
 ### Pure class variables (`ClassVar`)
 
 #### Annotated with `ClassVar` type qualifier
@@ -440,12 +597,12 @@ reveal_type(C.pure_class_variable)  # revealed: Unknown
 
 C.pure_class_variable = "overwritten on class"
 
-# TODO: should be `Literal["overwritten on class"]`
+# TODO: should be  `Unknown | Literal["value set in class method"]` or
+# Literal["overwritten on class"]`, once/if we support local narrowing.
 # error: [unresolved-attribute]
 reveal_type(C.pure_class_variable)  # revealed: Unknown
 
 c_instance = C()
-# TODO: should be `Literal["overwritten on class"]`
 reveal_type(c_instance.pure_class_variable)  # revealed: Unknown | Literal["value set in class method"]
 
 # TODO: should raise an error.
@@ -774,8 +931,6 @@ outer.nested.inner.Outer.Nested.Inner.attr = "a"
 Most attribute accesses on function-literal types are delegated to `types.FunctionType`, since all
 functions are instances of that class:
 
-`a.py`:
-
 ```py
 def f(): ...
 
@@ -785,11 +940,7 @@ reveal_type(f.__kwdefaults__)  # revealed: @Todo(generics) | None
 
 Some attributes are special-cased, however:
 
-`b.py`:
-
 ```py
-def f(): ...
-
 reveal_type(f.__get__)  # revealed: @Todo(`__get__` method on functions)
 reveal_type(f.__call__)  # revealed: @Todo(`__call__` method on functions)
 ```
@@ -799,8 +950,6 @@ reveal_type(f.__call__)  # revealed: @Todo(`__call__` method on functions)
 Most attribute accesses on int-literal types are delegated to `builtins.int`, since all literal
 integers are instances of that class:
 
-`a.py`:
-
 ```py
 reveal_type((2).bit_length)  # revealed: @Todo(bound method)
 reveal_type((2).denominator)  # revealed: @Todo(@property)
@@ -808,8 +957,6 @@ reveal_type((2).denominator)  # revealed: @Todo(@property)
 
 Some attributes are special-cased, however:
 
-`b.py`:
-
 ```py
 reveal_type((2).numerator)  # revealed: Literal[2]
 reveal_type((2).real)  # revealed: Literal[2]
@@ -820,8 +967,6 @@ reveal_type((2).real)  # revealed: Literal[2]
 Most attribute accesses on bool-literal types are delegated to `builtins.bool`, since all literal
 bols are instances of that class:
 
-`a.py`:
-
 ```py
 reveal_type(True.__and__)  # revealed: @Todo(bound method)
 reveal_type(False.__or__)  # revealed: @Todo(bound method)
@@ -829,8 +974,6 @@ reveal_type(False.__or__)  # revealed: @Todo(bound method)
 
 Some attributes are special-cased, however:
 
-`b.py`:
-
 ```py
 reveal_type(True.numerator)  # revealed: Literal[1]
 reveal_type(False.real)  # revealed: Literal[0]

crates/red_knot_python_semantic/resources/mdtest/comparison/tuples.md

@@ -33,8 +33,6 @@ reveal_type(a >= b)  # revealed: Literal[False]
 
 Even when tuples have different lengths, comparisons should be handled appropriately.
 
-`different_length.py`:
-
 ```py
 a = (1, 2, 3)
 b = (1, 2, 3, 4)
@@ -104,8 +102,6 @@ reveal_type(a >= b)  # revealed: bool
 However, if the lexicographic comparison completes without reaching a point where str and int are
 compared, Python will still produce a result based on the prior elements.
 
-`short_circuit.py`:
-
 ```py
 a = (1, 2)
 b = (999999, "hello")

crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -0,0 +1,199 @@
+# Descriptor protocol
+
+[Descriptors] let objects customize attribute lookup, storage, and deletion.
+
+A descriptor is an attribute value that has one of the methods in the descriptor protocol. Those
+methods are `__get__()`, `__set__()`, and `__delete__()`. If any of those methods are defined for an
+attribute, it is said to be a descriptor.
+
+## Basic example
+
+An introductory example, modeled after a [simple example] in the primer on descriptors, involving a
+descriptor that returns a constant value:
+
+```py
+from typing import Literal
+
+class Ten:
+    def __get__(self, instance: object, owner: type | None = None) -> Literal[10]:
+        return 10
+
+    def __set__(self, instance: object, value: Literal[10]) -> None:
+        pass
+
+class C:
+    ten = Ten()
+
+c = C()
+
+# TODO: this should be `Literal[10]`
+reveal_type(c.ten)  # revealed: Unknown | Ten
+
+# TODO: This should `Literal[10]`
+reveal_type(C.ten)  # revealed: Unknown | Ten
+
+# These are fine:
+c.ten = 10
+C.ten = 10
+
+# TODO: Both of these should be errors
+c.ten = 11
+C.ten = 11
+```
+
+## Different types for `__get__` and `__set__`
+
+The return type of `__get__` and the value type of `__set__` can be different:
+
+```py
+class FlexibleInt:
+    def __init__(self):
+        self._value: int | None = None
+
+    def __get__(self, instance: object, owner: type | None = None) -> int | None:
+        return self._value
+
+    def __set__(self, instance: object, value: int | str) -> None:
+        self._value = int(value)
+
+class C:
+    flexible_int = FlexibleInt()
+
+c = C()
+
+# TODO: should be `int | None`
+reveal_type(c.flexible_int)  # revealed: Unknown | FlexibleInt
+
+c.flexible_int = 42  # okay
+c.flexible_int = "42"  # also okay!
+
+# TODO: should be `int | None`
+reveal_type(c.flexible_int)  # revealed: Unknown | FlexibleInt
+
+# TODO: should be an error
+c.flexible_int = None  # not okay
+
+# TODO: should be `int | None`
+reveal_type(c.flexible_int)  # revealed: Unknown | FlexibleInt
+```
+
+## Built-in `property` descriptor
+
+The built-in `property` decorator creates a descriptor. The names for attribute reads/writes are
+determined by the return type of the `name` method and the parameter type of the setter,
+respectively.
+
+```py
+class C:
+    _name: str | None = None
+
+    @property
+    def name(self) -> str:
+        return self._name or "Unset"
+    # TODO: No diagnostic should be emitted here
+    # error: [unresolved-attribute] "Type `Literal[name]` has no attribute `setter`"
+    @name.setter
+    def name(self, value: str | None) -> None:
+        self._value = value
+
+c = C()
+
+reveal_type(c._name)  # revealed: str | None
+
+# Should be `str`
+reveal_type(c.name)  # revealed: @Todo(bound method)
+
+# Should be `builtins.property`
+reveal_type(C.name)  # revealed: Literal[name]
+
+# This is fine:
+c.name = "new"
+
+c.name = None
+
+# TODO: this should be an error
+c.name = 42
+```
+
+## Built-in `classmethod` descriptor
+
+Similarly to `property`, `classmethod` decorator creates an implicit descriptor that binds the first
+argument to the class instead of the instance.
+
+```py
+class C:
+    def __init__(self, value: str) -> None:
+        self._name: str = value
+
+    @classmethod
+    def factory(cls, value: str) -> "C":
+        return cls(value)
+
+    @classmethod
+    def get_name(cls) -> str:
+        return cls.__name__
+
+c1 = C.factory("test")  # okay
+
+# TODO: should be `C`
+reveal_type(c1)  # revealed: @Todo(return type)
+
+# TODO: should be `str`
+reveal_type(C.get_name())  # revealed: @Todo(return type)
+
+# TODO: should be `str`
+reveal_type(C("42").get_name())  # revealed: @Todo(bound method)
+```
+
+## Descriptors only work when used as class variables
+
+From the descriptor guide:
+
+> Descriptors only work when used as class variables. When put in instances, they have no effect.
+
+```py
+from typing import Literal
+
+class Ten:
+    def __get__(self, instance: object, owner: type | None = None) -> Literal[10]:
+        return 10
+
+class C:
+    def __init__(self):
+        self.ten = Ten()
+
+reveal_type(C().ten)  # revealed: Unknown | Ten
+```
+
+## Descriptors distinguishing between class and instance access
+
+Overloads can be used to distinguish between when a descriptor is accessed on a class object and
+when it is accessed on an instance. A real-world example of this is the `__get__` method on
+`types.FunctionType`.
+
+```py
+from typing_extensions import Literal, LiteralString, overload
+
+class Descriptor:
+    @overload
+    def __get__(self, instance: None, owner: type, /) -> Literal["called on class object"]: ...
+    @overload
+    def __get__(self, instance: object, owner: type | None = None, /) -> Literal["called on instance"]: ...
+    def __get__(self, instance, owner=None, /) -> LiteralString:
+        if instance:
+            return "called on instance"
+        else:
+            return "called on class object"
+
+class C:
+    d = Descriptor()
+
+# TODO: should be `Literal["called on class object"]
+reveal_type(C.d)  # revealed: Unknown | Descriptor
+
+# TODO: should be `Literal["called on instance"]
+reveal_type(C().d)  # revealed: Unknown | Descriptor
+```
+
+[descriptors]: https://docs.python.org/3/howto/descriptor.html
+[simple example]: https://docs.python.org/3/howto/descriptor.html#simple-example-a-descriptor-that-returns-a-constant

crates/red_knot_python_semantic/resources/mdtest/diagnostics/unpacking.md

@@ -0,0 +1,21 @@
+# Unpacking
+
+<!-- snapshot-diagnostics -->
+
+## Right hand side not iterable
+
+```py
+a, b = 1  # error: [not-iterable]
+```
+
+## Too many values to unpack
+
+```py
+a, b = (1, 2, 3)  # error: [invalid-assignment]
+```
+
+## Too few values to unpack
+
+```py
+a, b = (1,)  # error: [invalid-assignment]
+```

crates/red_knot_python_semantic/resources/mdtest/diagnostics/unresolved_import.md

@@ -0,0 +1,87 @@
+# Unresolved import diagnostics
+
+<!-- snapshot-diagnostics -->
+
+## Using `from` with an unresolvable module
+
+This example demonstrates the diagnostic when a `from` style import is used with a module that could
+not be found:
+
+```py
+from does_not_exist import add  # error: [unresolved-import]
+
+stat = add(10, 15)
+```
+
+## Using `from` with too many leading dots
+
+This example demonstrates the diagnostic when a `from` style import is used with a presumptively
+valid path, but where there are too many leading dots.
+
+`package/__init__.py`:
+
+```py
+```
+
+`package/foo.py`:
+
+```py
+def add(x, y):
+    return x + y
+```
+
+`package/subpackage/subsubpackage/__init__.py`:
+
+```py
+from ....foo import add  # error: [unresolved-import]
+
+stat = add(10, 15)
+```
+
+## Using `from` with an unknown current module
+
+This is another case handled separately in Red Knot, where a `.` provokes relative module name
+resolution, but where the module name is not resolvable.
+
+```py
+from .does_not_exist import add  # error: [unresolved-import]
+
+stat = add(10, 15)
+```
+
+## Using `from` with an unknown nested module
+
+Like the previous test, but with sub-modules to ensure the span is correct.
+
+```py
+from .does_not_exist.foo.bar import add  # error: [unresolved-import]
+
+stat = add(10, 15)
+```
+
+## Using `from` with a resolvable module but unresolvable item
+
+This ensures that diagnostics for an unresolvable item inside a resolvable import highlight the item
+and not the entire `from ... import ...` statement.
+
+`a.py`:
+
+```py
+does_exist1 = 1
+does_exist2 = 2
+```
+
+```py
+from a import does_exist1, does_not_exist, does_exist2  # error: [unresolved-import]
+```
+
+## An unresolvable import that does not use `from`
+
+This ensures that an unresolvable `import ...` statement highlights just the module name and not the
+entire statement.
+
+```py
+import does_not_exist  # error: [unresolved-import]
+
+x = does_not_exist.foo
+```

crates/red_knot_python_semantic/resources/mdtest/exception/basic.md

@@ -124,42 +124,49 @@ def _(e: Exception | type[Exception] | None):
 ## Exception cause is not an exception
 
 ```py
-try:
-    raise EOFError() from GeneratorExit  # fine
-except:
-    ...
+def _():
+    try:
+        raise EOFError() from GeneratorExit  # fine
+    except:
+        ...
 
-try:
-    raise StopIteration from MemoryError()  # fine
-except:
-    ...
+def _():
+    try:
+        raise StopIteration from MemoryError()  # fine
+    except:
+        ...
 
-try:
-    raise BufferError() from None  # fine
-except:
-    ...
+def _():
+    try:
+        raise BufferError() from None  # fine
+    except:
+        ...
 
-try:
-    raise ZeroDivisionError from False  # error: [invalid-raise]
-except:
-    ...
+def _():
+    try:
+        raise ZeroDivisionError from False  # error: [invalid-raise]
+    except:
+        ...
 
-try:
-    raise SystemExit from bool()  # error: [invalid-raise]
-except:
-    ...
+def _():
+    try:
+        raise SystemExit from bool()  # error: [invalid-raise]
+    except:
+        ...
 
-try:
-    raise
-except KeyboardInterrupt as e:  # fine
-    reveal_type(e)  # revealed: KeyboardInterrupt
-    raise LookupError from e  # fine
+def _():
+    try:
+        raise
+    except KeyboardInterrupt as e:  # fine
+        reveal_type(e)  # revealed: KeyboardInterrupt
+        raise LookupError from e  # fine
 
-try:
-    raise
-except int as e:  # error: [invalid-exception-caught]
-    reveal_type(e)  # revealed: Unknown
-    raise KeyError from e
+def _():
+    try:
+        raise
+    except int as e:  # error: [invalid-exception-caught]
+        reveal_type(e)  # revealed: Unknown
+        raise KeyError from e
 
 def _(e: Exception | type[Exception]):
     raise ModuleNotFoundError from e  # fine

crates/red_knot_python_semantic/resources/mdtest/exception/control_flow.md

@@ -29,8 +29,6 @@ completing. The type of `x` at the beginning of the `except` suite in this examp
 `x = could_raise_returns_str()` redefinition, but we *also* could have jumped to the `except` suite
 *after* that redefinition.
 
-`union_type_inferred.py`:
-
 ```py
 def could_raise_returns_str() -> str:
     return "foo"
@@ -52,12 +50,7 @@ reveal_type(x)  # revealed: str | Literal[2]
 If `x` has the same type at the end of both branches, however, the branches unify and `x` is not
 inferred as having a union type following the `try`/`except` block:
 
-`branches_unify_to_non_union_type.py`:
-
 ```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
 x = 1
 
 try:
@@ -137,8 +130,6 @@ the `except` suite:
 - At the end of `else`, `x == 3`
 - At the end of `except`, `x == 2`
 
-`single_except.py`:
-
 ```py
 def could_raise_returns_str() -> str:
     return "foo"
@@ -167,9 +158,6 @@ been executed in its entirety, or the `try` suite and the `else` suite must both
 in their entireties:
 
 ```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
 x = 1
 
 try:
@@ -198,8 +186,6 @@ A `finally` suite is *always* executed. As such, if we reach the `reveal_type` c
 this example, we know that `x` *must* have been reassigned to `2` during the `finally` suite. The
 type of `x` at the end of the example is therefore `Literal[2]`:
 
-`redef_in_finally.py`:
-
 ```py
 def could_raise_returns_str() -> str:
     return "foo"
@@ -225,12 +211,7 @@ at this point than there were when we were inside the `finally` block.
 (Our current model does *not* correctly infer the types *inside* `finally` suites, however; this is
 still a TODO item for us.)
 
-`no_redef_in_finally.py`:
-
 ```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
 x = 1
 
 try:
@@ -259,8 +240,6 @@ suites:
     exception raised in the `except` suite to cause us to jump to the `finally` suite before the
     `except` suite ran to completion
 
-`redef_in_finally.py`:
-
 ```py
 def could_raise_returns_str() -> str:
     return "foo"
@@ -298,18 +277,7 @@ itself. (In some control-flow possibilities, some exceptions were merely *suspen
 `finally` suite; these lead to the scope's termination following the conclusion of the `finally`
 suite.)
 
-`no_redef_in_finally.py`:
-
 ```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
 x = 1
 
 try:
@@ -331,18 +299,7 @@ reveal_type(x)  # revealed: str | bool
 
 An example with multiple `except` branches and a `finally` branch:
 
-`multiple_except_branches.py`:
-
 ```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
 def could_raise_returns_memoryview() -> memoryview:
     return memoryview(b"")
 
@@ -380,8 +337,6 @@ If the exception handler has an `else` branch, we must also take into account th
 control flow could have jumped to the `finally` suite from partway through the `else` suite due to
 an exception raised *there*.
 
-`single_except_branch.py`:
-
 ```py
 def could_raise_returns_str() -> str:
     return "foo"
@@ -425,24 +380,7 @@ reveal_type(x)  # revealed: bool | float
 
 The same again, this time with multiple `except` branches:
 
-`multiple_except_branches.py`:
-
 ```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
 def could_raise_returns_range() -> range:
     return range(42)
 

crates/red_knot_python_semantic/resources/mdtest/import/basic.md

@@ -116,8 +116,18 @@ reveal_type(c.C)  # revealed: Literal[C]
 class C: ...
 ```
 
+## Unresolvable module import
+
+<!-- snapshot-diagnostics -->
+
+```py
+import zqzqzqzqzqzqzq  # error: [unresolved-import] "Cannot resolve import `zqzqzqzqzqzqzq`"
+```
+
 ## Unresolvable submodule imports
 
+<!-- snapshot-diagnostics -->
+
 ```py
 # Topmost component resolvable, submodule not resolvable:
 import a.foo  # error: [unresolved-import] "Cannot resolve import `a.foo`"

crates/red_knot_python_semantic/resources/mdtest/import/relative.md

@@ -218,3 +218,21 @@ import package
 # error: [unresolved-attribute] "Type `<module 'package'>` has no attribute `foo`"
 reveal_type(package.foo.X)  # revealed: Unknown
 ```
+
+## Relative imports at the top of a search path
+
+Relative imports at the top of a search path result in a runtime error:
+`ImportError: attempted relative import with no known parent package`. That's why Red Knot should
+disallow them.
+
+`parser.py`:
+
+```py
+X: int = 42
+```
+
+`__main__.py`:
+
+```py
+from .parser import X  # error: [unresolved-import]
+```

crates/red_knot_python_semantic/resources/mdtest/scopes/builtin.md

@@ -13,7 +13,7 @@ if returns_bool():
     chr: int = 1
 
 def f():
-    reveal_type(chr)  # revealed: Literal[chr] | int
+    reveal_type(chr)  # revealed: int | Literal[chr]
 ```
 
 ## Conditionally global or builtin, with annotation
@@ -28,5 +28,5 @@ if returns_bool():
     chr: int = 1
 
 def f():
-    reveal_type(chr)  # revealed: Literal[chr] | int
+    reveal_type(chr)  # revealed: int | Literal[chr]
 ```

crates/red_knot_python_semantic/resources/mdtest/scopes/moduletype_attrs.md

@@ -29,8 +29,6 @@ def foo():
 However, three attributes on `types.ModuleType` are not present as implicit module globals; these
 are excluded:
 
-`unbound_dunders.py`:
-
 ```py
 # error: [unresolved-reference]
 # revealed: Unknown
@@ -56,10 +54,10 @@ inside the module:
 import typing
 
 reveal_type(typing.__name__)  # revealed: str
-reveal_type(typing.__init__)  # revealed: Literal[__init__]
+reveal_type(typing.__init__)  # revealed: @Todo(bound method)
 
 # These come from `builtins.object`, not `types.ModuleType`:
-reveal_type(typing.__eq__)  # revealed: Literal[__eq__]
+reveal_type(typing.__eq__)  # revealed: @Todo(bound method)
 
 reveal_type(typing.__class__)  # revealed: Literal[ModuleType]
 
@@ -72,11 +70,7 @@ Typeshed includes a fake `__getattr__` method in the stub for `types.ModuleType`
 dynamic imports; but we ignore that for module-literal types where we know exactly which module
 we're dealing with:
 
-`__getattr__.py`:
-
 ```py
-import typing
-
 # error: [unresolved-attribute]
 reveal_type(typing.__getattr__)  # revealed: Unknown
 ```

crates/red_knot_python_semantic/resources/mdtest/shadowing/function.md

@@ -5,8 +5,6 @@
 Parameter `x` of type `str` is shadowed and reassigned with a new `int` value inside the function.
 No diagnostics should be generated.
 
-`a.py`:
-
 ```py
 def f(x: str):
     x: int = int(x)
@@ -14,8 +12,6 @@ def f(x: str):
 
 ## Implicit error
 
-`a.py`:
-
 ```py
 def f(): ...
 
@@ -24,8 +20,6 @@ f = 1  # error: "Implicit shadowing of function `f`; annotate to make it explici
 
 ## Explicit shadowing
 
-`a.py`:
-
 ```py
 def f(): ...
 

crates/red_knot_python_semantic/resources/mdtest/snapshots/basic.md_-_Structures_-_Unresolvable_module_import.snap

@@ -0,0 +1,28 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: basic.md - Structures - Unresolvable module import
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/import/basic.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | import zqzqzqzqzqzqzq  # error: [unresolved-import] "Cannot resolve import `zqzqzqzqzqzqzq`"
+```
+
+# Diagnostics
+
+```
+error: lint:unresolved-import
+ --> /src/mdtest_snippet.py:1:8
+  |
+1 | import zqzqzqzqzqzqzq  # error: [unresolved-import] "Cannot resolve import `zqzqzqzqzqzqzq`"
+  |        ^^^^^^^^^^^^^^ Cannot resolve import `zqzqzqzqzqzqzq`
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/basic.md_-_Structures_-_Unresolvable_submodule_imports.snap

@@ -0,0 +1,51 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: basic.md - Structures - Unresolvable submodule imports
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/import/basic.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | # Topmost component resolvable, submodule not resolvable:
+2 | import a.foo  # error: [unresolved-import] "Cannot resolve import `a.foo`"
+3 | 
+4 | # Topmost component unresolvable:
+5 | import b.foo  # error: [unresolved-import] "Cannot resolve import `b.foo`"
+```
+
+## a/__init__.py
+
+```
+```
+
+# Diagnostics
+
+```
+error: lint:unresolved-import
+ --> /src/mdtest_snippet.py:2:8
+  |
+1 | # Topmost component resolvable, submodule not resolvable:
+2 | import a.foo  # error: [unresolved-import] "Cannot resolve import `a.foo`"
+  |        ^^^^^ Cannot resolve import `a.foo`
+3 |
+4 | # Topmost component unresolvable:
+  |
+
+```
+
+```
+error: lint:unresolved-import
+ --> /src/mdtest_snippet.py:5:8
+  |
+4 | # Topmost component unresolvable:
+5 | import b.foo  # error: [unresolved-import] "Cannot resolve import `b.foo`"
+  |        ^^^^^ Cannot resolve import `b.foo`
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unpacking.md_-_Unpacking_-_Right_hand_side_not_iterable.snap

@@ -0,0 +1,28 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unpacking.md - Unpacking - Right hand side not iterable
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unpacking.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | a, b = 1  # error: [not-iterable]
+```
+
+# Diagnostics
+
+```
+error: lint:not-iterable
+ --> /src/mdtest_snippet.py:1:8
+  |
+1 | a, b = 1  # error: [not-iterable]
+  |        ^ Object of type `Literal[1]` is not iterable
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unpacking.md_-_Unpacking_-_Too_few_values_to_unpack.snap

@@ -0,0 +1,28 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unpacking.md - Unpacking - Too few values to unpack
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unpacking.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | a, b = (1,)  # error: [invalid-assignment]
+```
+
+# Diagnostics
+
+```
+error: lint:invalid-assignment
+ --> /src/mdtest_snippet.py:1:1
+  |
+1 | a, b = (1,)  # error: [invalid-assignment]
+  | ^^^^ Not enough values to unpack (expected 2, got 1)
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unpacking.md_-_Unpacking_-_Too_many_values_to_unpack.snap

@@ -0,0 +1,28 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unpacking.md - Unpacking - Too many values to unpack
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unpacking.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | a, b = (1, 2, 3)  # error: [invalid-assignment]
+```
+
+# Diagnostics
+
+```
+error: lint:invalid-assignment
+ --> /src/mdtest_snippet.py:1:1
+  |
+1 | a, b = (1, 2, 3)  # error: [invalid-assignment]
+  | ^^^^ Too many values to unpack (expected 2, got 3)
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unresolved_import.md_-_Unresolved_import_diagnostics_-_An_unresolvable_import_that_does_not_use_`from`.snap

@@ -0,0 +1,32 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unresolved_import.md - Unresolved import diagnostics - An unresolvable import that does not use `from`
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unresolved_import.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | import does_not_exist  # error: [unresolved-import]
+2 | 
+3 | x = does_not_exist.foo
+```
+
+# Diagnostics
+
+```
+error: lint:unresolved-import
+ --> /src/mdtest_snippet.py:1:8
+  |
+1 | import does_not_exist  # error: [unresolved-import]
+  |        ^^^^^^^^^^^^^^ Cannot resolve import `does_not_exist`
+2 |
+3 | x = does_not_exist.foo
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unresolved_import.md_-_Unresolved_import_diagnostics_-_Using_`from`_with_a_resolvable_module_but_unresolvable_item.snap

@@ -0,0 +1,35 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unresolved_import.md - Unresolved import diagnostics - Using `from` with a resolvable module but unresolvable item
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unresolved_import.md
+---
+
+# Python source files
+
+## a.py
+
+```
+1 | does_exist1 = 1
+2 | does_exist2 = 2
+```
+
+## mdtest_snippet.py
+
+```
+1 | from a import does_exist1, does_not_exist, does_exist2  # error: [unresolved-import]
+```
+
+# Diagnostics
+
+```
+error: lint:unresolved-import
+ --> /src/mdtest_snippet.py:1:28
+  |
+1 | from a import does_exist1, does_not_exist, does_exist2  # error: [unresolved-import]
+  |                            ^^^^^^^^^^^^^^ Module `a` has no member `does_not_exist`
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unresolved_import.md_-_Unresolved_import_diagnostics_-_Using_`from`_with_an_unknown_current_module.snap

@@ -0,0 +1,32 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unresolved_import.md - Unresolved import diagnostics - Using `from` with an unknown current module
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unresolved_import.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | from .does_not_exist import add  # error: [unresolved-import]
+2 | 
+3 | stat = add(10, 15)
+```
+
+# Diagnostics
+
+```
+error: lint:unresolved-import
+ --> /src/mdtest_snippet.py:1:7
+  |
+1 | from .does_not_exist import add  # error: [unresolved-import]
+  |       ^^^^^^^^^^^^^^ Cannot resolve import `.does_not_exist`
+2 |
+3 | stat = add(10, 15)
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unresolved_import.md_-_Unresolved_import_diagnostics_-_Using_`from`_with_an_unknown_nested_module.snap

@@ -0,0 +1,32 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unresolved_import.md - Unresolved import diagnostics - Using `from` with an unknown nested module
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unresolved_import.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | from .does_not_exist.foo.bar import add  # error: [unresolved-import]
+2 | 
+3 | stat = add(10, 15)
+```
+
+# Diagnostics
+
+```
+error: lint:unresolved-import
+ --> /src/mdtest_snippet.py:1:7
+  |
+1 | from .does_not_exist.foo.bar import add  # error: [unresolved-import]
+  |       ^^^^^^^^^^^^^^^^^^^^^^ Cannot resolve import `.does_not_exist.foo.bar`
+2 |
+3 | stat = add(10, 15)
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unresolved_import.md_-_Unresolved_import_diagnostics_-_Using_`from`_with_an_unresolvable_module.snap

@@ -0,0 +1,32 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unresolved_import.md - Unresolved import diagnostics - Using `from` with an unresolvable module
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unresolved_import.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | from does_not_exist import add  # error: [unresolved-import]
+2 | 
+3 | stat = add(10, 15)
+```
+
+# Diagnostics
+
+```
+error: lint:unresolved-import
+ --> /src/mdtest_snippet.py:1:6
+  |
+1 | from does_not_exist import add  # error: [unresolved-import]
+  |      ^^^^^^^^^^^^^^ Cannot resolve import `does_not_exist`
+2 |
+3 | stat = add(10, 15)
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/snapshots/unresolved_import.md_-_Unresolved_import_diagnostics_-_Using_`from`_with_too_many_leading_dots.snap

@@ -0,0 +1,44 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: unresolved_import.md - Unresolved import diagnostics - Using `from` with too many leading dots
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/unresolved_import.md
+---
+
+# Python source files
+
+## package/__init__.py
+
+```
+```
+
+## package/foo.py
+
+```
+1 | def add(x, y):
+2 |     return x + y
+```
+
+## package/subpackage/subsubpackage/__init__.py
+
+```
+1 | from ....foo import add  # error: [unresolved-import]
+2 | 
+3 | stat = add(10, 15)
+```
+
+# Diagnostics
+
+```
+error: lint:unresolved-import
+ --> /src/package/subpackage/subsubpackage/__init__.py:1:10
+  |
+1 | from ....foo import add  # error: [unresolved-import]
+  |          ^^^ Cannot resolve import `....foo`
+2 |
+3 | stat = add(10, 15)
+  |
+
+```

crates/red_knot_python_semantic/resources/mdtest/statically_known_branches.md

@@ -7,43 +7,36 @@ branches whose conditions we can statically determine to be always true or alway
 useful for `sys.version_info` branches, which can make new features available based on the Python
 version:
 
-`module1.py`:
+If we can statically determine that the condition is always true, then we can also understand that
+`SomeFeature` is always bound, without raising any errors:
 
 ```py
 import sys
 
-if sys.version_info >= (3, 9):
-    SomeFeature: str = "available"
-```
+class C:
+    if sys.version_info >= (3, 9):
+        SomeFeature: str = "available"
 
-If we can statically determine that the condition is always true, then we can also understand that
-`SomeFeature` is always bound, without raising any errors:
-
-`test1.py`:
-
-```py
-from module1 import SomeFeature
-
-# SomeFeature is unconditionally available here, because we are on Python 3.9 or newer:
-reveal_type(SomeFeature)  # revealed: str
+# C.SomeFeature is unconditionally available here, because we are on Python 3.9 or newer:
+reveal_type(C.SomeFeature)  # revealed: str
 ```
 
 Another scenario where this is useful is for `typing.TYPE_CHECKING` branches, which are often used
 for conditional imports:
 
-`module2.py`:
+`module.py`:
 
 ```py
 class SomeType: ...
 ```
 
-`test2.py`:
+`main.py`:
 
 ```py
 import typing
 
 if typing.TYPE_CHECKING:
-    from module2 import SomeType
+    from module import SomeType
 
 # `SomeType` is unconditionally available here for type checkers:
 def f(s: SomeType) -> None: ...
@@ -1509,37 +1502,6 @@ if True:
 from module import symbol
 ```
 
-## Known limitations
-
-We currently have a limitation in the complexity (depth) of the visibility constraints that are
-supported. This is to avoid pathological cases that would require us to recurse deeply.
-
-```py
-x = 1
-
-False or False or False or False or \
-    False or False or False or False or \
-    False or False or False or False or \
-    False or False or False or False or \
-    False or False or False or False or \
-    False or False or (x := 2)  # fmt: skip
-
-# This still works fine:
-reveal_type(x)  # revealed: Literal[2]
-
-y = 1
-
-False or False or False or False or \
-    False or False or False or False or \
-    False or False or False or False or \
-    False or False or False or False or \
-    False or False or False or False or \
-    False or False or False or (y := 2)  # fmt: skip
-
-# TODO: This should ideally be `Literal[2]` as well:
-reveal_type(y)  # revealed: Literal[1, 2]
-```
-
 ## Unsupported features
 
 We do not support full unreachable code analysis yet. We also raise diagnostics from

crates/red_knot_python_semantic/resources/mdtest/suppressions/type_ignore.md

@@ -37,8 +37,6 @@ child expression now suppresses errors in the outer expression.
 For example, the `type: ignore` comment in this example suppresses the error of adding `2` to
 `"test"` and adding `"other"` to the result of the cast.
 
-`nested.py`:
-
 ```py
 # fmt: off
 from typing import cast

crates/red_knot_python_semantic/resources/mdtest/sys_version_info.md

@@ -109,8 +109,6 @@ reveal_type(version_info >= (3, 9))  # revealed: bool
 
 The fields of `sys.version_info` can be accessed by name:
 
-`a.py`:
-
 ```py
 import sys
 
@@ -122,11 +120,7 @@ reveal_type(sys.version_info.minor >= 10)  # revealed: Literal[False]
 But the `micro`, `releaselevel` and `serial` fields are inferred as `@Todo` until we support
 properties on instance types:
 
-`b.py`:
-
 ```py
-import sys
-
 reveal_type(sys.version_info.micro)  # revealed: @Todo(@property)
 reveal_type(sys.version_info.releaselevel)  # revealed: @Todo(@property)
 reveal_type(sys.version_info.serial)  # revealed: @Todo(@property)

crates/red_knot_python_semantic/resources/mdtest/terminal_statements.md

@@ -452,6 +452,9 @@ def raise_in_both_branches(cond: bool):
         # Exceptions can occur anywhere, so "before" and "raise" are valid possibilities
         reveal_type(x)  # revealed: Literal["before", "raise1", "raise2"]
     else:
+        # This branch is unreachable, since all control flows in the `try` clause raise exceptions.
+        # As a result, this binding should never be reachable, since new bindings are visible only
+        # when they are reachable.
         x = "unreachable"
     finally:
         # Exceptions can occur anywhere, so "before" and "raise" are valid possibilities
@@ -623,9 +626,9 @@ def return_from_nested_if(cond1: bool, cond2: bool):
 
 ## Statically known terminal statements
 
-Terminal statements do not yet interact correctly with statically known bounds. In this example, we
-should see that the `return` statement is always executed, and therefore that the `"b"` assignment
-is not visible to the `reveal_type`.
+We model reachability using the same visibility constraints that we use to model statically known
+bounds. In this example, we see that the `return` statement is always executed, and therefore that
+the `"b"` assignment is not visible to the `reveal_type`.
 
 ```py
 def _(cond: bool):
@@ -635,6 +638,26 @@ def _(cond: bool):
         if True:
             return
 
-    # TODO: Literal["a"]
-    reveal_type(x)  # revealed: Literal["a", "b"]
+    reveal_type(x)  # revealed: Literal["a"]
+```
+
+## Bindings after a terminal statement are unreachable
+
+Any bindings introduced after a terminal statement are unreachable, and are currently considered not
+visible. We [anticipate](https://github.com/astral-sh/ruff/issues/15797) that we want to provide a
+more useful analysis for code after terminal statements.
+
+```py
+def f(cond: bool) -> str:
+    x = "before"
+    if cond:
+        reveal_type(x)  # revealed: Literal["before"]
+        return
+        x = "after-return"
+        # TODO: no unresolved-reference error
+        # error: [unresolved-reference]
+        reveal_type(x)  # revealed: Unknown
+    else:
+        x = "else"
+    reveal_type(x)  # revealed: Literal["else"]
 ```

crates/red_knot_python_semantic/resources/mdtest/type_api.md

@@ -84,8 +84,11 @@ def explicit_unknown(x: Unknown, y: tuple[str, Unknown], z: Unknown = 1) -> None
     reveal_type(x)  # revealed: Unknown
     reveal_type(y)  # revealed: tuple[str, Unknown]
     reveal_type(z)  # revealed: Unknown | Literal[1]
+```
 
-# Unknown can be subclassed, just like Any
+`Unknown` can be subclassed, just like `Any`:
+
+```py
 class C(Unknown): ...
 
 # revealed: tuple[Literal[C], Unknown, Literal[object]]
@@ -238,9 +241,12 @@ error_message = "A custom message "
 error_message += "constructed from multiple string literals"
 # error: "Static assertion error: A custom message constructed from multiple string literals"
 static_assert(False, error_message)
+```
 
-# There are limitations to what we can still infer as a string literal. In those cases,
-# we simply fall back to the default message.
+There are limitations to what we can still infer as a string literal. In those cases, we simply fall
+back to the default message:
+
+```py
 shouted_message = "A custom message".upper()
 # error: "Static assertion error: argument evaluates to `False`"
 static_assert(False, shouted_message)
@@ -371,8 +377,11 @@ static_assert(is_subtype_of(TypeOf[str], type[str]))
 
 class Base: ...
 class Derived(Base): ...
+```
 
-# `TypeOf` can be used in annotations:
+`TypeOf` can also be used in annotations:
+
+```py
 def type_of_annotation() -> None:
     t1: TypeOf[Base] = Base
     t2: TypeOf[Base] = Derived  # error: [invalid-assignment]

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_disjoint_from.md

@@ -132,6 +132,27 @@ static_assert(not is_disjoint_from(Intersection[X, Z], Y))
 static_assert(not is_disjoint_from(Intersection[Y, Z], X))
 ```
 
+## Negation / complement
+
+The complement of a type `T` is disjoint from `T`. In fact, it is disjoint from every subtype of
+`T`:
+
+```py
+from knot_extensions import Not, Intersection, is_disjoint_from, static_assert
+
+class T: ...
+class S(T): ...
+
+static_assert(is_disjoint_from(Not[T], T))
+static_assert(is_disjoint_from(Not[T], S))
+
+static_assert(is_disjoint_from(Intersection[T, Any], Not[T]))
+static_assert(is_disjoint_from(Not[T], Intersection[T, Any]))
+
+static_assert(is_disjoint_from(Intersection[S, Any], Not[T]))
+static_assert(is_disjoint_from(Not[T], Intersection[S, Any]))
+```
+
 ## Special types
 
 ### `Never`
@@ -244,7 +265,7 @@ static_assert(not is_disjoint_from(TypeOf[f], object))
 ### `AlwaysTruthy` and `AlwaysFalsy`
 
 ```py
-from knot_extensions import AlwaysFalsy, AlwaysTruthy, is_disjoint_from, static_assert
+from knot_extensions import AlwaysFalsy, AlwaysTruthy, Intersection, Not, is_disjoint_from, static_assert
 from typing import Literal
 
 static_assert(is_disjoint_from(None, AlwaysTruthy))
@@ -256,6 +277,14 @@ static_assert(not is_disjoint_from(str, AlwaysTruthy))
 
 static_assert(is_disjoint_from(Literal[1, 2], AlwaysFalsy))
 static_assert(not is_disjoint_from(Literal[0, 1], AlwaysTruthy))
+
+type Truthy = Not[AlwaysFalsy]
+type Falsy = Not[AlwaysTruthy]
+
+type AmbiguousTruthiness = Intersection[Truthy, Falsy]
+
+static_assert(is_disjoint_from(AlwaysTruthy, AmbiguousTruthiness))
+static_assert(is_disjoint_from(AlwaysFalsy, AmbiguousTruthiness))
 ```
 
 ### Instance types versus `type[T]` types

crates/red_knot_python_semantic/resources/mdtest/type_properties/truthiness.md

@@ -1,5 +1,7 @@
 # Truthiness
 
+## Literals
+
 ```py
 from typing_extensions import Literal, LiteralString
 from knot_extensions import AlwaysFalsy, AlwaysTruthy
@@ -45,3 +47,31 @@ def _(
     reveal_type(bool(c))  # revealed: bool
     reveal_type(bool(d))  # revealed: bool
 ```
+
+## Instances
+
+Checks that we don't get into a cycle if someone sets their `__bool__` method to the `bool` builtin:
+
+### __bool__ is bool
+
+```py
+class BoolIsBool:
+    __bool__ = bool
+
+reveal_type(bool(BoolIsBool()))  # revealed: bool
+```
+
+### Conditional __bool__ method
+
+```py
+def flag() -> bool:
+    return True
+
+class Boom:
+    if flag():
+        __bool__ = bool
+    else:
+        __bool__ = int
+
+reveal_type(bool(Boom()))  # revealed: bool
+```

crates/red_knot_python_semantic/resources/mdtest/type_properties/tuples_containing_never.md

@@ -19,11 +19,17 @@ static_assert(is_equivalent_to(Never, tuple[int, Never]))
 static_assert(is_equivalent_to(Never, tuple[int, Never, str]))
 static_assert(is_equivalent_to(Never, tuple[int, tuple[str, Never]]))
 static_assert(is_equivalent_to(Never, tuple[tuple[str, Never], int]))
+```
 
-# The empty tuple is *not* equivalent to Never!
+The empty `tuple` is *not* equivalent to `Never`!
+
+```py
 static_assert(not is_equivalent_to(Never, tuple[()]))
+```
 
-# NoReturn is just a different spelling of Never, so the same is true for NoReturn
+`NoReturn` is just a different spelling of `Never`, so the same is true for `NoReturn`:
+
+```py
 static_assert(is_equivalent_to(NoReturn, tuple[NoReturn]))
 static_assert(is_equivalent_to(NoReturn, tuple[NoReturn, int]))
 static_assert(is_equivalent_to(NoReturn, tuple[int, NoReturn]))

crates/red_knot_python_semantic/resources/mdtest/unary/not.md

@@ -141,15 +141,6 @@ class AlwaysFalse:
 # revealed: Literal[True]
 reveal_type(not AlwaysFalse())
 
-# We don't get into a cycle if someone sets their `__bool__` method to the `bool` builtin:
-class BoolIsBool:
-    # TODO: The `type[bool]` declaration here is a workaround to avoid running into
-    # https://github.com/astral-sh/ruff/issues/15672
-    __bool__: type[bool] = bool
-
-# revealed: bool
-reveal_type(not BoolIsBool())
-
 # At runtime, no `__bool__` and no `__len__` means truthy, but we can't rely on that, because
 # a subclass could add a `__bool__` method.
 class NoBoolMethod: ...

crates/red_knot_python_semantic/src/lint.rs

@@ -1,6 +1,8 @@
+use core::fmt;
 use itertools::Itertools;
 use ruff_db::diagnostic::{DiagnosticId, LintName, Severity};
 use rustc_hash::FxHashMap;
+use std::fmt::Formatter;
 use std::hash::Hasher;
 use thiserror::Error;
 
@@ -36,13 +38,20 @@ pub struct LintMetadata {
     derive(serde::Serialize, serde::Deserialize),
     serde(rename_all = "kebab-case")
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum Level {
+    /// # Ignore
+    ///
     /// The lint is disabled and should not run.
     Ignore,
 
+    /// # Warn
+    ///
     /// The lint is enabled and diagnostic should have a warning severity.
     Warn,
 
+    /// # Error
+    ///
     /// The lint is enabled and diagnostics have an error severity.
     Error,
 }
@@ -61,6 +70,16 @@ impl Level {
     }
 }
 
+impl fmt::Display for Level {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Level::Ignore => f.write_str("ignore"),
+            Level::Warn => f.write_str("warn"),
+            Level::Error => f.write_str("error"),
+        }
+    }
+}
+
 impl TryFrom<Level> for Severity {
     type Error = ();
 
@@ -84,9 +103,11 @@ impl LintMetadata {
 
     /// Returns the documentation line by line with one leading space and all trailing whitespace removed.
     pub fn documentation_lines(&self) -> impl Iterator<Item = &str> {
-        self.raw_documentation
-            .lines()
-            .map(|line| line.strip_prefix(' ').unwrap_or(line).trim_end())
+        self.raw_documentation.lines().map(|line| {
+            line.strip_prefix(char::is_whitespace)
+                .unwrap_or(line)
+                .trim_end()
+        })
     }
 
     /// Returns the documentation as a single string.
@@ -180,6 +201,10 @@ impl LintStatus {
     pub const fn is_removed(&self) -> bool {
         matches!(self, LintStatus::Removed { .. })
     }
+
+    pub const fn is_deprecated(&self) -> bool {
+        matches!(self, LintStatus::Deprecated { .. })
+    }
 }
 
 /// Declares a lint rule with the given metadata.
@@ -223,7 +248,7 @@ macro_rules! declare_lint {
         $vis static $name: $crate::lint::LintMetadata = $crate::lint::LintMetadata {
             name: ruff_db::diagnostic::LintName::of(ruff_macros::kebab_case!($name)),
             summary: $summary,
-            raw_documentation: concat!($($doc,)+ "\n"),
+            raw_documentation: concat!($($doc, '\n',)+),
             status: $status,
             file: file!(),
             line: line!(),

crates/red_knot_python_semantic/src/python_platform.rs

@@ -11,6 +11,7 @@ pub enum PythonPlatform {
     /// Do not make any assumptions about the target platform.
     #[default]
     All,
+
     /// Assume a specific target platform like `linux`, `darwin` or `win32`.
     ///
     /// We use a string (instead of individual enum variants), as the set of possible platforms
@@ -28,3 +29,77 @@ impl Display for PythonPlatform {
         }
     }
 }
+
+#[cfg(feature = "schemars")]
+mod schema {
+    use crate::PythonPlatform;
+    use schemars::_serde_json::Value;
+    use schemars::gen::SchemaGenerator;
+    use schemars::schema::{Metadata, Schema, SchemaObject, SubschemaValidation};
+    use schemars::JsonSchema;
+
+    impl JsonSchema for PythonPlatform {
+        fn schema_name() -> String {
+            "PythonPlatform".to_string()
+        }
+
+        fn json_schema(_gen: &mut SchemaGenerator) -> Schema {
+            Schema::Object(SchemaObject {
+                // Hard code some well known values, but allow any other string as well.
+                subschemas: Some(Box::new(SubschemaValidation {
+                    any_of: Some(vec![
+                        Schema::Object(SchemaObject {
+                            instance_type: Some(schemars::schema::InstanceType::String.into()),
+                            ..SchemaObject::default()
+                        }),
+                        // Promote well-known values for better auto-completion.
+                        // Using `const` over `enumValues` as recommended [here](https://github.com/SchemaStore/schemastore/blob/master/CONTRIBUTING.md#documenting-enums).
+                        Schema::Object(SchemaObject {
+                            const_value: Some(Value::String("all".to_string())),
+                            metadata: Some(Box::new(Metadata {
+                                description: Some(
+                                    "Do not make any assumptions about the target platform."
+                                        .to_string(),
+                                ),
+                                ..Metadata::default()
+                            })),
+
+                            ..SchemaObject::default()
+                        }),
+                        Schema::Object(SchemaObject {
+                            const_value: Some(Value::String("darwin".to_string())),
+                            metadata: Some(Box::new(Metadata {
+                                description: Some("Darwin".to_string()),
+                                ..Metadata::default()
+                            })),
+
+                            ..SchemaObject::default()
+                        }),
+                        Schema::Object(SchemaObject {
+                            const_value: Some(Value::String("linux".to_string())),
+                            metadata: Some(Box::new(Metadata {
+                                description: Some("Linux".to_string()),
+                                ..Metadata::default()
+                            })),
+
+                            ..SchemaObject::default()
+                        }),
+                        Schema::Object(SchemaObject {
+                            const_value: Some(Value::String("win32".to_string())),
+                            metadata: Some(Box::new(Metadata {
+                                description: Some("Windows".to_string()),
+                                ..Metadata::default()
+                            })),
+
+                            ..SchemaObject::default()
+                        }),
+                    ]),
+
+                    ..SubschemaValidation::default()
+                })),
+
+                ..SchemaObject::default()
+            })
+        }
+    }
+}

crates/red_knot_python_semantic/src/python_version.rs

@@ -31,6 +31,20 @@ impl PythonVersion {
         minor: 13,
     };
 
+    pub fn iter() -> impl Iterator<Item = PythonVersion> {
+        [
+            PythonVersion::PY37,
+            PythonVersion::PY38,
+            PythonVersion::PY39,
+            PythonVersion::PY310,
+            PythonVersion::PY311,
+            PythonVersion::PY312,
+            PythonVersion::PY313,
+        ]
+        .iter()
+        .copied()
+    }
+
     pub fn free_threaded_build_available(self) -> bool {
         self >= PythonVersion::PY313
     }
@@ -69,40 +83,86 @@ impl fmt::Display for PythonVersion {
 }
 
 #[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for PythonVersion {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let as_str = String::deserialize(deserializer)?;
+mod serde {
+    use crate::PythonVersion;
 
-        if let Some((major, minor)) = as_str.split_once('.') {
-            let major = major
-                .parse()
-                .map_err(|err| serde::de::Error::custom(format!("invalid major version: {err}")))?;
-            let minor = minor
-                .parse()
-                .map_err(|err| serde::de::Error::custom(format!("invalid minor version: {err}")))?;
+    impl<'de> serde::Deserialize<'de> for PythonVersion {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: serde::Deserializer<'de>,
+        {
+            let as_str = String::deserialize(deserializer)?;
 
-            Ok((major, minor).into())
-        } else {
-            let major = as_str.parse().map_err(|err| {
-                serde::de::Error::custom(format!(
-                    "invalid python-version: {err}, expected: `major.minor`"
-                ))
-            })?;
+            if let Some((major, minor)) = as_str.split_once('.') {
+                let major = major.parse().map_err(|err| {
+                    serde::de::Error::custom(format!("invalid major version: {err}"))
+                })?;
+                let minor = minor.parse().map_err(|err| {
+                    serde::de::Error::custom(format!("invalid minor version: {err}"))
+                })?;
 
-            Ok((major, 0).into())
+                Ok((major, minor).into())
+            } else {
+                let major = as_str.parse().map_err(|err| {
+                    serde::de::Error::custom(format!(
+                        "invalid python-version: {err}, expected: `major.minor`"
+                    ))
+                })?;
+
+                Ok((major, 0).into())
+            }
+        }
+    }
+
+    impl serde::Serialize for PythonVersion {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer,
+        {
+            serializer.serialize_str(&self.to_string())
         }
     }
 }
 
-#[cfg(feature = "serde")]
-impl serde::Serialize for PythonVersion {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
+#[cfg(feature = "schemars")]
+mod schemars {
+    use super::PythonVersion;
+    use schemars::schema::{Metadata, Schema, SchemaObject, SubschemaValidation};
+    use schemars::JsonSchema;
+    use schemars::_serde_json::Value;
+
+    impl JsonSchema for PythonVersion {
+        fn schema_name() -> String {
+            "PythonVersion".to_string()
+        }
+
+        fn json_schema(_gen: &mut schemars::gen::SchemaGenerator) -> Schema {
+            let sub_schemas = std::iter::once(Schema::Object(SchemaObject {
+                instance_type: Some(schemars::schema::InstanceType::String.into()),
+                string: Some(Box::new(schemars::schema::StringValidation {
+                    pattern: Some(r"^\d+\.\d+$".to_string()),
+                    ..Default::default()
+                })),
+                ..Default::default()
+            }))
+            .chain(Self::iter().map(|v| {
+                Schema::Object(SchemaObject {
+                    const_value: Some(Value::String(v.to_string())),
+                    metadata: Some(Box::new(Metadata {
+                        description: Some(format!("Python {v}")),
+                        ..Metadata::default()
+                    })),
+                    ..SchemaObject::default()
+                })
+            }));
+
+            Schema::Object(SchemaObject {
+                subschemas: Some(Box::new(SubschemaValidation {
+                    any_of: Some(sub_schemas.collect()),
+                    ..Default::default()
+                })),
+                ..SchemaObject::default()
+            })
+        }
     }
 }

crates/red_knot_python_semantic/src/semantic_index/attribute_assignment.rs

@@ -1,4 +1,7 @@
-use crate::semantic_index::expression::Expression;
+use crate::{
+    semantic_index::{ast_ids::ScopedExpressionId, expression::Expression},
+    unpack::Unpack,
+};
 
 use ruff_python_ast::name::Name;
 
@@ -14,6 +17,17 @@ pub(crate) enum AttributeAssignment<'db> {
 
     /// An attribute assignment without a type annotation, e.g. `self.x = <value>`.
     Unannotated { value: Expression<'db> },
+
+    /// An attribute assignment where the right-hand side is an iterable, for example
+    /// `for self.x in <iterable>`.
+    Iterable { iterable: Expression<'db> },
+
+    /// An attribute assignment where the left-hand side is an unpacking expression,
+    /// e.g. `self.x, self.y = <value>`.
+    Unpack {
+        attribute_expression_id: ScopedExpressionId,
+        unpack: Unpack<'db>,
+    },
 }
 
 pub(crate) type AttributeAssignments<'db> = FxHashMap<Name, Vec<AttributeAssignment<'db>>>;

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -6,9 +6,9 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use ruff_db::files::File;
 use ruff_db::parsed::ParsedModule;
 use ruff_index::IndexVec;
-use ruff_python_ast as ast;
 use ruff_python_ast::name::Name;
 use ruff_python_ast::visitor::{walk_expr, walk_pattern, walk_stmt, Visitor};
+use ruff_python_ast::{self as ast, ExprContext};
 
 use crate::ast_node_ref::AstNodeRef;
 use crate::module_name::ModuleName;
@@ -793,9 +793,30 @@ where
                             &mut builder.current_first_parameter_name,
                             &mut first_parameter_name,
                         );
-                        builder.visit_body(body);
-                        builder.current_first_parameter_name = first_parameter_name;
 
+                        // TODO: Fix how we determine the public types of symbols in a
+                        // function-like scope: https://github.com/astral-sh/ruff/issues/15777
+                        //
+                        // In the meantime, visit the function body, but treat the last statement
+                        // specially if it is a return. If it is, this would cause all definitions
+                        // in the function to be marked as non-visible with our current treatment
+                        // of terminal statements. Since we currently model the externally visible
+                        // definitions in a function scope as the set of bindings that are visible
+                        // at the end of the body, we then consider this function to have no
+                        // externally visible definitions. To get around this, we take a flow
+                        // snapshot just before processing the return statement, and use _that_ as
+                        // the "end-of-body" state that we resolve external references against.
+                        if let Some((last_stmt, first_stmts)) = body.split_last() {
+                            builder.visit_body(first_stmts);
+                            let pre_return_state = matches!(last_stmt, ast::Stmt::Return(_))
+                                .then(|| builder.flow_snapshot());
+                            builder.visit_stmt(last_stmt);
+                            if let Some(pre_return_state) = pre_return_state {
+                                builder.flow_restore(pre_return_state);
+                            }
+                        }
+
+                        builder.current_first_parameter_name = first_parameter_name;
                         builder.pop_scope()
                     },
                 );
@@ -1210,6 +1231,20 @@ where
                         unpack: None,
                         first: false,
                     }),
+                    ast::Expr::Attribute(ast::ExprAttribute {
+                        value: object,
+                        attr,
+                        ..
+                    }) => {
+                        self.register_attribute_assignment(
+                            object,
+                            attr,
+                            AttributeAssignment::Iterable {
+                                iterable: iter_expr,
+                            },
+                        );
+                        None
+                    }
                     _ => None,
                 };
 
@@ -1438,7 +1473,7 @@ where
     fn visit_expr(&mut self, expr: &'ast ast::Expr) {
         self.scopes_by_expression
             .insert(expr.into(), self.current_scope());
-        self.current_ast_ids().record_expression(expr);
+        let expression_id = self.current_ast_ids().record_expression(expr);
 
         match expr {
             ast::Expr::Name(name_node @ ast::ExprName { id, ctx, .. }) => {
@@ -1697,6 +1732,35 @@ where
 
                 self.simplify_visibility_constraints(pre_op);
             }
+            ast::Expr::Attribute(ast::ExprAttribute {
+                value: object,
+                attr,
+                ctx: ExprContext::Store,
+                range: _,
+            }) => {
+                if let Some(
+                    CurrentAssignment::Assign {
+                        unpack: Some(unpack),
+                        ..
+                    }
+                    | CurrentAssignment::For {
+                        unpack: Some(unpack),
+                        ..
+                    },
+                ) = self.current_assignment()
+                {
+                    self.register_attribute_assignment(
+                        object,
+                        attr,
+                        AttributeAssignment::Unpack {
+                            attribute_expression_id: expression_id,
+                            unpack,
+                        },
+                    );
+                }
+
+                walk_expr(self, expr);
+            }
             _ => {
                 walk_expr(self, expr);
             }

crates/red_knot_python_semantic/src/semantic_index/constraint.rs

@@ -5,20 +5,20 @@ use crate::db::Db;
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId};
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub(crate) struct Constraint<'db> {
     pub(crate) node: ConstraintNode<'db>,
     pub(crate) is_positive: bool,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub(crate) enum ConstraintNode<'db> {
     Expression(Expression<'db>),
     Pattern(PatternConstraint<'db>),
 }
 
 /// Pattern kinds for which we support type narrowing and/or static visibility analysis.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Hash, PartialEq)]
 pub(crate) enum PatternConstraintKind<'db> {
     Singleton(Singleton, Option<Expression<'db>>),
     Value(Expression<'db>, Option<Expression<'db>>),

crates/red_knot_python_semantic/src/semantic_index/use_def.rs

@@ -478,7 +478,6 @@ impl std::iter::FusedIterator for DeclarationsIterator<'_, '_> {}
 pub(super) struct FlowSnapshot {
     symbol_states: IndexVec<ScopedSymbolId, SymbolState>,
     scope_start_visibility: ScopedVisibilityConstraintId,
-    reachable: bool,
 }
 
 #[derive(Debug)]
@@ -506,8 +505,6 @@ pub(super) struct UseDefMapBuilder<'db> {
 
     /// Currently live bindings and declarations for each symbol.
     symbol_states: IndexVec<ScopedSymbolId, SymbolState>,
-
-    reachable: bool,
 }
 
 impl Default for UseDefMapBuilder<'_> {
@@ -520,14 +517,13 @@ impl Default for UseDefMapBuilder<'_> {
             bindings_by_use: IndexVec::new(),
             definitions_by_definition: FxHashMap::default(),
             symbol_states: IndexVec::new(),
-            reachable: true,
         }
     }
 }
 
 impl<'db> UseDefMapBuilder<'db> {
     pub(super) fn mark_unreachable(&mut self) {
-        self.reachable = false;
+        self.record_visibility_constraint(ScopedVisibilityConstraintId::ALWAYS_FALSE);
     }
 
     pub(super) fn add_symbol(&mut self, symbol: ScopedSymbolId) {
@@ -544,7 +540,7 @@ impl<'db> UseDefMapBuilder<'db> {
             binding,
             SymbolDefinitions::Declarations(symbol_state.declarations().clone()),
         );
-        symbol_state.record_binding(def_id);
+        symbol_state.record_binding(def_id, self.scope_start_visibility);
     }
 
     pub(super) fn add_constraint(&mut self, constraint: Constraint<'db>) -> ScopedConstraintId {
@@ -596,7 +592,11 @@ impl<'db> UseDefMapBuilder<'db> {
     pub(super) fn simplify_visibility_constraints(&mut self, snapshot: FlowSnapshot) {
         debug_assert!(self.symbol_states.len() >= snapshot.symbol_states.len());
 
-        self.scope_start_visibility = snapshot.scope_start_visibility;
+        // If there are any control flow paths that have become unreachable between `snapshot` and
+        // now, then it's not valid to simplify any visibility constraints to `snapshot`.
+        if self.scope_start_visibility != snapshot.scope_start_visibility {
+            return;
+        }
 
         // Note that this loop terminates when we reach a symbol not present in the snapshot.
         // This means we keep visibility constraints for all new symbols, which is intended,
@@ -632,7 +632,7 @@ impl<'db> UseDefMapBuilder<'db> {
         let def_id = self.all_definitions.push(Some(definition));
         let symbol_state = &mut self.symbol_states[symbol];
         symbol_state.record_declaration(def_id);
-        symbol_state.record_binding(def_id);
+        symbol_state.record_binding(def_id, self.scope_start_visibility);
     }
 
     pub(super) fn record_use(&mut self, symbol: ScopedSymbolId, use_id: ScopedUseId) {
@@ -649,7 +649,6 @@ impl<'db> UseDefMapBuilder<'db> {
         FlowSnapshot {
             symbol_states: self.symbol_states.clone(),
             scope_start_visibility: self.scope_start_visibility,
-            reachable: self.reachable,
         }
     }
 
@@ -672,21 +671,23 @@ impl<'db> UseDefMapBuilder<'db> {
             num_symbols,
             SymbolState::undefined(self.scope_start_visibility),
         );
-
-        self.reachable = snapshot.reachable;
     }
 
     /// Merge the given snapshot into the current state, reflecting that we might have taken either
     /// path to get here. The new state for each symbol should include definitions from both the
     /// prior state and the snapshot.
     pub(super) fn merge(&mut self, snapshot: FlowSnapshot) {
-        // Unreachable snapshots should not be merged: If the current snapshot is unreachable, it
-        // should be completely overwritten by the snapshot we're merging in. If the other snapshot
-        // is unreachable, we should return without merging.
-        if !snapshot.reachable {
+        // As an optimization, if we know statically that either of the snapshots is always
+        // unreachable, we can leave it out of the merged result entirely. Note that we cannot
+        // perform any type inference at this point, so this is largely limited to unreachability
+        // via terminal statements. If a flow's reachability depends on an expression in the code,
+        // we will include the flow in the merged result; the visibility constraints of its
+        // bindings will include this reachability condition, so that later during type inference,
+        // we can determine whether any particular binding is non-visible due to unreachability.
+        if snapshot.scope_start_visibility == ScopedVisibilityConstraintId::ALWAYS_FALSE {
             return;
         }
-        if !self.reachable {
+        if self.scope_start_visibility == ScopedVisibilityConstraintId::ALWAYS_FALSE {
             self.restore(snapshot);
             return;
         }
@@ -712,9 +713,6 @@ impl<'db> UseDefMapBuilder<'db> {
         self.scope_start_visibility = self
             .visibility_constraints
             .add_or_constraint(self.scope_start_visibility, snapshot.scope_start_visibility);
-
-        // Both of the snapshots are reachable, so the merged result is too.
-        self.reachable = true;
     }
 
     pub(super) fn finish(mut self) -> UseDefMap<'db> {

crates/red_knot_python_semantic/src/semantic_index/use_def/symbol_state.rs

@@ -237,7 +237,11 @@ impl SymbolBindings {
     }
 
     /// Record a newly-encountered binding for this symbol.
-    pub(super) fn record_binding(&mut self, binding_id: ScopedDefinitionId) {
+    pub(super) fn record_binding(
+        &mut self,
+        binding_id: ScopedDefinitionId,
+        visibility_constraint: ScopedVisibilityConstraintId,
+    ) {
         // The new binding replaces all previous live bindings in this path, and has no
         // constraints.
         self.live_bindings = Bindings::with(binding_id.into());
@@ -245,8 +249,7 @@ impl SymbolBindings {
         self.constraints.push(Constraints::default());
 
         self.visibility_constraints = VisibilityConstraintPerBinding::with_capacity(1);
-        self.visibility_constraints
-            .push(ScopedVisibilityConstraintId::ALWAYS_TRUE);
+        self.visibility_constraints.push(visibility_constraint);
     }
 
     /// Add given constraint to all live bindings.
@@ -349,9 +352,14 @@ impl SymbolState {
     }
 
     /// Record a newly-encountered binding for this symbol.
-    pub(super) fn record_binding(&mut self, binding_id: ScopedDefinitionId) {
+    pub(super) fn record_binding(
+        &mut self,
+        binding_id: ScopedDefinitionId,
+        visibility_constraint: ScopedVisibilityConstraintId,
+    ) {
         debug_assert_ne!(binding_id, ScopedDefinitionId::UNBOUND);
-        self.bindings.record_binding(binding_id);
+        self.bindings
+            .record_binding(binding_id, visibility_constraint);
     }
 
     /// Add given constraint to all live bindings.
@@ -557,7 +565,10 @@ mod tests {
     #[test]
     fn with() {
         let mut sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym.record_binding(ScopedDefinitionId::from_u32(1));
+        sym.record_binding(
+            ScopedDefinitionId::from_u32(1),
+            ScopedVisibilityConstraintId::ALWAYS_TRUE,
+        );
 
         assert_bindings(&sym, &["1<>"]);
     }
@@ -565,7 +576,10 @@ mod tests {
     #[test]
     fn record_constraint() {
         let mut sym = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym.record_binding(ScopedDefinitionId::from_u32(1));
+        sym.record_binding(
+            ScopedDefinitionId::from_u32(1),
+            ScopedVisibilityConstraintId::ALWAYS_TRUE,
+        );
         sym.record_constraint(ScopedConstraintId::from_u32(0));
 
         assert_bindings(&sym, &["1<0>"]);
@@ -577,11 +591,17 @@ mod tests {
 
         // merging the same definition with the same constraint keeps the constraint
         let mut sym1a = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym1a.record_binding(ScopedDefinitionId::from_u32(1));
+        sym1a.record_binding(
+            ScopedDefinitionId::from_u32(1),
+            ScopedVisibilityConstraintId::ALWAYS_TRUE,
+        );
         sym1a.record_constraint(ScopedConstraintId::from_u32(0));
 
         let mut sym1b = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym1b.record_binding(ScopedDefinitionId::from_u32(1));
+        sym1b.record_binding(
+            ScopedDefinitionId::from_u32(1),
+            ScopedVisibilityConstraintId::ALWAYS_TRUE,
+        );
         sym1b.record_constraint(ScopedConstraintId::from_u32(0));
 
         sym1a.merge(sym1b, &mut visibility_constraints);
@@ -590,11 +610,17 @@ mod tests {
 
         // merging the same definition with differing constraints drops all constraints
         let mut sym2a = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym2a.record_binding(ScopedDefinitionId::from_u32(2));
+        sym2a.record_binding(
+            ScopedDefinitionId::from_u32(2),
+            ScopedVisibilityConstraintId::ALWAYS_TRUE,
+        );
         sym2a.record_constraint(ScopedConstraintId::from_u32(1));
 
         let mut sym1b = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym1b.record_binding(ScopedDefinitionId::from_u32(2));
+        sym1b.record_binding(
+            ScopedDefinitionId::from_u32(2),
+            ScopedVisibilityConstraintId::ALWAYS_TRUE,
+        );
         sym1b.record_constraint(ScopedConstraintId::from_u32(2));
 
         sym2a.merge(sym1b, &mut visibility_constraints);
@@ -603,7 +629,10 @@ mod tests {
 
         // merging a constrained definition with unbound keeps both
         let mut sym3a = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);
-        sym3a.record_binding(ScopedDefinitionId::from_u32(3));
+        sym3a.record_binding(
+            ScopedDefinitionId::from_u32(3),
+            ScopedVisibilityConstraintId::ALWAYS_TRUE,
+        );
         sym3a.record_constraint(ScopedConstraintId::from_u32(3));
 
         let sym2b = SymbolState::undefined(ScopedVisibilityConstraintId::ALWAYS_TRUE);

crates/red_knot_python_semantic/src/symbol.rs

@@ -9,15 +9,6 @@ pub(crate) enum Boundness {
     PossiblyUnbound,
 }
 
-impl Boundness {
-    pub(crate) fn or(self, other: Boundness) -> Boundness {
-        match (self, other) {
-            (Boundness::Bound, _) | (_, Boundness::Bound) => Boundness::Bound,
-            (Boundness::PossiblyUnbound, Boundness::PossiblyUnbound) => Boundness::PossiblyUnbound,
-        }
-    }
-}
-
 /// The result of a symbol lookup, which can either be a (possibly unbound) type
 /// or a completely unbound symbol.
 ///
@@ -46,13 +37,6 @@ impl<'db> Symbol<'db> {
         matches!(self, Symbol::Unbound)
     }
 
-    pub(crate) fn possibly_unbound(&self) -> bool {
-        match self {
-            Symbol::Type(_, Boundness::PossiblyUnbound) | Symbol::Unbound => true,
-            Symbol::Type(_, Boundness::Bound) => false,
-        }
-    }
-
     /// Returns the type of the symbol, ignoring possible unboundness.
     ///
     /// If the symbol is *definitely* unbound, this function will return `None`. Otherwise,
@@ -71,18 +55,32 @@ impl<'db> Symbol<'db> {
             .expect("Expected a (possibly unbound) type, not an unbound symbol")
     }
 
+    /// Fallback (partially or fully) to another symbol if `self` is partially or fully unbound.
+    ///
+    /// 1. If `self` is definitely bound, return `self` without evaluating `fallback_fn()`.
+    /// 2. Else, evaluate `fallback_fn()`:
+    ///    a. If `self` is definitely unbound, return the result of `fallback_fn()`.
+    ///    b. Else, if `fallback` is definitely unbound, return `self`.
+    ///    c. Else, if `self` is possibly unbound and `fallback` is definitely bound,
+    ///       return `Symbol(<union of self-type and fallback-type>, Boundness::Bound)`
+    ///    d. Else, if `self` is possibly unbound and `fallback` is possibly unbound,
+    ///       return `Symbol(<union of self-type and fallback-type>, Boundness::PossiblyUnbound)`
     #[must_use]
-    pub(crate) fn or_fall_back_to(self, db: &'db dyn Db, fallback: &Symbol<'db>) -> Symbol<'db> {
-        match fallback {
-            Symbol::Type(fallback_ty, fallback_boundness) => match self {
-                Symbol::Type(_, Boundness::Bound) => self,
-                Symbol::Type(ty, boundness @ Boundness::PossiblyUnbound) => Symbol::Type(
-                    UnionType::from_elements(db, [*fallback_ty, ty]),
-                    fallback_boundness.or(boundness),
+    pub(crate) fn or_fall_back_to(
+        self,
+        db: &'db dyn Db,
+        fallback_fn: impl FnOnce() -> Self,
+    ) -> Self {
+        match self {
+            Symbol::Type(_, Boundness::Bound) => self,
+            Symbol::Unbound => fallback_fn(),
+            Symbol::Type(self_ty, Boundness::PossiblyUnbound) => match fallback_fn() {
+                Symbol::Unbound => self,
+                Symbol::Type(fallback_ty, fallback_boundness) => Symbol::Type(
+                    UnionType::from_elements(db, [self_ty, fallback_ty]),
+                    fallback_boundness,
                 ),
-                Symbol::Unbound => fallback.clone(),
             },
-            Symbol::Unbound => self,
         }
     }
 
@@ -110,44 +108,44 @@ mod tests {
 
         // Start from an unbound symbol
         assert_eq!(
-            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Unbound.or_fall_back_to(&db, || Symbol::Unbound),
             Symbol::Unbound
         );
         assert_eq!(
-            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, PossiblyUnbound)),
+            Symbol::Unbound.or_fall_back_to(&db, || Symbol::Type(ty1, PossiblyUnbound)),
             Symbol::Type(ty1, PossiblyUnbound)
         );
         assert_eq!(
-            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, Bound)),
+            Symbol::Unbound.or_fall_back_to(&db, || Symbol::Type(ty1, Bound)),
             Symbol::Type(ty1, Bound)
         );
 
         // Start from a possibly unbound symbol
         assert_eq!(
-            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, || Symbol::Unbound),
             Symbol::Type(ty1, PossiblyUnbound)
         );
         assert_eq!(
             Symbol::Type(ty1, PossiblyUnbound)
-                .or_fall_back_to(&db, &Symbol::Type(ty2, PossiblyUnbound)),
-            Symbol::Type(UnionType::from_elements(&db, [ty2, ty1]), PossiblyUnbound)
+                .or_fall_back_to(&db, || Symbol::Type(ty2, PossiblyUnbound)),
+            Symbol::Type(UnionType::from_elements(&db, [ty1, ty2]), PossiblyUnbound)
         );
         assert_eq!(
-            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, &Symbol::Type(ty2, Bound)),
-            Symbol::Type(UnionType::from_elements(&db, [ty2, ty1]), Bound)
+            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, || Symbol::Type(ty2, Bound)),
+            Symbol::Type(UnionType::from_elements(&db, [ty1, ty2]), Bound)
         );
 
         // Start from a definitely bound symbol
         assert_eq!(
-            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, || Symbol::Unbound),
             Symbol::Type(ty1, Bound)
         );
         assert_eq!(
-            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Type(ty2, PossiblyUnbound)),
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, || Symbol::Type(ty2, PossiblyUnbound)),
             Symbol::Type(ty1, Bound)
         );
         assert_eq!(
-            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Type(ty2, Bound)),
+            Symbol::Type(ty1, Bound).or_fall_back_to(&db, || Symbol::Type(ty2, Bound)),
             Symbol::Type(ty1, Bound)
         );
     }

crates/red_knot_python_semantic/src/types.rs

@@ -15,8 +15,7 @@ pub(crate) use self::diagnostic::register_lints;
 pub use self::diagnostic::{TypeCheckDiagnostic, TypeCheckDiagnostics};
 pub(crate) use self::display::TypeArrayDisplay;
 pub(crate) use self::infer::{
-    infer_deferred_types, infer_definition_types, infer_expression_type, infer_expression_types,
-    infer_scope_types,
+    infer_deferred_types, infer_definition_types, infer_expression_types, infer_scope_types,
 };
 pub use self::narrow::KnownConstraintFunction;
 pub(crate) use self::signatures::Signature;
@@ -26,6 +25,7 @@ use crate::module_resolver::{file_to_module, resolve_module, KnownModule};
 use crate::semantic_index::ast_ids::HasScopedExpressionId;
 use crate::semantic_index::attribute_assignment::AttributeAssignment;
 use crate::semantic_index::definition::Definition;
+use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{self as symbol, ScopeId, ScopedSymbolId};
 use crate::semantic_index::{
     attribute_assignments, global_scope, imported_modules, semantic_index, symbol_table,
@@ -40,6 +40,7 @@ use crate::types::call::{
 };
 use crate::types::class_base::ClassBase;
 use crate::types::diagnostic::INVALID_TYPE_FORM;
+use crate::types::infer::infer_unpack_types;
 use crate::types::mro::{Mro, MroError, MroIterator};
 use crate::types::narrow::narrowing_constraint;
 use crate::{Db, FxOrderSet, Module, Program, PythonVersion};
@@ -256,26 +257,19 @@ fn module_type_symbols<'db>(db: &'db dyn Db) -> smallvec::SmallVec<[ast::name::N
 
 /// Looks up a module-global symbol by name in a file.
 pub(crate) fn global_symbol<'db>(db: &'db dyn Db, file: File, name: &str) -> Symbol<'db> {
-    let explicit_symbol = symbol(db, global_scope(db, file), name);
-
-    if !explicit_symbol.possibly_unbound() {
-        return explicit_symbol;
-    }
-
     // Not defined explicitly in the global scope?
     // All modules are instances of `types.ModuleType`;
     // look it up there (with a few very special exceptions)
-    if module_type_symbols(db)
-        .iter()
-        .any(|module_type_member| &**module_type_member == name)
-    {
-        // TODO: this should use `.to_instance(db)`. but we don't understand attribute access
-        // on instance types yet.
-        let module_type_member = KnownClass::ModuleType.to_class_literal(db).member(db, name);
-        return explicit_symbol.or_fall_back_to(db, &module_type_member);
-    }
-
-    explicit_symbol
+    symbol(db, global_scope(db, file), name).or_fall_back_to(db, || {
+        if module_type_symbols(db)
+            .iter()
+            .any(|module_type_member| &**module_type_member == name)
+        {
+            KnownClass::ModuleType.to_instance(db).member(db, name)
+        } else {
+            Symbol::Unbound
+        }
+    })
 }
 
 /// Infer the type of a binding.
@@ -670,6 +664,10 @@ impl<'db> Type<'db> {
         matches!(self, Type::ClassLiteral(..))
     }
 
+    pub const fn is_instance(&self) -> bool {
+        matches!(self, Type::Instance(..))
+    }
+
     pub fn module_literal(db: &'db dyn Db, importing_file: File, submodule: Module) -> Self {
         Self::ModuleLiteral(ModuleLiteralType::new(db, importing_file, submodule))
     }
@@ -1263,19 +1261,42 @@ impl<'db> Type<'db> {
                 .iter()
                 .all(|e| e.is_disjoint_from(db, other)),
 
-            (Type::Intersection(intersection), other)
-            | (other, Type::Intersection(intersection)) => {
-                if intersection
+            (Type::Intersection(inter_left), Type::Intersection(inter_right)) => {
+                // We explicitly make this case a symmetric version of the case below, as there
+                // are some type pairs like `Any & T` and `~T` that would otherwise lead to non-
+                // symmetric results.
+                inter_left
                     .positive(db)
                     .iter()
                     .any(|p| p.is_disjoint_from(db, other))
-                {
-                    true
-                } else {
-                    // TODO we can do better here. For example:
-                    // X & ~Literal[1] is disjoint from Literal[1]
-                    false
-                }
+                    || inter_right
+                        .positive(db)
+                        .iter()
+                        .any(|p| p.is_disjoint_from(db, self))
+                    || inter_left.negative(db).iter().any(|n| {
+                        other.is_subtype_of(db, *n)
+                            && self.is_fully_static(db)
+                            && other.is_fully_static(db)
+                    })
+                    || inter_right.negative(db).iter().any(|n| {
+                        self.is_subtype_of(db, *n)
+                            && self.is_fully_static(db)
+                            && other.is_fully_static(db)
+                    })
+            }
+            (Type::Intersection(intersection), t) | (t, Type::Intersection(intersection)) => {
+                // TODO: There are certainly more cases that could be handled here. For example,
+                // it is possible that both A and B overlap with C, but the intersection A & B
+                // does not overlap with C.
+                intersection
+                    .positive(db)
+                    .iter()
+                    .any(|p| p.is_disjoint_from(db, t))
+                    || intersection.negative(db).iter().any(|n| {
+                        t.is_subtype_of(db, *n)
+                            && self.is_fully_static(db)
+                            && other.is_fully_static(db)
+                    })
             }
 
             // any single-valued type is disjoint from another single-valued type
@@ -1843,19 +1864,8 @@ impl<'db> Type<'db> {
                         return Truthiness::Ambiguous;
                     };
 
-                    // Check if the class has `__bool__ = bool` and avoid infinite recursion, since
-                    // `Type::call` on `bool` will call `Type::bool` on the argument.
-                    if bool_method
-                        .into_class_literal()
-                        .is_some_and(|ClassLiteralType { class }| {
-                            class.is_known(db, KnownClass::Bool)
-                        })
-                    {
-                        return Truthiness::Ambiguous;
-                    }
-
                     if let Some(Type::BooleanLiteral(bool_val)) = bool_method
-                        .call(db, &CallArguments::positional([*instance_ty]))
+                        .call_bound(db, instance_ty, &CallArguments::positional([]))
                         .return_type(db)
                     {
                         bool_val.into()
@@ -2148,6 +2158,52 @@ impl<'db> Type<'db> {
         }
     }
 
+    /// Return the outcome of calling an class/instance attribute of this type
+    /// using descriptor protocol.
+    ///
+    /// `receiver_ty` must be `Type::Instance(_)` or `Type::ClassLiteral`.
+    ///
+    /// TODO: handle `super()` objects properly
+    #[must_use]
+    fn call_bound(
+        self,
+        db: &'db dyn Db,
+        receiver_ty: &Type<'db>,
+        arguments: &CallArguments<'_, 'db>,
+    ) -> CallOutcome<'db> {
+        debug_assert!(receiver_ty.is_instance() || receiver_ty.is_class_literal());
+
+        match self {
+            Type::FunctionLiteral(..) => {
+                // Functions are always descriptors, so this would effectively call
+                // the function with the instance as the first argument
+                self.call(db, &arguments.with_self(*receiver_ty))
+            }
+
+            Type::Instance(_) | Type::ClassLiteral(_) => {
+                // TODO descriptor protocol. For now, assume non-descriptor and call without `self` argument.
+                self.call(db, arguments)
+            }
+
+            Type::Union(union) => CallOutcome::union(
+                self,
+                union
+                    .elements(db)
+                    .iter()
+                    .map(|elem| elem.call_bound(db, receiver_ty, arguments)),
+            ),
+
+            Type::Intersection(_) => CallOutcome::callable(CallBinding::from_return_type(
+                todo_type!("Type::Intersection.call_bound()"),
+            )),
+
+            // Cases that duplicate, and thus must be kept in sync with, `Type::call()`
+            Type::Dynamic(_) => CallOutcome::callable(CallBinding::from_return_type(self)),
+
+            _ => CallOutcome::not_callable(self),
+        }
+    }
+
     /// Look up a dunder method on the meta type of `self` and call it.
     fn call_dunder(
         self,
@@ -3757,10 +3813,8 @@ impl<'db> ModuleLiteralType<'db> {
             }
         }
 
-        let global_lookup = symbol(db, global_scope(db, self.module(db).file()), name);
-
-        // If it's unbound, check if it's present as an instance on `types.ModuleType`
-        // or `builtins.object`.
+        // If it's not found in the global scope, check if it's present as an instance
+        // on `types.ModuleType` or `builtins.object`.
         //
         // We do a more limited version of this in `global_symbol_ty`,
         // but there are two crucial differences here:
@@ -3774,14 +3828,13 @@ impl<'db> ModuleLiteralType<'db> {
         // ignore `__getattr__`. Typeshed has a fake `__getattr__` on `types.ModuleType`
         // to help out with dynamic imports; we shouldn't use it for `ModuleLiteral` types
         // where we know exactly which module we're dealing with.
-        if name != "__getattr__" && global_lookup.possibly_unbound() {
-            // TODO: this should use `.to_instance()`, but we don't understand instance attribute yet
-            let module_type_instance_member =
-                KnownClass::ModuleType.to_class_literal(db).member(db, name);
-            global_lookup.or_fall_back_to(db, &module_type_instance_member)
-        } else {
-            global_lookup
-        }
+        symbol(db, global_scope(db, self.module(db).file()), name).or_fall_back_to(db, || {
+            if name == "__getattr__" {
+                Symbol::Unbound
+            } else {
+                KnownClass::ModuleType.to_instance(db).member(db, name)
+            }
+        })
     }
 }
 
@@ -4147,6 +4200,16 @@ impl<'db> Class<'db> {
         name: &str,
         inferred_type_from_class_body: Option<Type<'db>>,
     ) -> Symbol<'db> {
+        // We use a separate salsa query here to prevent unrelated changes in the AST of an external
+        // file from triggering re-evaluations of downstream queries.
+        // See the `dependency_implicit_instance_attribute` test for more information.
+        #[salsa::tracked]
+        fn infer_expression_type<'db>(db: &'db dyn Db, expression: Expression<'db>) -> Type<'db> {
+            let inference = infer_expression_types(db, expression);
+            let expr_scope = expression.scope(db);
+            inference.expression_type(expression.node_ref(db).scoped_expression_id(db, expr_scope))
+        }
+
         // If we do not see any declarations of an attribute, neither in the class body nor in
         // any method, we build a union of `Unknown` with the inferred types of all bindings of
         // that attribute. We include `Unknown` in that union to account for the fact that the
@@ -4192,6 +4255,32 @@ impl<'db> Class<'db> {
 
                     union_of_inferred_types = union_of_inferred_types.add(inferred_ty);
                 }
+                AttributeAssignment::Iterable { iterable } => {
+                    // We found an attribute assignment like:
+                    //
+                    //     for self.name in <iterable>:
+
+                    // TODO: Potential diagnostics resulting from the iterable are currently not reported.
+
+                    let iterable_ty = infer_expression_type(db, *iterable);
+                    let inferred_ty = iterable_ty.iterate(db).unwrap_without_diagnostic();
+
+                    union_of_inferred_types = union_of_inferred_types.add(inferred_ty);
+                }
+                AttributeAssignment::Unpack {
+                    attribute_expression_id,
+                    unpack,
+                } => {
+                    // We found an unpacking assignment like:
+                    //
+                    //     .., self.name, .. = <value>
+                    //     (.., self.name, ..) = <value>
+                    //     [.., self.name, ..] = <value>
+
+                    let inferred_ty =
+                        infer_unpack_types(db, *unpack).expression_type(*attribute_expression_id);
+                    union_of_inferred_types = union_of_inferred_types.add(inferred_ty);
+                }
             }
         }
 

crates/red_knot_python_semantic/src/types/infer.rs

@@ -193,20 +193,6 @@ pub(crate) fn infer_expression_types<'db>(
     TypeInferenceBuilder::new(db, InferenceRegion::Expression(expression), index).finish()
 }
 
-// Similar to `infer_expression_types` (with the same restrictions). Directly returns the
-// type of the overall expression. This is a salsa query because it accesses `node_ref`,
-// which is sensitive to changes in the AST. Making it a query allows downstream queries
-// to short-circuit if the result type has not changed.
-#[salsa::tracked]
-pub(crate) fn infer_expression_type<'db>(
-    db: &'db dyn Db,
-    expression: Expression<'db>,
-) -> Type<'db> {
-    let inference = infer_expression_types(db, expression);
-    let expr_scope = expression.scope(db);
-    inference.expression_type(expression.node_ref(db).scoped_expression_id(db, expr_scope))
-}
-
 /// Infer the types for an [`Unpack`] operation.
 ///
 /// This infers the expression type and performs structural match against the target expression
@@ -214,7 +200,7 @@ pub(crate) fn infer_expression_type<'db>(
 /// type of the variables involved in this unpacking along with any violations that are detected
 /// during this unpacking.
 #[salsa::tracked(return_ref)]
-fn infer_unpack_types<'db>(db: &'db dyn Db, unpack: Unpack<'db>) -> UnpackResult<'db> {
+pub(super) fn infer_unpack_types<'db>(db: &'db dyn Db, unpack: Unpack<'db>) -> UnpackResult<'db> {
     let file = unpack.file(db);
     let _span =
         tracing::trace_span!("infer_unpack_types", range=?unpack.range(db), file=%file.path(db))
@@ -2099,7 +2085,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                 }
 
                 let name_ast_id = name.scoped_expression_id(self.db(), self.scope());
-                unpacked.get(name_ast_id).unwrap_or(Type::unknown())
+                unpacked.expression_type(name_ast_id)
             }
             TargetKind::Name => {
                 if self.in_stub() && value.is_ellipsis_literal_expr() {
@@ -2370,7 +2356,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         self.context.extend(unpacked);
                     }
                     let name_ast_id = name.scoped_expression_id(self.db(), self.scope());
-                    unpacked.get(name_ast_id).unwrap_or(Type::unknown())
+                    unpacked.expression_type(name_ast_id)
                 }
                 TargetKind::Name => iterable_ty
                     .iterate(self.db())
@@ -2526,19 +2512,22 @@ impl<'db> TypeInferenceBuilder<'db> {
         let module = file_to_module(self.db(), self.file())
             .ok_or(ModuleNameResolutionError::UnknownCurrentModule)?;
         let mut level = level.get();
+
         if module.kind().is_package() {
-            level -= 1;
-        }
-        let mut module_name = module.name().clone();
-        for _ in 0..level {
-            module_name = module_name
-                .parent()
-                .ok_or(ModuleNameResolutionError::TooManyDots)?;
+            level = level.saturating_sub(1);
         }
+
+        let mut module_name = module
+            .name()
+            .ancestors()
+            .nth(level as usize)
+            .ok_or(ModuleNameResolutionError::TooManyDots)?;
+
         if let Some(tail) = tail {
             let tail = ModuleName::new(tail).ok_or(ModuleNameResolutionError::InvalidSyntax)?;
             module_name.extend(&tail);
         }
+
         Ok(module_name)
     }
 
@@ -2552,6 +2541,12 @@ impl<'db> TypeInferenceBuilder<'db> {
         // - Absolute `*` imports (`from collections import *`)
         // - Relative `*` imports (`from ...foo import *`)
         let ast::StmtImportFrom { module, level, .. } = import_from;
+        // For diagnostics, we want to highlight the unresolvable
+        // module and not the entire `from ... import ...` statement.
+        let module_ref = module
+            .as_ref()
+            .map(AnyNodeRef::from)
+            .unwrap_or_else(|| AnyNodeRef::from(import_from));
         let module = module.as_deref();
 
         let module_name = if let Some(level) = NonZeroU32::new(*level) {
@@ -2586,7 +2581,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     "Relative module resolution `{}` failed: too many leading dots",
                     format_import_from_module(*level, module),
                 );
-                report_unresolved_module(&self.context, import_from, *level, module);
+                report_unresolved_module(&self.context, module_ref, *level, module);
                 self.add_unknown_declaration_with_binding(alias.into(), definition);
                 return;
             }
@@ -2596,14 +2591,14 @@ impl<'db> TypeInferenceBuilder<'db> {
                     format_import_from_module(*level, module),
                     self.file().path(self.db())
                 );
-                report_unresolved_module(&self.context, import_from, *level, module);
+                report_unresolved_module(&self.context, module_ref, *level, module);
                 self.add_unknown_declaration_with_binding(alias.into(), definition);
                 return;
             }
         };
 
         let Some(module_ty) = self.module_type_from_name(&module_name) else {
-            report_unresolved_module(&self.context, import_from, *level, module);
+            report_unresolved_module(&self.context, module_ref, *level, module);
             self.add_unknown_declaration_with_binding(alias.into(), definition);
             return;
         };
@@ -3304,8 +3299,9 @@ impl<'db> TypeInferenceBuilder<'db> {
 
     /// Look up a name reference that isn't bound in the local scope.
     fn lookup_name(&mut self, name_node: &ast::ExprName) -> Symbol<'db> {
+        let db = self.db();
         let ast::ExprName { id: name, .. } = name_node;
-        let file_scope_id = self.scope().file_scope_id(self.db());
+        let file_scope_id = self.scope().file_scope_id(db);
         let is_bound =
             if let Some(symbol) = self.index.symbol_table(file_scope_id).symbol_by_name(name) {
                 symbol.is_bound()
@@ -3320,16 +3316,15 @@ impl<'db> TypeInferenceBuilder<'db> {
         // In function-like scopes, any local variable (symbol that is bound in this scope) can
         // only have a definition in this scope, or error; it never references another scope.
         // (At runtime, it would use the `LOAD_FAST` opcode.)
-        if !is_bound || !self.scope().is_function_like(self.db()) {
+        if !is_bound || !self.scope().is_function_like(db) {
             // Walk up parent scopes looking for a possible enclosing scope that may have a
             // definition of this name visible to us (would be `LOAD_DEREF` at runtime.)
             for (enclosing_scope_file_id, _) in self.index.ancestor_scopes(file_scope_id) {
                 // Class scopes are not visible to nested scopes, and we need to handle global
                 // scope differently (because an unbound name there falls back to builtins), so
                 // check only function-like scopes.
-                let enclosing_scope_id =
-                    enclosing_scope_file_id.to_scope_id(self.db(), self.file());
-                if !enclosing_scope_id.is_function_like(self.db()) {
+                let enclosing_scope_id = enclosing_scope_file_id.to_scope_id(db, self.file());
+                if !enclosing_scope_id.is_function_like(db) {
                     continue;
                 }
                 let enclosing_symbol_table = self.index.symbol_table(enclosing_scope_file_id);
@@ -3342,37 +3337,45 @@ impl<'db> TypeInferenceBuilder<'db> {
                     // runtime, it is the scope that creates the cell for our closure.) If the name
                     // isn't bound in that scope, we should get an unbound name, not continue
                     // falling back to other scopes / globals / builtins.
-                    return symbol(self.db(), enclosing_scope_id, name);
+                    return symbol(db, enclosing_scope_id, name);
                 }
             }
 
-            // No nonlocal binding, check module globals. Avoid infinite recursion if `self.scope`
-            // already is module globals.
-            let global_symbol = if file_scope_id.is_global() {
-                Symbol::Unbound
-            } else {
-                global_symbol(self.db(), self.file(), name)
-            };
-
-            // Fallback to builtins (without infinite recursion if we're already in builtins.)
-            if global_symbol.possibly_unbound()
-                && Some(self.scope()) != builtins_module_scope(self.db())
-            {
-                let mut builtins_symbol = builtins_symbol(self.db(), name);
-                if builtins_symbol.is_unbound() && name == "reveal_type" {
-                    self.context.report_lint(
-                        &UNDEFINED_REVEAL,
-                        name_node.into(),
-                        format_args!(
-                            "`reveal_type` used without importing it; this is allowed for debugging convenience but will fail at runtime"),
-                    );
-                    builtins_symbol = typing_extensions_symbol(self.db(), name);
-                }
-
-                global_symbol.or_fall_back_to(self.db(), &builtins_symbol)
-            } else {
-                global_symbol
-            }
+            Symbol::Unbound
+                // No nonlocal binding? Check the module's globals.
+                // Avoid infinite recursion if `self.scope` already is the module's global scope.
+                .or_fall_back_to(db, || {
+                    if file_scope_id.is_global() {
+                        Symbol::Unbound
+                    } else {
+                        global_symbol(db, self.file(), name)
+                    }
+                })
+                // Not found in globals? Fallback to builtins
+                // (without infinite recursion if we're already in builtins.)
+                .or_fall_back_to(db, || {
+                    if Some(self.scope()) == builtins_module_scope(db) {
+                        Symbol::Unbound
+                    } else {
+                        builtins_symbol(db, name)
+                    }
+                })
+                // Still not found? It might be `reveal_type`...
+                .or_fall_back_to(db, || {
+                    if name == "reveal_type" {
+                        self.context.report_lint(
+                            &UNDEFINED_REVEAL,
+                            name_node.into(),
+                            format_args!(
+                                "`reveal_type` used without importing it; \
+                            this is allowed for debugging convenience but will fail at runtime"
+                            ),
+                        );
+                        typing_extensions_symbol(db, name)
+                    } else {
+                        Symbol::Unbound
+                    }
+                })
         } else {
             Symbol::Unbound
         }

crates/red_knot_python_semantic/src/types/unpacker.rs

@@ -7,7 +7,7 @@ use ruff_python_ast::{self as ast, AnyNodeRef};
 
 use crate::semantic_index::ast_ids::{HasScopedExpressionId, ScopedExpressionId};
 use crate::semantic_index::symbol::ScopeId;
-use crate::types::{infer_expression_type, todo_type, Type, TypeCheckDiagnostics};
+use crate::types::{infer_expression_types, todo_type, Type, TypeCheckDiagnostics};
 use crate::unpack::UnpackValue;
 use crate::Db;
 
@@ -42,7 +42,8 @@ impl<'db> Unpacker<'db> {
             "Unpacking target must be a list or tuple expression"
         );
 
-        let mut value_ty = infer_expression_type(self.db(), value.expression());
+        let mut value_ty = infer_expression_types(self.db(), value.expression())
+            .expression_type(value.scoped_expression_id(self.db(), self.scope));
 
         if value.is_assign()
             && self.context.in_stub()
@@ -61,19 +62,22 @@ impl<'db> Unpacker<'db> {
                 .unwrap_with_diagnostic(&self.context, value.as_any_node_ref(self.db()));
         }
 
-        self.unpack_inner(target, value_ty);
+        self.unpack_inner(target, value.as_any_node_ref(self.db()), value_ty);
     }
 
-    fn unpack_inner(&mut self, target: &ast::Expr, value_ty: Type<'db>) {
+    fn unpack_inner(
+        &mut self,
+        target: &ast::Expr,
+        value_expr: AnyNodeRef<'db>,
+        value_ty: Type<'db>,
+    ) {
         match target {
-            ast::Expr::Name(target_name) => {
-                self.targets.insert(
-                    target_name.scoped_expression_id(self.db(), self.scope),
-                    value_ty,
-                );
+            ast::Expr::Name(_) | ast::Expr::Attribute(_) => {
+                self.targets
+                    .insert(target.scoped_expression_id(self.db(), self.scope), value_ty);
             }
             ast::Expr::Starred(ast::ExprStarred { value, .. }) => {
-                self.unpack_inner(value, value_ty);
+                self.unpack_inner(value, value_expr, value_ty);
             }
             ast::Expr::List(ast::ExprList { elts, .. })
             | ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
@@ -152,7 +156,7 @@ impl<'db> Unpacker<'db> {
                             Type::LiteralString
                         } else {
                             ty.iterate(self.db())
-                                .unwrap_with_diagnostic(&self.context, AnyNodeRef::from(target))
+                                .unwrap_with_diagnostic(&self.context, value_expr)
                         };
                         for target_type in &mut target_types {
                             target_type.push(ty);
@@ -166,7 +170,7 @@ impl<'db> Unpacker<'db> {
                         [] => Type::unknown(),
                         types => UnionType::from_elements(self.db(), types),
                     };
-                    self.unpack_inner(element, element_ty);
+                    self.unpack_inner(element, value_expr, element_ty);
                 }
             }
             _ => {}
@@ -264,8 +268,14 @@ pub(crate) struct UnpackResult<'db> {
 }
 
 impl<'db> UnpackResult<'db> {
-    pub(crate) fn get(&self, expr_id: ScopedExpressionId) -> Option<Type<'db>> {
-        self.targets.get(&expr_id).copied()
+    /// Returns the inferred type for a given sub-expression of the left-hand side target
+    /// of an unpacking assignment.
+    ///
+    /// Panics if a scoped expression ID is passed in that does not correspond to a sub-
+    /// expression of the target.
+    #[track_caller]
+    pub(crate) fn expression_type(&self, expr_id: ScopedExpressionId) -> Type<'db> {
+        self.targets[&expr_id]
     }
 }
 

crates/red_knot_python_semantic/src/unpack.rs

@@ -3,6 +3,7 @@ use ruff_python_ast::{self as ast, AnyNodeRef};
 use ruff_text_size::{Ranged, TextRange};
 
 use crate::ast_node_ref::AstNodeRef;
+use crate::semantic_index::ast_ids::{HasScopedExpressionId, ScopedExpressionId};
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId};
 use crate::Db;
@@ -87,6 +88,17 @@ impl<'db> UnpackValue<'db> {
         }
     }
 
+    /// Returns the [`ScopedExpressionId`] of the underlying expression.
+    pub(crate) fn scoped_expression_id(
+        self,
+        db: &'db dyn Db,
+        scope: ScopeId<'db>,
+    ) -> ScopedExpressionId {
+        self.expression()
+            .node_ref(db)
+            .scoped_expression_id(db, scope)
+    }
+
     /// Returns the expression as an [`AnyNodeRef`].
     pub(crate) fn as_any_node_ref(self, db: &'db dyn Db) -> AnyNodeRef<'db> {
         self.expression().node_ref(db).node().into()

crates/red_knot_python_semantic/src/visibility_constraints.rs

@@ -137,33 +137,54 @@
 //! create a state where the `x = <unbound>` binding is always visible.
 //!
 //!
-//! ### Properties
+//! ### Representing formulas
 //!
-//! The ternary `AND` and `OR` operations have the property that `~a OR ~b = ~(a AND b)`. This
-//! means we could, in principle, get rid of either of these two to simplify the representation.
+//! Given everything above, we can represent a visibility constraint as a _ternary formula_. This
+//! is like a boolean formula (which maps several true/false variables to a single true/false
+//! result), but which allows the third "ambiguous" value in addition to "true" and "false".
 //!
-//! However, we already apply negative constraints `~test1` and `~test2` to the "branches not
-//! taken" in the example above. This means that the tree-representation `~test1 OR ~test2` is much
-//! cheaper/shallower than basically creating `~(~(~test1) AND ~(~test2))`. Similarly, if we wanted
-//! to get rid of `AND`, we would also have to create additional nodes. So for performance reasons,
-//! there is a small "duplication" in the code between those two constraint types.
+//! [_Binary decision diagrams_][bdd] (BDDs) are a common way to represent boolean formulas when
+//! doing program analysis. We extend this to a _ternary decision diagram_ (TDD) to support
+//! ambiguous values.
+//!
+//! A TDD is a graph, and a ternary formula is represented by a node in this graph. There are three
+//! possible leaf nodes representing the "true", "false", and "ambiguous" constant functions.
+//! Interior nodes consist of a ternary variable to evaluate, and outgoing edges for whether the
+//! variable evaluates to true, false, or ambiguous.
+//!
+//! Our TDDs are _reduced_ and _ordered_ (as is typical for BDDs).
+//!
+//! An ordered TDD means that variables appear in the same order in all paths within the graph.
+//!
+//! A reduced TDD means two things: First, we intern the graph nodes, so that we only keep a single
+//! copy of interior nodes with the same contents. Second, we eliminate any nodes that are "noops",
+//! where the "true" and "false" outgoing edges lead to the same node. (This implies that it
+//! doesn't matter what value that variable has when evaluating the formula, and we can leave it
+//! out of the evaluation chain completely.)
+//!
+//! Reduced and ordered decision diagrams are _normal forms_, which means that two equivalent
+//! formulas (which have the same outputs for every combination of inputs) are represented by
+//! exactly the same graph node. (Because of interning, this is not _equal_ nodes, but _identical_
+//! ones.) That means that we can compare formulas for equivalence in constant time, and in
+//! particular, can check whether a visibility constraint is statically always true or false,
+//! regardless of any Python program state, by seeing if the constraint's formula is the "true" or
+//! "false" leaf node.
 //!
 //! [Kleene]: <https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics>
+//! [bdd]: https://en.wikipedia.org/wiki/Binary_decision_diagram
 
-use ruff_index::{newtype_index, IndexVec};
+use std::cmp::Ordering;
 
-use crate::semantic_index::constraint::{Constraint, ConstraintNode, PatternConstraintKind};
-use crate::types::{infer_expression_type, Truthiness};
+use ruff_index::{Idx, IndexVec};
+use rustc_hash::FxHashMap;
+
+use crate::semantic_index::{
+    ast_ids::HasScopedExpressionId,
+    constraint::{Constraint, ConstraintNode, PatternConstraintKind},
+};
+use crate::types::{infer_expression_types, Truthiness};
 use crate::Db;
 
-/// The maximum depth of recursion when evaluating visibility constraints.
-///
-/// This is a performance optimization that prevents us from descending deeply in case of
-/// pathological cases. The actual limit here has been derived from performance testing on
-/// the `black` codebase. When increasing the limit beyond 32, we see a 5x runtime increase
-/// resulting from a few files with a lot of boolean expressions and `if`-statements.
-const MAX_RECURSION_DEPTH: usize = 24;
-
 /// A ternary formula that defines under what conditions a binding is visible. (A ternary formula
 /// is just like a boolean formula, but with `Ambiguous` as a third potential result. See the
 /// module documentation for more details.)
@@ -179,211 +200,416 @@ const MAX_RECURSION_DEPTH: usize = 24;
 /// That means that when you are constructing a formula, you might need to create distinct atoms
 /// for a particular [`Constraint`], if your formula needs to consider how a particular runtime
 /// property might be different at different points in the execution of the program.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct VisibilityConstraint<'db>(VisibilityConstraintInner<'db>);
+///
+/// Visibility constraints are normalized, so equivalent constraints are guaranteed to have equal
+/// IDs.
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub(crate) struct ScopedVisibilityConstraintId(u32);
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum VisibilityConstraintInner<'db> {
-    AlwaysTrue,
-    AlwaysFalse,
-    Ambiguous,
-    VisibleIf(Constraint<'db>, u8),
-    VisibleIfNot(ScopedVisibilityConstraintId),
-    KleeneAnd(ScopedVisibilityConstraintId, ScopedVisibilityConstraintId),
-    KleeneOr(ScopedVisibilityConstraintId, ScopedVisibilityConstraintId),
+impl std::fmt::Debug for ScopedVisibilityConstraintId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut f = f.debug_tuple("ScopedVisibilityConstraintId");
+        match *self {
+            // We use format_args instead of rendering the strings directly so that we don't get
+            // any quotes in the output: ScopedVisibilityConstraintId(AlwaysTrue) instead of
+            // ScopedVisibilityConstraintId("AlwaysTrue").
+            ALWAYS_TRUE => f.field(&format_args!("AlwaysTrue")),
+            AMBIGUOUS => f.field(&format_args!("Ambiguous")),
+            ALWAYS_FALSE => f.field(&format_args!("AlwaysFalse")),
+            _ => f.field(&self.0),
+        };
+        f.finish()
+    }
 }
 
-/// A newtype-index for a visibility constraint in a particular scope.
-#[newtype_index]
-pub(crate) struct ScopedVisibilityConstraintId;
+// Internal details:
+//
+// There are 3 terminals, with hard-coded constraint IDs: true, ambiguous, and false.
+//
+// _Atoms_ are the underlying Constraints, which are the variables that are evaluated by the
+// ternary function.
+//
+// _Interior nodes_ provide the TDD structure for the formula. Interior nodes are stored in an
+// arena Vec, with the constraint ID providing an index into the arena.
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+struct InteriorNode {
+    atom: Atom,
+    if_true: ScopedVisibilityConstraintId,
+    if_ambiguous: ScopedVisibilityConstraintId,
+    if_false: ScopedVisibilityConstraintId,
+}
+
+/// A "variable" that is evaluated as part of a TDD ternary function. For visibility constraints,
+/// this is a `Constraint` that represents some runtime property of the Python code that we are
+/// evaluating. We intern these constraints in an arena ([`VisibilityConstraints::constraints`]).
+/// An atom is then an index into this arena.
+///
+/// By using a 32-bit index, we would typically allow 4 billion distinct constraints within a
+/// scope. However, we sometimes have to model how a `Constraint` can have a different runtime
+/// value at different points in the execution of the program. To handle this, we reserve the top
+/// byte of an atom to represent a "copy number". This is just an opaque value that allows
+/// different `Atom`s to evaluate the same `Constraint`. This yields a maximum of 16 million
+/// distinct `Constraint`s in a scope, and 256 possible copies of each of those constraints.
+#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
+struct Atom(u32);
+
+impl Atom {
+    /// Deconstruct an atom into a constraint index and a copy number.
+    #[inline]
+    fn into_index_and_copy(self) -> (u32, u8) {
+        let copy = self.0 >> 24;
+        let index = self.0 & 0x00ff_ffff;
+        (index, copy as u8)
+    }
+
+    #[inline]
+    fn copy_of(mut self, copy: u8) -> Self {
+        // Clear out the previous copy number
+        self.0 &= 0x00ff_ffff;
+        // OR in the new one
+        self.0 |= u32::from(copy) << 24;
+        self
+    }
+}
+
+// A custom Debug implementation that prints out the constraint index and copy number as distinct
+// fields.
+impl std::fmt::Debug for Atom {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let (index, copy) = self.into_index_and_copy();
+        f.debug_tuple("Atom").field(&index).field(&copy).finish()
+    }
+}
+
+impl Idx for Atom {
+    #[inline]
+    fn new(value: usize) -> Self {
+        assert!(value <= 0x00ff_ffff);
+        #[allow(clippy::cast_possible_truncation)]
+        Self(value as u32)
+    }
+
+    #[inline]
+    fn index(self) -> usize {
+        let (index, _) = self.into_index_and_copy();
+        index as usize
+    }
+}
 
 impl ScopedVisibilityConstraintId {
     /// A special ID that is used for an "always true" / "always visible" constraint.
-    /// When we create a new [`VisibilityConstraints`] object, this constraint is always
-    /// present at index 0.
     pub(crate) const ALWAYS_TRUE: ScopedVisibilityConstraintId =
-        ScopedVisibilityConstraintId::from_u32(0);
-
-    /// A special ID that is used for an "always false" / "never visible" constraint.
-    /// When we create a new [`VisibilityConstraints`] object, this constraint is always
-    /// present at index 1.
-    pub(crate) const ALWAYS_FALSE: ScopedVisibilityConstraintId =
-        ScopedVisibilityConstraintId::from_u32(1);
+        ScopedVisibilityConstraintId(0xffff_ffff);
 
     /// A special ID that is used for an ambiguous constraint.
-    /// When we create a new [`VisibilityConstraints`] object, this constraint is always
-    /// present at index 2.
     pub(crate) const AMBIGUOUS: ScopedVisibilityConstraintId =
-        ScopedVisibilityConstraintId::from_u32(2);
+        ScopedVisibilityConstraintId(0xffff_fffe);
+
+    /// A special ID that is used for an "always false" / "never visible" constraint.
+    pub(crate) const ALWAYS_FALSE: ScopedVisibilityConstraintId =
+        ScopedVisibilityConstraintId(0xffff_fffd);
+
+    fn is_terminal(self) -> bool {
+        self.0 >= SMALLEST_TERMINAL.0
+    }
 }
 
+impl Idx for ScopedVisibilityConstraintId {
+    #[inline]
+    fn new(value: usize) -> Self {
+        assert!(value <= (SMALLEST_TERMINAL.0 as usize));
+        #[allow(clippy::cast_possible_truncation)]
+        Self(value as u32)
+    }
+
+    #[inline]
+    fn index(self) -> usize {
+        debug_assert!(!self.is_terminal());
+        self.0 as usize
+    }
+}
+
+// Rebind some constants locally so that we don't need as many qualifiers below.
+const ALWAYS_TRUE: ScopedVisibilityConstraintId = ScopedVisibilityConstraintId::ALWAYS_TRUE;
+const AMBIGUOUS: ScopedVisibilityConstraintId = ScopedVisibilityConstraintId::AMBIGUOUS;
+const ALWAYS_FALSE: ScopedVisibilityConstraintId = ScopedVisibilityConstraintId::ALWAYS_FALSE;
+const SMALLEST_TERMINAL: ScopedVisibilityConstraintId = ALWAYS_FALSE;
+
+/// A collection of visibility constraints. This is currently stored in `UseDefMap`, which means we
+/// maintain a separate set of visibility constraints for each scope in file.
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) struct VisibilityConstraints<'db> {
-    constraints: IndexVec<ScopedVisibilityConstraintId, VisibilityConstraint<'db>>,
+    constraints: IndexVec<Atom, Constraint<'db>>,
+    interiors: IndexVec<ScopedVisibilityConstraintId, InteriorNode>,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, Default, PartialEq, Eq)]
 pub(crate) struct VisibilityConstraintsBuilder<'db> {
-    constraints: IndexVec<ScopedVisibilityConstraintId, VisibilityConstraint<'db>>,
-}
-
-impl Default for VisibilityConstraintsBuilder<'_> {
-    fn default() -> Self {
-        Self {
-            constraints: IndexVec::from_iter([
-                VisibilityConstraint(VisibilityConstraintInner::AlwaysTrue),
-                VisibilityConstraint(VisibilityConstraintInner::AlwaysFalse),
-                VisibilityConstraint(VisibilityConstraintInner::Ambiguous),
-            ]),
-        }
-    }
+    constraints: IndexVec<Atom, Constraint<'db>>,
+    interiors: IndexVec<ScopedVisibilityConstraintId, InteriorNode>,
+    constraint_cache: FxHashMap<Constraint<'db>, Atom>,
+    interior_cache: FxHashMap<InteriorNode, ScopedVisibilityConstraintId>,
+    not_cache: FxHashMap<ScopedVisibilityConstraintId, ScopedVisibilityConstraintId>,
+    and_cache: FxHashMap<
+        (ScopedVisibilityConstraintId, ScopedVisibilityConstraintId),
+        ScopedVisibilityConstraintId,
+    >,
+    or_cache: FxHashMap<
+        (ScopedVisibilityConstraintId, ScopedVisibilityConstraintId),
+        ScopedVisibilityConstraintId,
+    >,
 }
 
 impl<'db> VisibilityConstraintsBuilder<'db> {
     pub(crate) fn build(self) -> VisibilityConstraints<'db> {
         VisibilityConstraints {
             constraints: self.constraints,
+            interiors: self.interiors,
         }
     }
 
-    fn add(&mut self, constraint: VisibilityConstraintInner<'db>) -> ScopedVisibilityConstraintId {
-        self.constraints.push(VisibilityConstraint(constraint))
+    /// Returns whether `a` or `b` has a "larger" atom. TDDs are ordered such that interior nodes
+    /// can only have edges to "larger" nodes. Terminals are considered to have a larger atom than
+    /// any internal node, since they are leaf nodes.
+    fn cmp_atoms(
+        &self,
+        a: ScopedVisibilityConstraintId,
+        b: ScopedVisibilityConstraintId,
+    ) -> Ordering {
+        if a == b || (a.is_terminal() && b.is_terminal()) {
+            Ordering::Equal
+        } else if a.is_terminal() {
+            Ordering::Greater
+        } else if b.is_terminal() {
+            Ordering::Less
+        } else {
+            self.interiors[a].atom.cmp(&self.interiors[b].atom)
+        }
     }
 
+    /// Adds a constraint, ensuring that we only store any particular constraint once.
+    fn add_constraint(&mut self, constraint: Constraint<'db>, copy: u8) -> Atom {
+        self.constraint_cache
+            .entry(constraint)
+            .or_insert_with(|| self.constraints.push(constraint))
+            .copy_of(copy)
+    }
+
+    /// Adds an interior node, ensuring that we always use the same visibility constraint ID for
+    /// equal nodes.
+    fn add_interior(&mut self, node: InteriorNode) -> ScopedVisibilityConstraintId {
+        // If the true and false branches lead to the same node, we can override the ambiguous
+        // branch to go there too. And this node is then redundant and can be reduced.
+        if node.if_true == node.if_false {
+            return node.if_true;
+        }
+
+        *self
+            .interior_cache
+            .entry(node)
+            .or_insert_with(|| self.interiors.push(node))
+    }
+
+    /// Adds a new visibility constraint that checks a single [`Constraint`]. Provide different
+    /// values for `copy` if you need to model that the constraint can evaluate to different
+    /// results at different points in the execution of the program being modeled.
     pub(crate) fn add_atom(
         &mut self,
         constraint: Constraint<'db>,
         copy: u8,
     ) -> ScopedVisibilityConstraintId {
-        self.add(VisibilityConstraintInner::VisibleIf(constraint, copy))
+        let atom = self.add_constraint(constraint, copy);
+        self.add_interior(InteriorNode {
+            atom,
+            if_true: ALWAYS_TRUE,
+            if_ambiguous: AMBIGUOUS,
+            if_false: ALWAYS_FALSE,
+        })
     }
 
+    /// Adds a new visibility constraint that is the ternary NOT of an existing one.
     pub(crate) fn add_not_constraint(
         &mut self,
         a: ScopedVisibilityConstraintId,
     ) -> ScopedVisibilityConstraintId {
-        if a == ScopedVisibilityConstraintId::ALWAYS_FALSE {
-            ScopedVisibilityConstraintId::ALWAYS_TRUE
-        } else if a == ScopedVisibilityConstraintId::ALWAYS_TRUE {
-            ScopedVisibilityConstraintId::ALWAYS_FALSE
-        } else if a == ScopedVisibilityConstraintId::AMBIGUOUS {
-            ScopedVisibilityConstraintId::AMBIGUOUS
-        } else {
-            self.add(VisibilityConstraintInner::VisibleIfNot(a))
+        if a == ALWAYS_TRUE {
+            return ALWAYS_FALSE;
+        } else if a == AMBIGUOUS {
+            return AMBIGUOUS;
+        } else if a == ALWAYS_FALSE {
+            return ALWAYS_TRUE;
         }
+
+        if let Some(cached) = self.not_cache.get(&a) {
+            return *cached;
+        }
+        let a_node = self.interiors[a];
+        let if_true = self.add_not_constraint(a_node.if_true);
+        let if_ambiguous = self.add_not_constraint(a_node.if_ambiguous);
+        let if_false = self.add_not_constraint(a_node.if_false);
+        let result = self.add_interior(InteriorNode {
+            atom: a_node.atom,
+            if_true,
+            if_ambiguous,
+            if_false,
+        });
+        self.not_cache.insert(a, result);
+        result
     }
 
+    /// Adds a new visibility constraint that is the ternary OR of two existing ones.
     pub(crate) fn add_or_constraint(
         &mut self,
         a: ScopedVisibilityConstraintId,
         b: ScopedVisibilityConstraintId,
     ) -> ScopedVisibilityConstraintId {
-        if a == ScopedVisibilityConstraintId::ALWAYS_TRUE
-            || b == ScopedVisibilityConstraintId::ALWAYS_TRUE
-        {
-            return ScopedVisibilityConstraintId::ALWAYS_TRUE;
-        } else if a == ScopedVisibilityConstraintId::ALWAYS_FALSE {
-            return b;
-        } else if b == ScopedVisibilityConstraintId::ALWAYS_FALSE {
-            return a;
+        match (a, b) {
+            (ALWAYS_TRUE, _) | (_, ALWAYS_TRUE) => return ALWAYS_TRUE,
+            (ALWAYS_FALSE, other) | (other, ALWAYS_FALSE) => return other,
+            (AMBIGUOUS, AMBIGUOUS) => return AMBIGUOUS,
+            _ => {}
         }
-        match (&self.constraints[a], &self.constraints[b]) {
-            (_, VisibilityConstraint(VisibilityConstraintInner::VisibleIfNot(id))) if a == *id => {
-                ScopedVisibilityConstraintId::ALWAYS_TRUE
-            }
-            (VisibilityConstraint(VisibilityConstraintInner::VisibleIfNot(id)), _) if *id == b => {
-                ScopedVisibilityConstraintId::ALWAYS_TRUE
-            }
-            _ => self.add(VisibilityConstraintInner::KleeneOr(a, b)),
+
+        // OR is commutative, which lets us halve the cache requirements
+        let (a, b) = if b.0 < a.0 { (b, a) } else { (a, b) };
+        if let Some(cached) = self.or_cache.get(&(a, b)) {
+            return *cached;
         }
+
+        let (atom, if_true, if_ambiguous, if_false) = match self.cmp_atoms(a, b) {
+            Ordering::Equal => {
+                let a_node = self.interiors[a];
+                let b_node = self.interiors[b];
+                let if_true = self.add_or_constraint(a_node.if_true, b_node.if_true);
+                let if_false = self.add_or_constraint(a_node.if_false, b_node.if_false);
+                let if_ambiguous = if if_true == if_false {
+                    if_true
+                } else {
+                    self.add_or_constraint(a_node.if_ambiguous, b_node.if_ambiguous)
+                };
+                (a_node.atom, if_true, if_ambiguous, if_false)
+            }
+            Ordering::Less => {
+                let a_node = self.interiors[a];
+                let if_true = self.add_or_constraint(a_node.if_true, b);
+                let if_false = self.add_or_constraint(a_node.if_false, b);
+                let if_ambiguous = if if_true == if_false {
+                    if_true
+                } else {
+                    self.add_or_constraint(a_node.if_ambiguous, b)
+                };
+                (a_node.atom, if_true, if_ambiguous, if_false)
+            }
+            Ordering::Greater => {
+                let b_node = self.interiors[b];
+                let if_true = self.add_or_constraint(a, b_node.if_true);
+                let if_false = self.add_or_constraint(a, b_node.if_false);
+                let if_ambiguous = if if_true == if_false {
+                    if_true
+                } else {
+                    self.add_or_constraint(a, b_node.if_ambiguous)
+                };
+                (b_node.atom, if_true, if_ambiguous, if_false)
+            }
+        };
+
+        let result = self.add_interior(InteriorNode {
+            atom,
+            if_true,
+            if_ambiguous,
+            if_false,
+        });
+        self.or_cache.insert((a, b), result);
+        result
     }
 
+    /// Adds a new visibility constraint that is the ternary AND of two existing ones.
     pub(crate) fn add_and_constraint(
         &mut self,
         a: ScopedVisibilityConstraintId,
         b: ScopedVisibilityConstraintId,
     ) -> ScopedVisibilityConstraintId {
-        if a == ScopedVisibilityConstraintId::ALWAYS_FALSE
-            || b == ScopedVisibilityConstraintId::ALWAYS_FALSE
-        {
-            return ScopedVisibilityConstraintId::ALWAYS_FALSE;
-        } else if a == ScopedVisibilityConstraintId::ALWAYS_TRUE {
-            return b;
-        } else if b == ScopedVisibilityConstraintId::ALWAYS_TRUE {
-            return a;
+        match (a, b) {
+            (ALWAYS_FALSE, _) | (_, ALWAYS_FALSE) => return ALWAYS_FALSE,
+            (ALWAYS_TRUE, other) | (other, ALWAYS_TRUE) => return other,
+            (AMBIGUOUS, AMBIGUOUS) => return AMBIGUOUS,
+            _ => {}
         }
-        match (&self.constraints[a], &self.constraints[b]) {
-            (_, VisibilityConstraint(VisibilityConstraintInner::VisibleIfNot(id))) if a == *id => {
-                ScopedVisibilityConstraintId::ALWAYS_FALSE
-            }
-            (VisibilityConstraint(VisibilityConstraintInner::VisibleIfNot(id)), _) if *id == b => {
-                ScopedVisibilityConstraintId::ALWAYS_FALSE
-            }
-            _ => self.add(VisibilityConstraintInner::KleeneAnd(a, b)),
+
+        // AND is commutative, which lets us halve the cache requirements
+        let (a, b) = if b.0 < a.0 { (b, a) } else { (a, b) };
+        if let Some(cached) = self.and_cache.get(&(a, b)) {
+            return *cached;
         }
+
+        let (atom, if_true, if_ambiguous, if_false) = match self.cmp_atoms(a, b) {
+            Ordering::Equal => {
+                let a_node = self.interiors[a];
+                let b_node = self.interiors[b];
+                let if_true = self.add_and_constraint(a_node.if_true, b_node.if_true);
+                let if_false = self.add_and_constraint(a_node.if_false, b_node.if_false);
+                let if_ambiguous = if if_true == if_false {
+                    if_true
+                } else {
+                    self.add_and_constraint(a_node.if_ambiguous, b_node.if_ambiguous)
+                };
+                (a_node.atom, if_true, if_ambiguous, if_false)
+            }
+            Ordering::Less => {
+                let a_node = self.interiors[a];
+                let if_true = self.add_and_constraint(a_node.if_true, b);
+                let if_false = self.add_and_constraint(a_node.if_false, b);
+                let if_ambiguous = if if_true == if_false {
+                    if_true
+                } else {
+                    self.add_and_constraint(a_node.if_ambiguous, b)
+                };
+                (a_node.atom, if_true, if_ambiguous, if_false)
+            }
+            Ordering::Greater => {
+                let b_node = self.interiors[b];
+                let if_true = self.add_and_constraint(a, b_node.if_true);
+                let if_false = self.add_and_constraint(a, b_node.if_false);
+                let if_ambiguous = if if_true == if_false {
+                    if_true
+                } else {
+                    self.add_and_constraint(a, b_node.if_ambiguous)
+                };
+                (b_node.atom, if_true, if_ambiguous, if_false)
+            }
+        };
+
+        let result = self.add_interior(InteriorNode {
+            atom,
+            if_true,
+            if_ambiguous,
+            if_false,
+        });
+        self.and_cache.insert((a, b), result);
+        result
     }
 }
 
 impl<'db> VisibilityConstraints<'db> {
     /// Analyze the statically known visibility for a given visibility constraint.
-    pub(crate) fn evaluate(&self, db: &'db dyn Db, id: ScopedVisibilityConstraintId) -> Truthiness {
-        self.evaluate_impl(db, id, MAX_RECURSION_DEPTH)
-    }
-
-    fn evaluate_impl(
+    pub(crate) fn evaluate(
         &self,
         db: &'db dyn Db,
-        id: ScopedVisibilityConstraintId,
-        max_depth: usize,
+        mut id: ScopedVisibilityConstraintId,
     ) -> Truthiness {
-        if max_depth == 0 {
-            return Truthiness::Ambiguous;
-        }
-
-        let VisibilityConstraint(visibility_constraint) = &self.constraints[id];
-        match visibility_constraint {
-            VisibilityConstraintInner::AlwaysTrue => Truthiness::AlwaysTrue,
-            VisibilityConstraintInner::AlwaysFalse => Truthiness::AlwaysFalse,
-            VisibilityConstraintInner::Ambiguous => Truthiness::Ambiguous,
-            VisibilityConstraintInner::VisibleIf(constraint, _) => {
-                Self::analyze_single(db, constraint)
-            }
-            VisibilityConstraintInner::VisibleIfNot(negated) => {
-                self.evaluate_impl(db, *negated, max_depth - 1).negate()
-            }
-            VisibilityConstraintInner::KleeneAnd(lhs, rhs) => {
-                let lhs = self.evaluate_impl(db, *lhs, max_depth - 1);
-
-                if lhs == Truthiness::AlwaysFalse {
-                    return Truthiness::AlwaysFalse;
-                }
-
-                let rhs = self.evaluate_impl(db, *rhs, max_depth - 1);
-
-                if rhs == Truthiness::AlwaysFalse {
-                    Truthiness::AlwaysFalse
-                } else if lhs == Truthiness::AlwaysTrue && rhs == Truthiness::AlwaysTrue {
-                    Truthiness::AlwaysTrue
-                } else {
-                    Truthiness::Ambiguous
-                }
-            }
-            VisibilityConstraintInner::KleeneOr(lhs_id, rhs_id) => {
-                let lhs = self.evaluate_impl(db, *lhs_id, max_depth - 1);
-
-                if lhs == Truthiness::AlwaysTrue {
-                    return Truthiness::AlwaysTrue;
-                }
-
-                let rhs = self.evaluate_impl(db, *rhs_id, max_depth - 1);
-
-                if rhs == Truthiness::AlwaysTrue {
-                    Truthiness::AlwaysTrue
-                } else if lhs == Truthiness::AlwaysFalse && rhs == Truthiness::AlwaysFalse {
-                    Truthiness::AlwaysFalse
-                } else {
-                    Truthiness::Ambiguous
-                }
+        loop {
+            let node = match id {
+                ALWAYS_TRUE => return Truthiness::AlwaysTrue,
+                AMBIGUOUS => return Truthiness::Ambiguous,
+                ALWAYS_FALSE => return Truthiness::AlwaysFalse,
+                _ => self.interiors[id],
+            };
+            let constraint = &self.constraints[node.atom];
+            match Self::analyze_single(db, constraint) {
+                Truthiness::AlwaysTrue => id = node.if_true,
+                Truthiness::Ambiguous => id = node.if_ambiguous,
+                Truthiness::AlwaysFalse => id = node.if_false,
             }
         }
     }
@@ -391,15 +617,28 @@ impl<'db> VisibilityConstraints<'db> {
     fn analyze_single(db: &dyn Db, constraint: &Constraint) -> Truthiness {
         match constraint.node {
             ConstraintNode::Expression(test_expr) => {
-                let ty = infer_expression_type(db, test_expr);
+                let inference = infer_expression_types(db, test_expr);
+                let scope = test_expr.scope(db);
+                let ty = inference
+                    .expression_type(test_expr.node_ref(db).scoped_expression_id(db, scope));
 
                 ty.bool(db).negate_if(!constraint.is_positive)
             }
             ConstraintNode::Pattern(inner) => match inner.kind(db) {
                 PatternConstraintKind::Value(value, guard) => {
                     let subject_expression = inner.subject(db);
-                    let subject_ty = infer_expression_type(db, *subject_expression);
-                    let value_ty = infer_expression_type(db, *value);
+                    let inference = infer_expression_types(db, *subject_expression);
+                    let scope = subject_expression.scope(db);
+                    let subject_ty = inference.expression_type(
+                        subject_expression
+                            .node_ref(db)
+                            .scoped_expression_id(db, scope),
+                    );
+
+                    let inference = infer_expression_types(db, *value);
+                    let scope = value.scope(db);
+                    let value_ty = inference
+                        .expression_type(value.node_ref(db).scoped_expression_id(db, scope));
 
                     if subject_ty.is_single_valued(db) {
                         let truthiness =

crates/red_knot_python_semantic/tests/mdtest.rs

@@ -1,6 +1,5 @@
 use camino::Utf8Path;
 use dir_test::{dir_test, Fixture};
-use std::path::Path;
 
 /// See `crates/red_knot_test/README.md` for documentation on these tests.
 #[dir_test(
@@ -9,16 +8,23 @@ use std::path::Path;
 )]
 #[allow(clippy::needless_pass_by_value)]
 fn mdtest(fixture: Fixture<&str>) {
-    let fixture_path = Utf8Path::new(fixture.path());
-    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let absolute_fixture_path = Utf8Path::new(fixture.path());
+    let crate_dir = Utf8Path::new(env!("CARGO_MANIFEST_DIR"));
+    let snapshot_path = crate_dir.join("resources").join("mdtest").join("snapshots");
     let workspace_root = crate_dir.ancestors().nth(2).unwrap();
 
-    let long_title = fixture_path.strip_prefix(workspace_root).unwrap();
-    let short_title = fixture_path.file_name().unwrap();
+    let relative_fixture_path = absolute_fixture_path.strip_prefix(workspace_root).unwrap();
+    let short_title = absolute_fixture_path.file_name().unwrap();
 
-    let test_name = test_name("mdtest", fixture_path);
+    let test_name = test_name("mdtest", absolute_fixture_path);
 
-    red_knot_test::run(fixture_path, long_title.as_str(), short_title, &test_name);
+    red_knot_test::run(
+        absolute_fixture_path,
+        relative_fixture_path,
+        &snapshot_path,
+        short_title,
+        &test_name,
+    );
 }
 
 /// Constructs the test name used for individual markdown files

crates/red_knot_test/Cargo.toml

@@ -18,10 +18,12 @@ ruff_index = { workspace = true }
 ruff_python_trivia = { workspace = true }
 ruff_source_file = { workspace = true }
 ruff_text_size = { workspace = true }
+ruff_python_ast = { workspace = true }
 
 anyhow = { workspace = true }
 camino = { workspace = true }
 colored = { workspace = true }
+insta = { workspace = true, features = ["filters"] }
 memchr = { workspace = true }
 regex = { workspace = true }
 rustc-hash = { workspace = true }

crates/red_knot_test/README.md

@@ -20,7 +20,7 @@ reveal_type(1)  # revealed: Literal[1]
 ````
 
 When running this test, the mdtest framework will write a file with these contents to the default
-file path (`/src/mdtest_snippet__1.py`) in its in-memory file system, run a type check on that file,
+file path (`/src/mdtest_snippet.py`) in its in-memory file system, run a type check on that file,
 and then match the resulting diagnostics with the assertions in the test. Assertions are in the form
 of Python comments. If all diagnostics and all assertions are matched, the test passes; otherwise,
 it fails.
@@ -34,7 +34,8 @@ syntax, it's just how this README embeds an example mdtest Markdown document.)
 See actual example mdtest suites in
 [`crates/red_knot_python_semantic/resources/mdtest`](https://github.com/astral-sh/ruff/tree/main/crates/red_knot_python_semantic/resources/mdtest).
 
-> ℹ️ Note: If you use `dir-test`, `rstest` or similar to generate a separate test for all Markdown files in a certain directory,
+> [!NOTE]
+> If you use `dir-test`, `rstest` or similar to generate a separate test for all Markdown files in a certain directory,
 > as with the example in `crates/red_knot_python_semantic/tests/mdtest.rs`,
 > you will likely want to also make sure that the crate the tests are in is rebuilt every time a
 > Markdown file is added or removed from the directory. See
@@ -126,15 +127,63 @@ Intervening empty lines or non-assertion comments are not allowed; an assertion
 assertion per line, immediately following each other, with the line immediately following the last
 assertion as the line of source code on which the matched diagnostics are emitted.
 
+## Literate style
+
+If multiple code blocks (without an explicit path, see below) are present in a single test, they will
+be merged into a single file in the order they appear in the Markdown file. This allows for tests that
+interleave code and explanations:
+
+````markdown
+# My literate test
+
+This first snippet here:
+
+```py
+from typing import Literal
+
+def f(x: Literal[1]):
+    pass
+```
+
+will be merged with this second snippet here, i.e. `f` is defined here:
+
+```py
+f(2)  # error: [invalid-argument-type]
+```
+````
+
+## Diagnostic Snapshotting
+
+In addition to inline assertions, one can also snapshot the full diagnostic
+output of a test. This is done by adding a `<!-- snapshot-diagnostics -->` directive
+in the corresponding section. For example:
+
+````markdown
+## Unresolvable module import
+
+<!-- snapshot-diagnostics -->
+
+```py
+import zqzqzqzqzqzqzq  # error: [unresolved-import] "Cannot resolve import `zqzqzqzqzqzqzq`"
+```
+````
+
+The `snapshot-diagnostics` directive must appear before anything else in
+the section.
+
+This will use `insta` to manage an external file snapshot of all diagnostic
+output generated.
+
+Inline assertions, as described above, may be used in conjunction with diagnostic
+snapshotting.
+
+At present, there is no way to do inline snapshotting or to request more granular
+snapshotting of specific diagnostics.
+
 ## Multi-file tests
 
-Some tests require multiple files, with imports from one file into another. Multiple fenced code
-blocks represent multiple embedded files. If there are multiple unnamed files, mdtest will name them
-according to the numbered scheme `/src/mdtest_snippet__1.py`, `/src/mdtest_snippet__2.py`, etc. (If
-they are `pyi` files, they will be named with a `pyi` extension instead.)
-
-Tests should not rely on these default names. If a test must import from a file, then it should
-explicitly specify the file name:
+Some tests require multiple files, with imports from one file into another. For this purpose,
+tests can specify explicit file paths in a separate line before the code block (`b.py` below):
 
 ````markdown
 ```py
@@ -155,8 +204,8 @@ is, the equivalent of a runtime entry on `sys.path`).
 The default workspace root is `/src/`. Currently it is not possible to customize this in a test, but
 this is a feature we will want to add in the future.
 
-So the above test creates two files, `/src/mdtest_snippet__1.py` and `/src/b.py`, and sets the
-workspace root to `/src/`, allowing imports from `b.py` using the module name `b`.
+So the above test creates two files, `/src/mdtest_snippet.py` and `/src/b.py`, and sets the workspace
+root to `/src/`, allowing imports from `b.py` using the module name `b`.
 
 ## Multi-test suites
 
@@ -345,6 +394,11 @@ I/O error on read.
 
 ### Asserting on full diagnostic output
 
+> [!NOTE]
+> At present, one can opt into diagnostic snapshotting that is managed via external files. See
+> the section above for more details. The feature outlined below, *inline* diagnostic snapshotting,
+> is still desirable.
+
 The inline comment diagnostic assertions are useful for making quick, readable assertions about
 diagnostics in a particular location. But sometimes we will want to assert on the full diagnostic
 output of checking an embedded Python file. Or sometimes (see “incremental tests” below) we will
@@ -365,7 +419,7 @@ This is just an example, not a proposal that red-knot would ever actually output
 precisely this format:
 
 ```output
-mdtest_snippet__1.py, line 1, col 1: revealed type is 'Literal[1]'
+mdtest_snippet.py, line 1, col 1: revealed type is 'Literal[1]'
 ```
 ````
 
@@ -373,7 +427,7 @@ We will want to build tooling to automatically capture and update these “full
 blocks, when tests are run in an update-output mode (probably specified by an environment variable.)
 
 By default, an `output` block will specify diagnostic output for the file
-`<workspace-root>/mdtest_snippet__1.py`. An `output` block can be prefixed by a
+`<workspace-root>/mdtest_snippet.py`. An `output` block can be prefixed by a
 <code>`&lt;path>`:</code> label as usual, to explicitly specify the Python file for which it asserts
 diagnostic output.
 
@@ -409,7 +463,7 @@ x = 1
 Initial expected output for the unnamed file:
 
 ```output
-/src/mdtest_snippet__1.py, line 1, col 1: revealed type is 'Literal[1]'
+/src/mdtest_snippet.py, line 1, col 1: revealed type is 'Literal[1]'
 ```
 
 Now in our first incremental stage, modify the contents of `b.py`:
@@ -424,12 +478,12 @@ x = 2
 And this is our updated expected output for the unnamed file at stage 1:
 
 ```output stage=1
-/src/mdtest_snippet__1.py, line 1, col 1: revealed type is 'Literal[2]'
+/src/mdtest_snippet.py, line 1, col 1: revealed type is 'Literal[2]'
 ```
 
 (One reason to use full-diagnostic-output blocks in this test is that updating inline-comment
-diagnostic assertions for `mdtest_snippet__1.py` would require specifying new contents for
-`mdtest_snippet__1.py` in stage 1, which we don't want to do in this test.)
+diagnostic assertions for `mdtest_snippet.py` would require specifying new contents for
+`mdtest_snippet.py` in stage 1, which we don't want to do in this test.)
 ````
 
 It will be possible to provide any number of stages in an incremental test. If a stage re-specifies

crates/red_knot_test/src/lib.rs

@@ -1,4 +1,5 @@
 use crate::config::Log;
+use crate::parser::{BacktickOffsets, EmbeddedFileSourceMap};
 use camino::Utf8Path;
 use colored::Colorize;
 use parser as test_parser;
@@ -11,7 +12,6 @@ use ruff_db::parsed::parsed_module;
 use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
 use ruff_db::testing::{setup_logging, setup_logging_with_filter};
 use ruff_source_file::{LineIndex, OneIndexed};
-use ruff_text_size::TextSize;
 use std::fmt::Write;
 
 mod assertion;
@@ -27,12 +27,18 @@ const MDTEST_TEST_FILTER: &str = "MDTEST_TEST_FILTER";
 ///
 /// Panic on test failure, and print failure details.
 #[allow(clippy::print_stdout)]
-pub fn run(path: &Utf8Path, long_title: &str, short_title: &str, test_name: &str) {
-    let source = std::fs::read_to_string(path).unwrap();
+pub fn run(
+    absolute_fixture_path: &Utf8Path,
+    relative_fixture_path: &Utf8Path,
+    snapshot_path: &Utf8Path,
+    short_title: &str,
+    test_name: &str,
+) {
+    let source = std::fs::read_to_string(absolute_fixture_path).unwrap();
     let suite = match test_parser::parse(short_title, &source) {
         Ok(suite) => suite,
         Err(err) => {
-            panic!("Error parsing `{path}`: {err:?}")
+            panic!("Error parsing `{absolute_fixture_path}`: {err:?}")
         }
     };
 
@@ -54,20 +60,23 @@ pub fn run(path: &Utf8Path, long_title: &str, short_title: &str, test_name: &str
         db.memory_file_system().remove_all();
         Files::sync_all(&mut db);
 
-        if let Err(failures) = run_test(&mut db, &test) {
+        if let Err(failures) = run_test(&mut db, relative_fixture_path, snapshot_path, &test) {
             any_failures = true;
             println!("\n{}\n", test.name().bold().underline());
 
             let md_index = LineIndex::from_source_text(&source);
 
             for test_failures in failures {
-                let backtick_line = md_index.line_index(test_failures.backtick_offset);
+                let source_map =
+                    EmbeddedFileSourceMap::new(&md_index, test_failures.backtick_offsets);
 
                 for (relative_line_number, failures) in test_failures.by_line.iter() {
+                    let absolute_line_number =
+                        source_map.to_absolute_line_number(relative_line_number);
+
                     for failure in failures {
-                        let absolute_line_number =
-                            backtick_line.checked_add(relative_line_number).unwrap();
-                        let line_info = format!("{long_title}:{absolute_line_number}").cyan();
+                        let line_info =
+                            format!("{relative_fixture_path}:{absolute_line_number}").cyan();
                         println!("  {line_info} {failure}");
                     }
                 }
@@ -89,7 +98,12 @@ pub fn run(path: &Utf8Path, long_title: &str, short_title: &str, test_name: &str
     assert!(!any_failures, "Some tests failed.");
 }
 
-fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures> {
+fn run_test(
+    db: &mut db::Db,
+    relative_fixture_path: &Utf8Path,
+    snapshot_path: &Utf8Path,
+    test: &parser::MarkdownTest,
+) -> Result<(), Failures> {
     let project_root = db.project_root().to_path_buf();
     let src_path = SystemPathBuf::from("/src");
     let custom_typeshed_path = test.configuration().typeshed().map(SystemPathBuf::from);
@@ -108,11 +122,7 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
                 "Supported file types are: py, pyi, text"
             );
 
-            let full_path = if embedded.path.starts_with('/') {
-                SystemPathBuf::from(embedded.path.clone())
-            } else {
-                project_root.join(&embedded.path)
-            };
+            let full_path = embedded.full_path(&project_root);
 
             if let Some(ref typeshed_path) = custom_typeshed_path {
                 if let Ok(relative_path) = full_path.strip_prefix(typeshed_path.join("stdlib")) {
@@ -124,7 +134,7 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
                 }
             }
 
-            db.write_file(&full_path, embedded.code).unwrap();
+            db.write_file(&full_path, &embedded.code).unwrap();
 
             if !full_path.starts_with(&src_path) || embedded.lang == "text" {
                 // These files need to be written to the file system (above), but we don't run any checks on them.
@@ -135,7 +145,7 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
 
             Some(TestFile {
                 file,
-                backtick_offset: embedded.backtick_offset,
+                backtick_offsets: embedded.backtick_offsets.clone(),
             })
         })
         .collect();
@@ -176,6 +186,10 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
         )
         .expect("Failed to update Program settings in TestDb");
 
+    // When snapshot testing is enabled, this is populated with
+    // all diagnostics. Otherwise it remains empty.
+    let mut snapshot_diagnostics = vec![];
+
     let failures: Failures = test_files
         .into_iter()
         .filter_map(|test_file| {
@@ -214,7 +228,7 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
                     }
                     by_line.push(OneIndexed::from_zero_indexed(0), messages);
                     return Some(FileFailures {
-                        backtick_offset: test_file.backtick_offset,
+                        backtick_offsets: test_file.backtick_offsets,
                         by_line,
                     });
                 }
@@ -224,16 +238,36 @@ fn run_test(db: &mut db::Db, test: &parser::MarkdownTest) -> Result<(), Failures
                 diagnostic
             }));
 
-            match matcher::match_file(db, test_file.file, diagnostics) {
-                Ok(()) => None,
-                Err(line_failures) => Some(FileFailures {
-                    backtick_offset: test_file.backtick_offset,
-                    by_line: line_failures,
-                }),
+            let failure =
+                match matcher::match_file(db, test_file.file, diagnostics.iter().map(|d| &**d)) {
+                    Ok(()) => None,
+                    Err(line_failures) => Some(FileFailures {
+                        backtick_offsets: test_file.backtick_offsets,
+                        by_line: line_failures,
+                    }),
+                };
+            if test.should_snapshot_diagnostics() {
+                snapshot_diagnostics.extend(diagnostics);
             }
+            failure
         })
         .collect();
 
+    if !snapshot_diagnostics.is_empty() {
+        let snapshot =
+            create_diagnostic_snapshot(db, relative_fixture_path, test, snapshot_diagnostics);
+        let name = test.name().replace(' ', "_");
+        insta::with_settings!(
+            {
+                snapshot_path => snapshot_path,
+                input_file => name.clone(),
+                filters => vec![(r"\\", "/")],
+                prepend_module_to_snapshot => false,
+            },
+            { insta::assert_snapshot!(name, snapshot) }
+        );
+    }
+
     if failures.is_empty() {
         Ok(())
     } else {
@@ -245,9 +279,10 @@ type Failures = Vec<FileFailures>;
 
 /// The failures for a single file in a test by line number.
 struct FileFailures {
-    /// The offset of the backticks that starts the code block in the Markdown file
-    backtick_offset: TextSize,
-    /// The failures by lines in the code block.
+    /// Positional information about the code block(s) to reconstruct absolute line numbers.
+    backtick_offsets: Vec<BacktickOffsets>,
+
+    /// The failures by lines in the file.
     by_line: matcher::FailuresByLine,
 }
 
@@ -255,6 +290,58 @@ struct FileFailures {
 struct TestFile {
     file: File,
 
-    // Offset of the backticks that starts the code block in the Markdown file
-    backtick_offset: TextSize,
+    /// Positional information about the code block(s) to reconstruct absolute line numbers.
+    backtick_offsets: Vec<BacktickOffsets>,
+}
+
+fn create_diagnostic_snapshot<D: Diagnostic>(
+    db: &mut db::Db,
+    relative_fixture_path: &Utf8Path,
+    test: &parser::MarkdownTest,
+    diagnostics: impl IntoIterator<Item = D>,
+) -> String {
+    // TODO(ag): Do something better than requiring this
+    // global state to be twiddled everywhere.
+    colored::control::set_override(false);
+
+    let mut snapshot = String::new();
+    writeln!(snapshot).unwrap();
+    writeln!(snapshot, "---").unwrap();
+    writeln!(snapshot, "mdtest name: {}", test.name()).unwrap();
+    writeln!(snapshot, "mdtest path: {relative_fixture_path}").unwrap();
+    writeln!(snapshot, "---").unwrap();
+    writeln!(snapshot).unwrap();
+
+    writeln!(snapshot, "# Python source files").unwrap();
+    writeln!(snapshot).unwrap();
+    for file in test.files() {
+        writeln!(snapshot, "## {}", file.relative_path()).unwrap();
+        writeln!(snapshot).unwrap();
+        // Note that we don't use ```py here because the line numbering
+        // we add makes it invalid Python. This sacrifices syntax
+        // highlighting when you look at the snapshot on GitHub,
+        // but the line numbers are extremely useful for analyzing
+        // snapshots. So we keep them.
+        writeln!(snapshot, "```").unwrap();
+
+        let line_number_width = file.code.lines().count().to_string().len();
+        for (i, line) in file.code.lines().enumerate() {
+            let line_number = i + 1;
+            writeln!(snapshot, "{line_number:>line_number_width$} | {line}").unwrap();
+        }
+        writeln!(snapshot, "```").unwrap();
+        writeln!(snapshot).unwrap();
+    }
+
+    writeln!(snapshot, "# Diagnostics").unwrap();
+    writeln!(snapshot).unwrap();
+    for (i, diag) in diagnostics.into_iter().enumerate() {
+        if i > 0 {
+            writeln!(snapshot).unwrap();
+        }
+        writeln!(snapshot, "```").unwrap();
+        writeln!(snapshot, "{}", diag.display(db)).unwrap();
+        writeln!(snapshot, "```").unwrap();
+    }
+    snapshot
 }

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.9.4"
+version = "0.9.5"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff/tests/lint.rs

@@ -3,9 +3,9 @@
 #![cfg(not(target_family = "wasm"))]
 
 use regex::escape;
-use std::fs;
 use std::process::Command;
 use std::str;
+use std::{fs, path::Path};
 
 use anyhow::Result;
 use assert_fs::fixture::{ChildPath, FileTouch, PathChild};
@@ -2174,3 +2174,211 @@ fn flake8_import_convention_unused_aliased_import() {
         .arg("-")
         .pass_stdin("1"));
 }
+
+#[test]
+fn flake8_import_convention_unused_aliased_import_no_conflict() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(r#"lint.isort.required-imports = ["import pandas as pd"]"#)
+        .args(["--select", "I002,ICN001,F401"])
+        .args(["--stdin-filename", "test.py"])
+        .arg("--unsafe-fixes")
+        .arg("--fix")
+        .arg("-")
+        .pass_stdin("1"));
+}
+
+/// Test that private, old-style `TypeVar` generics
+/// 1. Get replaced with PEP 695 type parameters (UP046, UP047)
+/// 2. Get renamed to remove leading underscores (UP049)
+/// 3. Emit a warning that the standalone type variable is now unused (PYI018)
+/// 4. Remove the now-unused `Generic` import
+#[test]
+fn pep695_generic_rename() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--select", "F401,PYI018,UP046,UP047,UP049"])
+        .args(["--stdin-filename", "test.py"])
+        .arg("--unsafe-fixes")
+        .arg("--fix")
+        .arg("--preview")
+        .arg("--target-version=py312")
+        .arg("-")
+        .pass_stdin(
+            r#"
+from typing import Generic, TypeVar
+_T = TypeVar("_T")
+
+class OldStyle(Generic[_T]):
+    var: _T
+
+def func(t: _T) -> _T:
+    x: _T
+    return x
+"#
+        ),
+        @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+
+    class OldStyle[T]:
+        var: T
+
+    def func[T](t: T) -> T:
+        x: T
+        return x
+
+    ----- stderr -----
+    Found 7 errors (7 fixed, 0 remaining).
+    "
+    );
+}
+
+/// Test that we do not rename two different type parameters to the same name
+/// in one execution of Ruff (autofixing this to `class Foo[T, T]: ...` would
+/// introduce invalid syntax)
+#[test]
+fn type_parameter_rename_isolation() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--select", "UP049"])
+        .args(["--stdin-filename", "test.py"])
+        .arg("--unsafe-fixes")
+        .arg("--fix")
+        .arg("--preview")
+        .arg("--target-version=py312")
+        .arg("-")
+        .pass_stdin(
+            r#"
+class Foo[_T, __T]:
+    pass
+"#
+        ),
+        @r"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+
+    class Foo[T, __T]:
+        pass
+
+    ----- stderr -----
+    test.py:2:14: UP049 Generic class uses private type parameters
+    Found 2 errors (1 fixed, 1 remaining).
+    "
+    );
+}
+
+#[test]
+fn a005_module_shadowing_strict() -> Result<()> {
+    fn create_module(path: &Path) -> Result<()> {
+        fs::create_dir(path)?;
+        fs::File::create(path.join("__init__.py"))?;
+        Ok(())
+    }
+    // construct a directory tree with this structure:
+    // .
+    // ├── abc
+    // │   └── __init__.py
+    // ├── collections
+    // │   ├── __init__.py
+    // │   ├── abc
+    // │   │   └── __init__.py
+    // │   └── foobar
+    // │       └── __init__.py
+    // ├── foobar
+    // │   ├── __init__.py
+    // │   ├── abc
+    // │   │   └── __init__.py
+    // │   └── collections
+    // │       ├── __init__.py
+    // │       ├── abc
+    // │       │   └── __init__.py
+    // │       └── foobar
+    // │           └── __init__.py
+    // ├── ruff.toml
+    // └── urlparse
+    //     └── __init__.py
+
+    let tempdir = TempDir::new()?;
+    let foobar = tempdir.path().join("foobar");
+    create_module(&foobar)?;
+    for base in [&tempdir.path().into(), &foobar] {
+        for dir in ["abc", "collections"] {
+            create_module(&base.join(dir))?;
+        }
+        create_module(&base.join("collections").join("abc"))?;
+        create_module(&base.join("collections").join("foobar"))?;
+    }
+    create_module(&tempdir.path().join("urlparse"))?;
+    // also create a ruff.toml to mark the project root
+    fs::File::create(tempdir.path().join("ruff.toml"))?;
+
+    insta::with_settings!({
+        filters => vec![(r"\\", "/")]
+    }, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .args(STDIN_BASE_OPTIONS)
+            .args(["--select", "A005"])
+            .current_dir(tempdir.path()),
+            @r"
+        success: false
+        exit_code: 1
+        ----- stdout -----
+        abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        collections/__init__.py:1:1: A005 Module `collections` shadows a Python standard-library module
+        collections/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        foobar/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        foobar/collections/__init__.py:1:1: A005 Module `collections` shadows a Python standard-library module
+        foobar/collections/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        Found 6 errors.
+
+        ----- stderr -----
+        ");
+
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .args(STDIN_BASE_OPTIONS)
+            .args(["--select", "A005"])
+            .current_dir(tempdir.path()),
+            @r"
+        success: false
+        exit_code: 1
+        ----- stdout -----
+        abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        collections/__init__.py:1:1: A005 Module `collections` shadows a Python standard-library module
+        collections/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        foobar/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        foobar/collections/__init__.py:1:1: A005 Module `collections` shadows a Python standard-library module
+        foobar/collections/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        Found 6 errors.
+
+        ----- stderr -----
+        ");
+
+        // TODO(brent) Default should currently match the strict version, but after the next minor
+        // release it will match the non-strict version directly above
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .args(STDIN_BASE_OPTIONS)
+            .args(["--select", "A005"])
+            .current_dir(tempdir.path()),
+            @r"
+        success: false
+        exit_code: 1
+        ----- stdout -----
+        abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        collections/__init__.py:1:1: A005 Module `collections` shadows a Python standard-library module
+        collections/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        foobar/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        foobar/collections/__init__.py:1:1: A005 Module `collections` shadows a Python standard-library module
+        foobar/collections/abc/__init__.py:1:1: A005 Module `abc` shadows a Python standard-library module
+        Found 6 errors.
+
+        ----- stderr -----
+        ");
+    });
+
+    Ok(())
+}

crates/ruff/tests/snapshots/lint__flake8_import_convention_unused_aliased_import_no_conflict.snap

@@ -0,0 +1,27 @@
+---
+source: crates/ruff/tests/lint.rs
+info:
+  program: ruff
+  args:
+    - check
+    - "--no-cache"
+    - "--output-format"
+    - concise
+    - "--config"
+    - "lint.isort.required-imports = [\"import pandas as pd\"]"
+    - "--select"
+    - "I002,ICN001,F401"
+    - "--stdin-filename"
+    - test.py
+    - "--unsafe-fixes"
+    - "--fix"
+    - "-"
+  stdin: "1"
+---
+success: true
+exit_code: 0
+----- stdout -----
+import pandas as pd
+1
+----- stderr -----
+Found 1 error (1 fixed, 0 remaining).

crates/ruff_db/Cargo.toml

@@ -30,6 +30,7 @@ glob = { workspace = true }
 ignore = { workspace = true, optional = true }
 matchit = { workspace = true }
 salsa = { workspace = true }
+schemars = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 path-slash = { workspace = true }
 thiserror = { workspace = true }

crates/ruff_db/src/diagnostic.rs

@@ -375,6 +375,50 @@ impl Diagnostic for Box<dyn Diagnostic> {
     }
 }
 
+impl Diagnostic for &'_ dyn Diagnostic {
+    fn id(&self) -> DiagnosticId {
+        (**self).id()
+    }
+
+    fn message(&self) -> Cow<str> {
+        (**self).message()
+    }
+
+    fn file(&self) -> Option<File> {
+        (**self).file()
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        (**self).range()
+    }
+
+    fn severity(&self) -> Severity {
+        (**self).severity()
+    }
+}
+
+impl Diagnostic for std::sync::Arc<dyn Diagnostic> {
+    fn id(&self) -> DiagnosticId {
+        (**self).id()
+    }
+
+    fn message(&self) -> Cow<str> {
+        (**self).message()
+    }
+
+    fn file(&self) -> Option<File> {
+        (**self).file()
+    }
+
+    fn range(&self) -> Option<TextRange> {
+        (**self).range()
+    }
+
+    fn severity(&self) -> Severity {
+        (**self).severity()
+    }
+}
+
 #[derive(Debug)]
 pub struct ParseDiagnostic {
     file: File,

crates/ruff_db/src/system/path.rs

@@ -471,7 +471,13 @@ impl ToOwned for SystemPath {
 /// The path is guaranteed to be valid UTF-8.
 #[repr(transparent)]
 #[derive(Eq, PartialEq, Clone, Hash, PartialOrd, Ord)]
-pub struct SystemPathBuf(Utf8PathBuf);
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(transparent)
+)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub struct SystemPathBuf(#[cfg_attr(feature = "schemars", schemars(with = "String"))] Utf8PathBuf);
 
 impl SystemPathBuf {
     pub fn new() -> Self {
@@ -658,27 +664,6 @@ impl ruff_cache::CacheKey for SystemPathBuf {
     }
 }
 
-#[cfg(feature = "serde")]
-impl serde::Serialize for SystemPath {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.0.serialize(serializer)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for SystemPathBuf {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.0.serialize(serializer)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for SystemPathBuf {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        Utf8PathBuf::deserialize(deserializer).map(SystemPathBuf)
-    }
-}
-
 /// A slice of a virtual path on [`System`](super::System) (akin to [`str`]).
 #[repr(transparent)]
 pub struct SystemVirtualPath(str);

crates/ruff_dev/Cargo.toml

@@ -11,6 +11,7 @@ repository = { workspace = true }
 license = { workspace = true }
 
 [dependencies]
+red_knot_project = { workspace = true, features = ["schemars"] }
 ruff = { workspace = true }
 ruff_diagnostics = { workspace = true }
 ruff_formatter = { workspace = true }

crates/ruff_dev/src/generate_all.rs

@@ -2,7 +2,7 @@
 
 use anyhow::Result;
 
-use crate::{generate_cli_help, generate_docs, generate_json_schema};
+use crate::{generate_cli_help, generate_docs, generate_json_schema, generate_knot_schema};
 
 pub(crate) const REGENERATE_ALL_COMMAND: &str = "cargo dev generate-all";
 
@@ -33,6 +33,7 @@ impl Mode {
 
 pub(crate) fn main(args: &Args) -> Result<()> {
     generate_json_schema::main(&generate_json_schema::Args { mode: args.mode })?;
+    generate_knot_schema::main(&generate_knot_schema::Args { mode: args.mode })?;
     generate_cli_help::main(&generate_cli_help::Args { mode: args.mode })?;
     generate_docs::main(&generate_docs::Args {
         dry_run: args.mode.is_dry_run(),

crates/ruff_dev/src/generate_knot_schema.rs

@@ -0,0 +1,72 @@
+#![allow(clippy::print_stdout, clippy::print_stderr)]
+
+use std::fs;
+use std::path::PathBuf;
+
+use anyhow::{bail, Result};
+use pretty_assertions::StrComparison;
+use schemars::schema_for;
+
+use crate::generate_all::{Mode, REGENERATE_ALL_COMMAND};
+use crate::ROOT_DIR;
+use red_knot_project::metadata::options::Options;
+
+#[derive(clap::Args)]
+pub(crate) struct Args {
+    /// Write the generated table to stdout (rather than to `knot.schema.json`).
+    #[arg(long, default_value_t, value_enum)]
+    pub(crate) mode: Mode,
+}
+
+pub(crate) fn main(args: &Args) -> Result<()> {
+    let schema = schema_for!(Options);
+    let schema_string = serde_json::to_string_pretty(&schema).unwrap();
+    let filename = "knot.schema.json";
+    let schema_path = PathBuf::from(ROOT_DIR).join(filename);
+
+    match args.mode {
+        Mode::DryRun => {
+            println!("{schema_string}");
+        }
+        Mode::Check => {
+            let current = fs::read_to_string(schema_path)?;
+            if current == schema_string {
+                println!("Up-to-date: {filename}");
+            } else {
+                let comparison = StrComparison::new(&current, &schema_string);
+                bail!("{filename} changed, please run `{REGENERATE_ALL_COMMAND}`:\n{comparison}");
+            }
+        }
+        Mode::Write => {
+            let current = fs::read_to_string(&schema_path)?;
+            if current == schema_string {
+                println!("Up-to-date: {filename}");
+            } else {
+                println!("Updating: {filename}");
+                fs::write(schema_path, schema_string.as_bytes())?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+    use std::env;
+
+    use crate::generate_all::Mode;
+
+    use super::{main, Args};
+
+    #[test]
+    fn test_generate_json_schema() -> Result<()> {
+        let mode = if env::var("KNOT_UPDATE_SCHEMA").as_deref() == Ok("1") {
+            Mode::Write
+        } else {
+            Mode::Check
+        };
+        main(&Args { mode })
+    }
+}

crates/ruff_dev/src/main.rs

@@ -13,6 +13,7 @@ mod generate_all;
 mod generate_cli_help;
 mod generate_docs;
 mod generate_json_schema;
+mod generate_knot_schema;
 mod generate_options;
 mod generate_rules_table;
 mod print_ast;
@@ -39,6 +40,8 @@ enum Command {
     GenerateAll(generate_all::Args),
     /// Generate JSON schema for the TOML configuration file.
     GenerateJSONSchema(generate_json_schema::Args),
+    /// Generate JSON schema for the Red Knot TOML configuration file.
+    GenerateKnotSchema(generate_knot_schema::Args),
     /// Generate a Markdown-compatible table of supported lint rules.
     GenerateRulesTable,
     /// Generate a Markdown-compatible listing of configuration options.
@@ -83,6 +86,7 @@ fn main() -> Result<ExitCode> {
     match command {
         Command::GenerateAll(args) => generate_all::main(&args)?,
         Command::GenerateJSONSchema(args) => generate_json_schema::main(&args)?,
+        Command::GenerateKnotSchema(args) => generate_knot_schema::main(&args)?,
         Command::GenerateRulesTable => println!("{}", generate_rules_table::generate()),
         Command::GenerateOptions => println!("{}", generate_options::generate()),
         Command::GenerateCliHelp(args) => generate_cli_help::main(&args)?,

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.9.4"
+version = "0.9.5"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_linter/resources/test/fixtures/airflow/AIR302_names.py

@@ -75,15 +75,10 @@ from airflow.secrets.local_filesystem import LocalFilesystemBackend, load_connec
 from airflow.security.permissions import RESOURCE_DATASET
 from airflow.sensors.base_sensor_operator import BaseSensorOperator
 from airflow.sensors.date_time_sensor import DateTimeSensor
-from airflow.sensors.external_task import (
-    ExternalTaskSensorLink as ExternalTaskSensorLinkFromExternalTask,
-)
 from airflow.sensors.external_task_sensor import (
     ExternalTaskMarker,
     ExternalTaskSensor,
-)
-from airflow.sensors.external_task_sensor import (
-    ExternalTaskSensorLink as ExternalTaskSensorLinkFromExternalTaskSensor,
+    ExternalTaskSensorLink,
 )
 from airflow.sensors.time_delta_sensor import TimeDeltaSensor
 from airflow.timetables.datasets import DatasetOrTimeSchedule
@@ -249,11 +244,13 @@ BaseSensorOperator()
 DateTimeSensor()
 
 # airflow.sensors.external_task
-ExternalTaskSensorLinkFromExternalTask()
-
-# airflow.sensors.external_task_sensor
+ExternalTaskSensorLink()
 ExternalTaskMarker()
 ExternalTaskSensor()
+
+# airflow.sensors.external_task_sensor
+ExternalTaskMarkerFromExternalTaskSensor()
+ExternalTaskSensorFromExternalTaskSensor()
 ExternalTaskSensorLinkFromExternalTaskSensor()
 
 # airflow.sensors.time_delta_sensor

crates/ruff_linter/resources/test/fixtures/flake8_comprehensions/C400.py

@@ -16,6 +16,17 @@ list((2 * x for x in range(3)))
 list(((2 * x for x in range(3))))
 list((((2 * x for x in range(3)))))
 
+# Account for trailing comma in fix
+# See https://github.com/astral-sh/ruff/issues/15852
+list((0 for _ in []),)
+list(
+     (0 for _ in [])
+     # some comments
+     ,
+     # some more
+ )
+
+
 # Not built-in list.
 def list(*args, **kwargs):
     return None

crates/ruff_linter/resources/test/fixtures/flake8_comprehensions/C401.py

@@ -26,6 +26,16 @@ set((2 * x for x in range(3)))
 set(((2 * x for x in range(3))))
 set((((2 * x for x in range(3)))))
 
+# Account for trailing comma in fix
+# See https://github.com/astral-sh/ruff/issues/15852
+set((0 for _ in []),)
+set(
+    (0 for _ in [])
+    # some comments
+    ,
+    # some more
+)
+
 # Not built-in set.
 def set(*args, **kwargs):
     return None

crates/ruff_linter/resources/test/fixtures/flake8_comprehensions/C417_1.py

@@ -0,0 +1,28 @@
+##### https://github.com/astral-sh/ruff/issues/15809
+
+### Errors
+
+def overshadowed_list():
+    list = ...
+    list(map(lambda x: x, []))
+
+
+### No errors
+
+dict(map(lambda k: (k,), a))
+dict(map(lambda k: (k, v, 0), a))
+dict(map(lambda k: [k], a))
+dict(map(lambda k: [k, v, 0], a))
+dict(map(lambda k: {k, v}, a))
+dict(map(lambda k: {k: 0, v: 1}, a))
+
+a = [(1, 2), (3, 4)]
+map(lambda x: [*x, 10], *a)
+map(lambda x: [*x, 10], *a, *b)
+map(lambda x: [*x, 10], a, *b)
+
+
+map(lambda x: x + 10, (a := []))
+list(map(lambda x: x + 10, (a := [])))
+set(map(lambda x: x + 10, (a := [])))
+dict(map(lambda x: (x, 10), (a := [])))

crates/ruff_linter/resources/test/fixtures/flake8_pie/PIE800.py

@@ -70,6 +70,32 @@ foo({**foo, **{"bar": True}})  # PIE800
     ,
 })
 
+{
+    "data": [],
+    ** # Foo
+    (  # Comment
+        { "a": b,
+          # Comment
+          }
+    ) ,
+    c: 9,
+}
+
+
+# https://github.com/astral-sh/ruff/issues/15997
+{"a": [], **{},}
+{"a": [], **({}),}
+
+{"a": [], **{}, 6: 3}
+{"a": [], **({}), 6: 3}
+
+{"a": [], **{
+    # Comment
+}, 6: 3}
+{"a": [], **({
+    # Comment
+}), 6: 3}
+
 
 {**foo,    "bar": True  }  # OK
 

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI019_0.py

@@ -1,4 +1,4 @@
-from typing import TypeVar, Self, Type
+from typing import TypeVar, Self, Type, cast
 
 _S = TypeVar("_S", bound=BadClass)
 _S2 = TypeVar("_S2", BadClass, GoodClass)
@@ -56,7 +56,7 @@ class CustomClassMethod:
 
 _S695 = TypeVar("_S695", bound="PEP695Fix")
 
-# Only .pyi gets fixes, no fixes for .py
+
 class PEP695Fix:
     def __new__[S: PEP695Fix](cls: type[S]) -> S: ...
 
@@ -139,3 +139,38 @@ class NoReturnAnnotations:
 class MultipleBoundParameters:
     def m[S: int, T: int](self: S, other: T) -> S: ...
     def n[T: (int, str), S: (int, str)](self: S, other: T) -> S: ...
+
+class MethodsWithBody:
+    def m[S](self: S, other: S) -> S:
+        x: S = other
+        return x
+
+    @classmethod
+    def n[S](cls: type[S], other: S) -> S:
+        x: type[S] = type(other)
+        return x()
+
+class StringizedReferencesCanBeFixed:
+    def m[S](self: S) -> S:
+        x = cast("list[tuple[S, S]]", self)
+        return x
+
+class ButStrangeStringizedReferencesCannotBeFixed:
+    def m[_T](self: _T) -> _T:
+        x = cast('list[_\x54]', self)
+        return x
+
+class DeletionsAreNotTouched:
+    def m[S](self: S) -> S:
+        # `S` is not a local variable here, and `del` can only be used with local variables,
+        # so `del S` here is not actually a reference to the type variable `S`.
+        # This `del` statement is therefore not touched by the autofix (it raises `UnboundLocalError`
+        # both before and after the autofix)
+        del S
+        return self
+
+class NamesShadowingTypeVarAreNotTouched:
+    def m[S](self: S) -> S:
+        type S = int
+        print(S)  # not a reference to the type variable, so not touched by the autofix
+        return 42

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI019_0.pyi

@@ -56,7 +56,7 @@ class CustomClassMethod:
 
 _S695 = TypeVar("_S695", bound="PEP695Fix")
 
-# Only .pyi gets fixes, no fixes for .py
+
 class PEP695Fix:
     def __new__[S: PEP695Fix](cls: type[S]) -> S: ...
 

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py

@@ -2,6 +2,8 @@
 # Positive cases
 ###
 
+a_dict = {}
+
 # SIM401 (pattern-1)
 if key in a_dict:
     var = a_dict[key]
@@ -26,6 +28,8 @@ if keys[idx] in a_dict:
 else:
     var = "default"
 
+dicts = {"key": a_dict}
+
 # SIM401 (complex expression in dict)
 if key in dicts[idx]:
     var = dicts[idx][key]
@@ -115,6 +119,28 @@ elif key in a_dict:
 else:
     vars[idx] = "default"
 
+class NotADictionary:
+    def __init__(self):
+        self._dict = {}
+
+    def __getitem__(self, key):
+        return self._dict[key]
+
+    def __setitem__(self, key, value):
+        self._dict[key] = value
+
+    def __iter__(self):
+        return self._dict.__iter__()
+
+not_dict = NotADictionary()
+not_dict["key"] = "value"
+
+# OK (type `NotADictionary` is not a known dictionary type)
+if "key" in not_dict:
+    value = not_dict["key"]
+else:
+    value = None
+
 ###
 # Positive cases (preview)
 ###

crates/ruff_linter/resources/test/fixtures/pep8_naming/N801.py

@@ -6,6 +6,10 @@ class _bad:
     pass
 
 
+class __bad:
+    pass
+
+
 class bad_class:
     pass
 
@@ -13,6 +17,8 @@ class bad_class:
 class Bad_Class:
     pass
 
+class Bad__Class:
+    pass
 
 class BAD_CLASS:
     pass
@@ -32,3 +38,6 @@ class GoodClass:
 
 class GOOD:
     pass
+
+class __GoodClass:
+    pass

crates/ruff_linter/resources/test/fixtures/pep8_naming/N803.py

@@ -9,3 +9,21 @@ class Class:
 
 def func(_, setUp):
     return _, setUp
+
+
+from typing import override
+
+class Extended(Class):
+    @override
+    def method(self, _, a, A): ...
+
+
+@override  # Incorrect usage
+def func(_, a, A): ...
+
+
+func = lambda _, a, A: ...
+
+
+class Extended(Class):
+    method = override(lambda self, _, a, A: ...)  # Incorrect usage

crates/ruff_linter/resources/test/fixtures/pycodestyle/E402_4.py

@@ -0,0 +1,7 @@
+import os
+import sys
+
+sys.path += [os.path.dirname(__file__)]
+sys.path += ["../"]
+
+from package import module

crates/ruff_linter/resources/test/fixtures/pylint/bad_str_strip_call.py

@@ -64,10 +64,42 @@ u''.strip('http://')
 u''.lstrip('http://')
 
 # PLE1310
-b''.rstrip('http://')
+b''.rstrip(b'http://')
 
 # OK
 ''.strip('Hi')
 
 # OK
 ''.strip()
+
+
+### https://github.com/astral-sh/ruff/issues/15968
+
+# Errors: Multiple backslashes
+''.strip('\\b\\x09')
+''.strip(r'\b\x09')
+''.strip('\\\x5C')
+
+# OK: Different types
+b"".strip("//")
+"".strip(b"//")
+
+# OK: Escapes
+'\\test'.strip('\\')
+
+# OK: Extra/missing arguments
+"".strip("//", foo)
+b"".lstrip(b"//", foo = "bar")
+"".rstrip()
+
+# OK: Not literals
+foo: str = ""; bar: bytes = b""
+"".strip(foo)
+b"".strip(bar)
+
+# False negative
+foo.rstrip("//")
+bar.lstrip(b"//")
+
+# OK: Not `.[lr]?strip`
+"".mobius_strip("")

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP040.py

@@ -113,3 +113,18 @@ PositiveList = TypeAliasType(
         Annotated[T, Gt(0)],  # preserved comment
     ], type_params=(T,)
 )
+
+T: TypeAlias = (
+    int
+    | str
+)
+
+T: TypeAlias = ( # comment0
+    # comment1
+    int  # comment2
+    # comment3
+    | # comment4
+    # comment5
+    str  # comment6
+    # comment7
+) # comment8

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP040.pyi

@@ -12,3 +12,13 @@ x: TypeAlias = tuple[
     int,  # preserved
     float,
 ]
+
+T: TypeAlias = ( # comment0
+    # comment1
+    int  # comment2
+    # comment3
+    | # comment4
+    # comment5
+    str  # comment6
+    # comment7
+) # comment8

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP049_0.py

@@ -0,0 +1,30 @@
+# simple case, replace _T in signature and body
+class Generic[_T]:
+    buf: list[_T]
+
+    def append(self, t: _T):
+        self.buf.append(t)
+
+
+# simple case, replace _T in signature and body
+def second[_T](var: tuple[_T]) -> _T:
+    y: _T = var[1]
+    return y
+
+
+# one diagnostic for each variable, comments are preserved
+def many_generics[
+    _T,  # first generic
+    _U,  # second generic
+](args):
+    return args
+
+
+# neither of these are currently renamed
+from typing import Literal, cast
+
+
+def f[_T](v):
+    cast("_T", v)
+    cast("Literal['_T']")
+    cast("list[_T]", v)

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP049_1.py

@@ -0,0 +1,105 @@
+# bound
+class Foo[_T: str]:
+    var: _T
+
+
+# constraint
+class Foo[_T: (str, bytes)]:
+    var: _T
+
+
+# python 3.13+ default
+class Foo[_T = int]:
+    var: _T
+
+
+# tuple
+class Foo[*_Ts]:
+    var: tuple[*_Ts]
+
+
+# paramspec
+class C[**_P]:
+    var: _P
+
+
+from typing import Callable
+
+
+# each of these will get a separate diagnostic, but at least they'll all get
+# fixed
+class Everything[_T, _U: str, _V: (int, float), *_W, **_X]:
+    @staticmethod
+    def transform(t: _T, u: _U, v: _V) -> tuple[*_W] | Callable[_X, _T] | None:
+        return None
+
+
+# this should not be fixed because the new name is a keyword, but we still
+# offer a diagnostic
+class F[_async]: ...
+
+
+# and this should not be fixed because of the conflict with the outer X, but it
+# also gets a diagnostic
+def f():
+    type X = int
+
+    class ScopeConflict[_X]:
+        var: _X
+        x: X
+
+
+# these cases should be skipped entirely
+def f[_](x: _) -> _: ...
+def g[__](x: __) -> __: ...
+def h[_T_](x: _T_) -> _T_: ...
+def i[__T__](x: __T__) -> __T__: ...
+
+
+# https://github.com/astral-sh/ruff/issues/16024
+
+from typing import cast, Literal
+
+
+class C[_0]: ...
+
+
+class C[T, _T]: ...
+class C[_T, T]: ...
+
+
+class C[_T]:
+    v1 = cast(_T, ...)
+    v2 = cast('_T', ...)
+    v3 = cast("\u005fT", ...)
+
+    def _(self):
+        v1 = cast(_T, ...)
+        v2 = cast('_T', ...)
+        v3 = cast("\u005fT", ...)
+
+
+class C[_T]:
+    v = cast('Literal[\'foo\'] | _T', ...)
+
+
+## Name collision
+class C[T]:
+    def f[_T](self):  # No fix, collides with `T` from outer scope
+        v1 = cast(_T, ...)
+        v2 = cast('_T', ...)
+
+
+# Unfixable as the new name collides with a variable visible from one of the inner scopes
+class C[_T]:
+    T = 42
+
+    v1 = cast(_T, ...)
+    v2 = cast('_T', ...)
+
+
+# Unfixable as the new name collides with a variable visible from one of the inner scopes
+class C[_T]:
+    def f[T](self):
+        v1 = cast(_T, ...)
+        v2 = cast('_T', ...)

crates/ruff_linter/resources/test/fixtures/refurb/FURB122.py

@@ -76,6 +76,27 @@ def _():
             f.write(())
 
 
+def _():
+    # https://github.com/astral-sh/ruff/issues/15936
+    with open("file", "w") as f:
+        for char in "a", "b":
+            f.write(char)
+
+def _():
+    # https://github.com/astral-sh/ruff/issues/15936
+    with open("file", "w") as f:
+        for char in "a", "b":
+            f.write(f"{char}")
+
+def _():
+    with open("file", "w") as f:
+        for char in (
+            "a",  # Comment
+            "b"
+        ):
+            f.write(f"{char}")
+
+
 # OK
 
 def _():

crates/ruff_linter/resources/test/fixtures/refurb/FURB142.py

@@ -31,6 +31,20 @@ for x in (1, 2, 3):
 for x in (1, 2, 3):
     s.add(x + num)
 
+# https://github.com/astral-sh/ruff/issues/15936
+for x in 1, 2, 3:
+    s.add(x)
+
+for x in 1, 2, 3:
+    s.add(f"{x}")
+
+for x in (
+    1,  # Comment
+    2, 3
+):
+    s.add(f"{x}")
+
+
 # False negative
 
 class C:
@@ -41,6 +55,7 @@ c = C()
 for x in (1, 2, 3):
     c.s.add(x)
 
+
 # Ok
 
 s.update(x for x in (1, 2, 3))

crates/ruff_linter/resources/test/fixtures/refurb/FURB169.py

@@ -26,6 +26,23 @@ type(None) != type(foo)
 
 type(None) != type(None)
 
+type(a.b) is type(None)
+
+type(
+    a(
+        # Comment
+    )
+) != type(None)
+
+type(
+    a := 1
+) == type(None)
+
+type(
+    a for a in range(0)
+) is not type(None)
+
+
 # Ok.
 
 foo is None

crates/ruff_linter/resources/test/fixtures/ruff/RUF008.py

@@ -23,3 +23,14 @@ class B:
     correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT
     perfectly_fine: list[int] = field(default_factory=list)
     class_variable: ClassVar[list[int]] = []
+
+# Lint should account for deferred annotations
+# See https://github.com/astral-sh/ruff/issues/15857
+@dataclass
+class AWithQuotes:
+    mutable_default: 'list[int]' = []
+    immutable_annotation: 'typing.Sequence[int]' = []
+    without_annotation = []
+    correct_code: 'list[int]' = KNOWINGLY_MUTABLE_DEFAULT
+    perfectly_fine: 'list[int]' = field(default_factory=list)
+    class_variable: 'typing.ClassVar[list[int]]'= []

crates/ruff_linter/resources/test/fixtures/ruff/RUF008_deferred.py

@@ -0,0 +1,19 @@
+# Lint should account for deferred annotations
+# See https://github.com/astral-sh/ruff/issues/15857
+
+from __future__ import annotations
+
+import typing
+from dataclasses import dataclass
+
+
+@dataclass
+class Example():
+    """Class that uses ClassVar."""
+
+    options: ClassVar[dict[str, str]] = {}
+
+
+if typing.TYPE_CHECKING:
+    from typing import ClassVar
+

crates/ruff_linter/resources/test/fixtures/ruff/RUF009_deferred.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass 
+from typing import TYPE_CHECKING
+
+
+def default_function() ->list[int]:
+    return []
+
+@dataclass()
+class A:
+    hidden_mutable_default: list[int] = default_function()
+    class_variable: typing.ClassVar[list[int]] = default_function()
+    another_class_var: ClassVar[list[int]] = default_function()
+
+if TYPE_CHECKING:
+    from typing import ClassVar

crates/ruff_linter/resources/test/fixtures/ruff/RUF012.py

@@ -103,3 +103,18 @@ class K(SQLModel):
 class L(SQLModel):
     id: int
     i_j: list[K] = list()
+
+# Lint should account for deferred annotations
+# See https://github.com/astral-sh/ruff/issues/15857
+class AWithQuotes:
+    __slots__ = {
+        "mutable_default": "A mutable default value",
+    }
+
+    mutable_default: 'list[int]' = []
+    immutable_annotation: 'Sequence[int]'= []
+    without_annotation = []
+    class_variable: 'ClassVar[list[int]]' = []
+    final_variable: 'Final[list[int]]' = []
+    class_variable_without_subscript: 'ClassVar' = []
+    final_variable_without_subscript: 'Final' = []

crates/ruff_linter/resources/test/fixtures/ruff/RUF012_deferred.py

@@ -0,0 +1,16 @@
+# Lint should account for deferred annotations
+# See https://github.com/astral-sh/ruff/issues/15857
+
+from __future__ import annotations
+
+import typing
+
+
+class Example():
+    """Class that uses ClassVar."""
+
+    options: ClassVar[dict[str, str]] = {}
+
+
+if typing.TYPE_CHECKING:
+    from typing import ClassVar

crates/ruff_linter/resources/test/fixtures/ruff/RUF052.py

@@ -176,3 +176,22 @@ class Node:
         _seen.add(self)
         for other in self.connected:
             other.recurse(_seen=_seen)
+
+
+def foo():
+    _dummy_var = 42
+
+    def bar():
+        dummy_var = 43
+        print(_dummy_var)
+
+
+def foo():
+    # Unfixable because both possible candidates for the new name are shadowed
+    # in the scope of one of the references to the variable
+    _dummy_var = 42
+
+    def bar():
+        dummy_var = 43
+        dummy_var_ = 44
+        print(_dummy_var)

crates/ruff_linter/resources/test/fixtures/ruff/RUF053.py

@@ -0,0 +1,109 @@
+from typing import Generic, ParamSpec, TypeVar, TypeVarTuple, Unpack
+
+
+_A = TypeVar('_A')
+_B = TypeVar('_B', bound=int)
+_C = TypeVar('_C', str, bytes)
+_D = TypeVar('_D', default=int)
+_E = TypeVar('_E', bound=int, default=int)
+_F = TypeVar('_F', str, bytes, default=str)
+_G = TypeVar('_G', str, a := int)
+
+_As = TypeVarTuple('_As')
+_Bs = TypeVarTuple('_Bs', bound=tuple[int, str])
+_Cs = TypeVarTuple('_Cs', default=tuple[int, str])
+
+_P1 = ParamSpec('_P1')
+_P2 = ParamSpec('_P2', bound=[bytes, bool])
+_P3 = ParamSpec('_P3', default=[int, str])
+
+
+### Errors
+
+class C[T](Generic[_A]): ...
+class C[T](Generic[_B], str): ...
+class C[T](int, Generic[_C]): ...
+class C[T](bytes, Generic[_D], bool): ...  # TODO: Type parameter defaults
+class C[T](Generic[_E], list[_E]): ...  # TODO: Type parameter defaults
+class C[T](list[_F], Generic[_F]): ...  # TODO: Type parameter defaults
+
+class C[*Ts](Generic[*_As]): ...
+class C[*Ts](Generic[Unpack[_As]]): ...
+class C[*Ts](Generic[Unpack[_Bs]], tuple[*Bs]): ...
+class C[*Ts](Callable[[*_Cs], tuple[*Ts]], Generic[_Cs]): ...  # TODO: Type parameter defaults
+
+
+class C[**P](Generic[_P1]): ...
+class C[**P](Generic[_P2]): ...
+class C[**P](Generic[_P3]): ...  # TODO: Type parameter defaults
+
+
+class C[T](Generic[T, _A]): ...
+
+
+# See `is_existing_param_of_same_class`.
+# `expr_name_to_type_var` doesn't handle named expressions,
+# only simple assignments, so there is no fix.
+class C[T: (_Z := TypeVar('_Z'))](Generic[_Z]): ...
+
+
+class C(Generic[_B]):
+    class D[T](Generic[_B, T]): ...
+
+
+class C[T]:
+    class D[U](Generic[T, U]): ...
+
+
+# In a single run, only the first is reported.
+# Others will be reported/fixed in following iterations.
+class C[T](Generic[_C], Generic[_D]): ...
+class C[T, _C: (str, bytes)](Generic[_D]): ...  # TODO: Type parameter defaults
+
+
+class C[
+T  # Comment
+](Generic[_E]): ...  # TODO: Type parameter defaults
+
+
+class C[T](Generic[Generic[_F]]): ...
+class C[T](Generic[Unpack[_A]]): ...
+class C[T](Generic[Unpack[_P1]]): ...
+class C[T](Generic[Unpack[Unpack[_P2]]]): ...
+class C[T](Generic[Unpack[*_As]]): ...
+class C[T](Generic[Unpack[_As, _Bs]]): ...
+
+
+class C[T](Generic[_A, _A]): ...
+class C[T](Generic[_A, Unpack[_As]]): ...
+class C[T](Generic[*_As, _A]): ...
+
+
+from somewhere import APublicTypeVar
+class C[T](Generic[APublicTypeVar]): ...
+class C[T](Generic[APublicTypeVar, _A]): ...
+
+
+# `_G` has two constraints: `str` and `a := int`.
+# The latter cannot be used as a PEP 695 constraint,
+# as named expressions are forbidden within type parameter lists.
+# See also the `_Z` example above.
+class C[T](Generic[_G]): ...  # Should be moved down below eventually
+
+
+# Single-element constraints should not be converted to a bound.
+class C[T: (str,)](Generic[_A]): ...
+class C[T: [a]](Generic[_A]): ...
+
+
+# Existing bounds should not be deparenthesized.
+# class C[T: (_Y := int)](Generic[_A]): ...  # TODO: Uncomment this
+# class C[T: (*a,)](Generic[_A]): ...        # TODO: Uncomment this
+
+
+### No errors
+
+class C(Generic[_A]): ...
+class C[_A]: ...
+class C[_A](list[_A]): ...
+class C[_A](list[Generic[_A]]): ...