[ty] Validate PEP 695 type alias scope and redeclaration rules

Author: charliermarsh

crates/ty/docs/rules.md

@@ -579,6 +579,7 @@ def f(x: int):
     # error: [invalid-super-argument] "`int` is not a valid class"
     super(x, x)
 
+    # error: [invalid-type-alias] "`type` statements are not allowed in function scopes"
     type IntAlias = int
     # error: [invalid-super-argument] "`TypeAliasType` is not a valid class"
     super(IntAlias, 0)

crates/ty_python_semantic/resources/mdtest/class/super.md

@@ -321,11 +321,13 @@ python-version = "3.12"
 
 ```py
 def _():
+    # error: [invalid-type-alias] "`type` statements are not allowed in function scopes"
     # error: [invalid-type-form] "`yield` expressions are not allowed in type expressions"
     # error: [invalid-syntax] "yield expression cannot be used within a TypeVar bound"
     type X[T: (yield 1)] = int
 
 def _():
+    # error: [invalid-type-alias] "`type` statements are not allowed in function scopes"
     # error: [invalid-type-form] "`yield` expressions are not allowed in type expressions"
     # error: [invalid-syntax] "yield expression cannot be used within a type alias"
     type Y = (yield 1)

crates/ty_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md

@@ -251,9 +251,9 @@ def _(g: G):
 Unless a type default was provided:
 
 ```py
-type G[T = int] = list[T]
+type GWithDefault[T = int] = list[T]
 
-def _(g: G):
+def _(g: GWithDefault):
     reveal_type(g)  # revealed: list[int]
 ```
 
@@ -268,9 +268,9 @@ A self-referential default that does not reference itself in the alias body shou
 even when the default is evaluated (e.g., by omitting the type argument):
 
 ```py
-type B[T = B] = list[T]
+type SelfDefaultB[T = SelfDefaultB] = list[T]
 
-def _(x: B) -> None:
+def _(x: SelfDefaultB) -> None:
     pass
 ```
 
@@ -427,12 +427,12 @@ reveal_type(get_value(d, "a"))  # revealed: int
 It also works in the reverse direction, where the type alias is used as the argument type:
 
 ```py
-type MyList[T] = list[T]
+type MyListAlias[T] = list[T]
 
 def head[T](l: list[T]) -> T:
     return l[0]
 
-def _(x: MyList[int]):
+def _(x: MyListAlias[int]):
     reveal_type(head(x))  # revealed: int
 ```
 

crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md

@@ -123,12 +123,29 @@ class Foo:
 But narrowing of names used in the type alias is still respected:
 
 ```py
-def _(flag: bool):
-    t = int if flag else None
-    if t is not None:
-        type Alias = t | str
-        def f(x: Alias):
-            reveal_type(x)  # revealed: int | str
+flag = True
+t = int if flag else None
+if t is not None:
+    type NarrowedAlias = t | str
+
+def f(x: NarrowedAlias):
+    reveal_type(x)  # revealed: int | str
+```
+
+`type` statements are only allowed in module and class scopes, and a type alias cannot be redeclared
+in the same scope:
+
+```py
+class C:
+    type Alias = int
+
+def _():
+    # error: [invalid-type-alias] "`type` statements are not allowed in function scopes"
+    type Local = int
+
+type Redeclared = int
+# error: [invalid-type-alias] "Type alias `Redeclared` is already defined in this scope"
+type Redeclared = str
 ```
 
 ## Generic type aliases

crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -511,9 +511,9 @@ def _(flag: bool):
     reveal_type(promotable4 or unpromotable4)  # revealed: Literal[True]
     reveal_type([promotable4 or unpromotable4])  # revealed: list[Literal[True]]
 
-type X = Literal[b"bar"]
+type XBytes = Literal[b"bar"]
 
-def _(x1: X | None, x2: X):
+def _(x1: XBytes | None, x2: XBytes):
     reveal_type([x1, x2])  # revealed: list[Literal[b"bar"] | None]
     reveal_type([x1 or x2])  # revealed: list[Literal[b"bar"]]
 ```

