Merge remote-tracking branch 'origin/main' into dcreager/special-class

* origin/main:
  [red-knot] Default `python-platform` to current platform (#17183)
  [red-knot] Add new 'unreachable code' test case (#17306)
  [red-knot] mypy_primer: Run on `async-utils` (#17303)
  [red-knot] Add custom `__setattr__` support (#16748)
  [red-knot] Add `__init__` arguments check when doing `try_call` on a class literal (#16512)
  [`flake8-pie`] Avoid false positive for multiple assignment with `auto()` (`PIE796`) (#17274)
  [syntax-errors] Async comprehension in sync comprehension (#17177)
  [`airflow`] Expand module path check to individual symbols (`AIR302`) (#17278)
  [syntax-errors] Check annotations in annotated assignments (#17283)
  [syntax-errors] Extend annotation checks to `await` (#17282)
  [red-knot] Add support for `assert_never` (#17287)
  [`flake8-pytest-style`] Avoid false positive for legacy form of `pytest.raises` (`PT011`) (#17231)
  [red-knot] Do not show types for literal expressions on hover (#17290)
  [red-knot] Fix dead-code clippy warning (#17291)
  [red-knot] Reachability analysis (#17199)
  [red-knot] Don't use latency-sensitive for handlers (#17227)

Author: dcreager

.github/workflows/mypy_primer.yaml

@@ -45,7 +45,7 @@ jobs:
 
       - name: Install mypy_primer
         run: |
-          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support-v3"
+          uv tool install "git+https://github.com/astral-sh/mypy_primer.git@add-red-knot-support-v4"
 
       - name: Run mypy_primer
         shell: bash
@@ -68,7 +68,7 @@ jobs:
             --type-checker knot \
             --old base_commit \
             --new "$GITHUB_SHA" \
-            --project-selector '/(mypy_primer|black|pyp|git-revise|zipp|arrow|isort|itsdangerous|rich|packaging|pybind11|pyinstrument|typeshed-stats|scrapy|werkzeug|bidict)$' \
+            --project-selector '/(mypy_primer|black|pyp|git-revise|zipp|arrow|isort|itsdangerous|rich|packaging|pybind11|pyinstrument|typeshed-stats|scrapy|werkzeug|bidict|async-utils)$' \
             --output concise \
             --debug > mypy_primer.diff || [ $? -eq 1 ]
 

crates/red_knot/src/args.rs

@@ -75,7 +75,8 @@ pub(crate) struct CheckCommand {
     ///
     /// This is used to specialize the type of `sys.platform` and will affect the visibility
     /// of platform-specific functions and attributes. If the value is set to `all`, no
-    /// assumptions are made about the target platform.
+    /// assumptions are made about the target platform. If unspecified, the current system's
+    /// platform will be used.
     #[arg(long, value_name = "PLATFORM", alias = "platform")]
     pub(crate) python_platform: Option<String>,
 

crates/red_knot_ide/src/hover.rs

@@ -1,4 +1,4 @@
-use crate::goto::find_goto_target;
+use crate::goto::{find_goto_target, GotoTarget};
 use crate::{Db, MarkupKind, RangedValue};
 use red_knot_python_semantic::types::Type;
 use red_knot_python_semantic::SemanticModel;
@@ -12,6 +12,12 @@ pub fn hover(db: &dyn Db, file: File, offset: TextSize) -> Option<RangedValue<Ho
     let parsed = parsed_module(db.upcast(), file);
     let goto_target = find_goto_target(parsed, offset)?;
 
+    if let GotoTarget::Expression(expr) = goto_target {
+        if expr.is_literal_expr() {
+            return None;
+        }
+    }
+
     let model = SemanticModel::new(db.upcast(), file);
     let ty = goto_target.inferred_type(&model)?;
 
@@ -496,6 +502,57 @@ mod tests {
         ");
     }
 
+    #[test]
+    fn hover_whitespace() {
+        let test = cursor_test(
+            r#"
+        class C:
+            <CURSOR>
+            foo: str = 'bar'
+        "#,
+        );
+
+        assert_snapshot!(test.hover(), @"Hover provided no content");
+    }
+
+    #[test]
+    fn hover_literal_int() {
+        let test = cursor_test(
+            r#"
+        print(
+            0 + 1<CURSOR>
+        )
+        "#,
+        );
+
+        assert_snapshot!(test.hover(), @"Hover provided no content");
+    }
+
+    #[test]
+    fn hover_literal_ellipsis() {
+        let test = cursor_test(
+            r#"
+        print(
+            .<CURSOR>..
+        )
+        "#,
+        );
+
+        assert_snapshot!(test.hover(), @"Hover provided no content");
+    }
+
+    #[test]
+    fn hover_docstring() {
+        let test = cursor_test(
+            r#"
+        def f():
+            """Lorem ipsum dolor sit amet.<CURSOR>"""
+        "#,
+        );
+
+        assert_snapshot!(test.hover(), @"Hover provided no content");
+    }
+
     impl CursorTest {
         fn hover(&self) -> String {
             use std::fmt::Write;

crates/red_knot_project/src/metadata/options.rs

@@ -54,20 +54,25 @@ impl Options {
         project_root: &SystemPath,
         system: &dyn System,
     ) -> ProgramSettings {
-        let (python_version, python_platform) = self
+        let python_version = self
             .environment
             .as_ref()
-            .map(|env| {
-                (
-                    env.python_version.as_deref().copied(),
-                    env.python_platform.as_deref(),
-                )
-            })
+            .and_then(|env| env.python_version.as_deref().copied())
             .unwrap_or_default();
-
+        let python_platform = self
+            .environment
+            .as_ref()
+            .and_then(|env| env.python_platform.as_deref().cloned())
+            .unwrap_or_else(|| {
+                let default = PythonPlatform::default();
+                tracing::info!(
+                    "Defaulting to default python version for this platform: '{default}'",
+                );
+                default
+            });
         ProgramSettings {
-            python_version: python_version.unwrap_or_default(),
-            python_platform: python_platform.cloned().unwrap_or_default(),
+            python_version,
+            python_platform,
             search_paths: self.to_search_path_settings(project_root, system),
         }
     }
@@ -237,7 +242,12 @@ pub struct EnvironmentOptions {
     /// 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.
+    /// If no platform is specified, knot will use the current platform:
+    /// - `win32` for Windows
+    /// - `darwin` for macOS
+    /// - `android` for Android
+    /// - `ios` for iOS
+    /// - `linux` for everything else
     #[serde(skip_serializing_if = "Option::is_none")]
     pub python_platform: Option<RangedValue<PythonPlatform>>,
 

crates/red_knot_python_semantic/resources/mdtest/annotations/new_types.md

@@ -8,7 +8,11 @@ Currently, red-knot doesn't support `typing.NewType` in type annotations.
 from typing_extensions import NewType
 from types import GenericAlias
 
+X = GenericAlias(type, ())
 A = NewType("A", int)
+# TODO: typeshed for `typing.GenericAlias` uses `type` for the first argument. `NewType` should be special-cased
+# to be compatible with `type`
+# error: [invalid-argument-type] "Object of type `NewType` cannot be assigned to parameter 2 (`origin`) of function `__new__`; expected type `type`"
 B = GenericAlias(A, ())
 
 def _(

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -1395,6 +1395,59 @@ def _(ns: argparse.Namespace):
     reveal_type(ns.whatever)  # revealed: Any
 ```
 
+## Classes with custom `__setattr__` methods
+
+### Basic
+
+If a type provides a custom `__setattr__` method, we use the parameter type of that method as the
+type to validate attribute assignments. Consider the following `CustomSetAttr` class:
+
+```py
+class CustomSetAttr:
+    def __setattr__(self, name: str, value: int) -> None:
+        pass
+```
+
+We can set arbitrary attributes on instances of this class:
+
+```py
+c = CustomSetAttr()
+
+c.whatever = 42
+```
+
+### Type of the `name` parameter
+
+If the `name` parameter of the `__setattr__` method is annotated with a (union of) literal type(s),
+we only consider the attribute assignment to be valid if the assigned attribute is one of them:
+
+```py
+from typing import Literal
+
+class Date:
+    def __setattr__(self, name: Literal["day", "month", "year"], value: int) -> None:
+        pass
+
+date = Date()
+date.day = 8
+date.month = 4
+date.year = 2025
+
+# error: [unresolved-attribute] "Can not assign object of `Literal["UTC"]` to attribute `tz` on type `Date` with custom `__setattr__` method."
+date.tz = "UTC"
+```
+
+### `argparse.Namespace`
+
+A standard library example of a class with a custom `__setattr__` method is `argparse.Namespace`:
+
+```py
+import argparse
+
+def _(ns: argparse.Namespace):
+    ns.whatever = 42
+```
+
 ## Objects of all types have a `__class__` method
 
 The type of `x.__class__` is the same as `x`'s meta-type. `x.__class__` is always the same value as