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

Author: charliermarsh

crates/ty/docs/rules.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

@@ -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: _,