crates/ty_python_semantic/resources/mdtest/promotion.md

@@ -1918,6 +1918,13 @@ impl<'ast> Visitor<'ast> for SemanticIndexBuilder<'_, 'ast> {
                         .map(|name| name.id.clone())
                         .unwrap_or("<unknown>".into()),
                 );
+
+                if type_alias.name.as_name_expr().is_some() {
+                    let use_id = self.current_ast_ids().record_use(&*type_alias.name);
+                    self.current_use_def_map_mut()
+                        .record_use(symbol.into(), use_id);
+                }
+
                 self.add_definition(symbol.into(), type_alias);
                 self.visit_expr(&type_alias.name);
 

crates/ty_python_semantic/src/semantic_index/builder.rs

@@ -90,6 +90,7 @@ pub(crate) fn register_lints(registry: &mut LintRegistryBuilder) {
     registry.register_lint(&INVALID_GENERIC_CLASS);
     registry.register_lint(&INVALID_LEGACY_TYPE_VARIABLE);
     registry.register_lint(&INVALID_PARAMSPEC);
+    registry.register_lint(&INVALID_TYPE_ALIAS);
     registry.register_lint(&INVALID_TYPE_ALIAS_TYPE);
     registry.register_lint(&INVALID_NEWTYPE);
     registry.register_lint(&INVALID_METACLASS);
@@ -1389,6 +1390,29 @@ declare_lint! {
     }
 }
 
+declare_lint! {
+    /// ## What it does
+    /// Checks for invalid PEP 695 `type` statements.
+    ///
+    /// ## Why is this bad?
+    /// A `type` statement is only valid in module and class scopes, and a type alias name should
+    /// not be redeclared in the same scope.
+    ///
+    /// ## Examples
+    /// ```python
+    /// type Alias = int
+    /// type Alias = str  # error: type alias already defined
+    ///
+    /// def f():
+    ///     type Local = int  # error: type statements are not allowed in function scopes
+    /// ```
+    pub(crate) static INVALID_TYPE_ALIAS = {
+        summary: "detects invalid PEP 695 `type` statements",
+        status: LintStatus::stable("0.0.28"),
+        default_level: Level::Error,
+    }
+}
+
 declare_lint! {
     /// ## What it does
     /// Checks for the creation of invalid `TypeAliasType`s

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -68,12 +68,12 @@ use crate::types::diagnostic::{
     CYCLIC_TYPE_ALIAS_DEFINITION, DUPLICATE_BASE, GeneratorMismatchKind, INCONSISTENT_MRO,
     INEFFECTIVE_FINAL, INVALID_ARGUMENT_TYPE, INVALID_ASSIGNMENT, INVALID_ATTRIBUTE_ACCESS,
     INVALID_BASE, INVALID_DECLARATION, INVALID_ENUM_MEMBER_ANNOTATION,
-    INVALID_LEGACY_TYPE_VARIABLE, INVALID_NEWTYPE, INVALID_PARAMSPEC, INVALID_TYPE_ALIAS_TYPE,
-    INVALID_TYPE_FORM, INVALID_TYPE_GUARD_CALL, INVALID_TYPE_VARIABLE_BOUND,
-    INVALID_TYPE_VARIABLE_CONSTRAINTS, IncompatibleBases, NO_MATCHING_OVERLOAD,
-    POSSIBLY_MISSING_IMPLICIT_CALL, POSSIBLY_MISSING_SUBMODULE, SUBCLASS_OF_FINAL_CLASS,
-    UNDEFINED_REVEAL, UNRESOLVED_ATTRIBUTE, UNRESOLVED_GLOBAL, UNRESOLVED_REFERENCE,
-    UNSUPPORTED_DYNAMIC_BASE, UNSUPPORTED_OPERATOR, UNUSED_AWAITABLE,
+    INVALID_LEGACY_TYPE_VARIABLE, INVALID_NEWTYPE, INVALID_PARAMSPEC, INVALID_TYPE_ALIAS,
+    INVALID_TYPE_ALIAS_TYPE, INVALID_TYPE_FORM, INVALID_TYPE_GUARD_CALL,
+    INVALID_TYPE_VARIABLE_BOUND, INVALID_TYPE_VARIABLE_CONSTRAINTS, IncompatibleBases,
+    NO_MATCHING_OVERLOAD, POSSIBLY_MISSING_IMPLICIT_CALL, POSSIBLY_MISSING_SUBMODULE,
+    SUBCLASS_OF_FINAL_CLASS, UNDEFINED_REVEAL, UNRESOLVED_ATTRIBUTE, UNRESOLVED_GLOBAL,
+    UNRESOLVED_REFERENCE, UNSUPPORTED_DYNAMIC_BASE, UNSUPPORTED_OPERATOR, UNUSED_AWAITABLE,
     hint_if_stdlib_attribute_exists_on_other_versions, report_attempted_protocol_instantiation,
     report_bad_dunder_set_call, report_call_to_abstract_method,
     report_cannot_pop_required_field_on_typed_dict, report_conflicting_metaclass_from_bases,
@@ -1439,6 +1439,9 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
         type_alias: &ast::StmtTypeAlias,
         definition: Definition<'db>,
     ) {
+        self.report_invalid_type_alias_scope(type_alias, definition);
+        self.report_redeclared_type_alias(type_alias, definition);
+
         self.infer_expression(&type_alias.name, TypeContext::default());
 
         // Check that no type parameter with a default follows a TypeVarTuple
@@ -1471,6 +1474,80 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
         );
     }
 
+    fn report_invalid_type_alias_scope(
+        &mut self,
+        type_alias: &ast::StmtTypeAlias,
+        definition: Definition<'db>,
+    ) {
+        let db = self.db();
+        if !definition
+            .scope(db)
+            .scope(db)
+            .kind()
+            .is_non_lambda_function()
+        {
+            return;
+        }
+
+        if let Some(builder) = self.context.report_lint(&INVALID_TYPE_ALIAS, type_alias) {
+            builder.into_diagnostic("`type` statements are not allowed in function scopes");
+        }
+    }
+
+    fn report_redeclared_type_alias(
+        &mut self,
+        type_alias: &ast::StmtTypeAlias,
+        definition: Definition<'db>,
+    ) {
+        let Some(type_alias_name) = type_alias.name.as_name_expr() else {
+            return;
+        };
+
+        let db = self.db();
+        let scope = definition.scope(db);
+        let use_def = self.index.use_def_map(scope.file_scope_id(db));
+        let use_id = type_alias_name.scoped_use_id(db, scope);
+
+        let Some(previous_definition) = use_def
+            .bindings_at_use(use_id)
+            .filter_map(|binding| binding.binding.definition())
+            .filter(|definition| definition.scope(db) == scope)
+            .filter(|definition| {
+                matches!(
+                    definition.kind(db),
+                    DefinitionKind::TypeAlias(previous_type_alias)
+                        if previous_type_alias
+                            .node(self.module())
+                            .node_index()
+                            .load()
+                            < type_alias.node_index().load()
+                )
+            })
+            .max_by_key(|definition| definition.focus_range(db, self.module()).start())
+        else {
+            return;
+        };
+
+        let Some(builder) = self
+            .context
+            .report_lint(&INVALID_TYPE_ALIAS, &*type_alias.name)
+        else {
+            return;
+        };
+
+        let mut diagnostic = builder.into_diagnostic(format_args!(
+            "Type alias `{}` is already defined in this scope",
+            type_alias_name.id
+        ));
+        diagnostic.annotate(
+            Annotation::secondary(previous_definition.focus_range(db, self.module()).into())
+                .message(format_args!(
+                    "`{}` previously defined here",
+                    type_alias_name.id
+                )),
+        );
+    }
+
     fn infer_if_statement(&mut self, if_statement: &ast::StmtIf) {
         let ast::StmtIf {
             range: _,