Expand type alias redefinition check

Summary:
Expands the type alias redefinition check added in D92188517:
* we now do the check in both directions (redefining something as a type alias, or redefining a type alias as something else)
* we also check legacy type aliases and ones created via `TypeAliasType(...)`
* we only error on redefinitions in the same scope (this matches pyright's behavior)

Reviewed By: stroxler

Differential Revision: D92904394

fbshipit-source-id: 177aeaf5b234ffd2b035b35f0033b961e2af5134

Author: rchen152

conformance/third_party/conformance.exp

@@ -947,8 +947,8 @@
     {
       "code": -2,
       "column": 6,
-      "concise_description": "Cannot redefine existing name `BadTypeAlias14` as a type alias",
-      "description": "Cannot redefine existing name `BadTypeAlias14` as a type alias",
+      "concise_description": "Cannot redefine existing type alias `BadTypeAlias14`",
+      "description": "Cannot redefine existing type alias `BadTypeAlias14`",
       "line": 52,
       "name": "redefinition",
       "severity": "error",

pyrefly/lib/binding/bindings.rs

@@ -1334,6 +1334,7 @@ impl<'a> BindingsBuilder<'a> {
         idx: Idx<Key>,
         style: FlowStyle,
     ) -> Option<Idx<KeyAnnotation>> {
+        self.check_for_type_alias_redefinition(name, idx);
         let name = Hashed::new(name);
         let write_info = self
             .scopes
@@ -1351,6 +1352,28 @@ impl<'a> BindingsBuilder<'a> {
         write_info.annotation
     }
 
+    fn check_for_type_alias_redefinition(&self, name: &Name, idx: Idx<Key>) {
+        let prev_idx = self.scopes.current_flow_idx(name);
+        if let Some(prev_idx) = prev_idx {
+            if matches!(
+                self.idx_to_binding(prev_idx),
+                Some(Binding::TypeAlias { .. })
+            ) {
+                self.error(
+                    self.idx_to_key(idx).range(),
+                    ErrorInfo::Kind(ErrorKind::Redefinition),
+                    format!("Cannot redefine existing type alias `{name}`",),
+                )
+            } else if matches!(self.idx_to_binding(idx), Some(Binding::TypeAlias { .. })) {
+                self.error(
+                    self.idx_to_key(idx).range(),
+                    ErrorInfo::Kind(ErrorKind::Redefinition),
+                    format!("Cannot redefine existing name `{name}` as a type alias",),
+                );
+            }
+        }
+    }
+
     pub fn type_params(&mut self, x: &mut TypeParams) -> SmallSet<Name> {
         let mut names = SmallSet::new();
         for x in x.type_params.iter_mut() {

pyrefly/lib/binding/scope.rs

@@ -1748,6 +1748,14 @@ impl Scopes {
         Some(self.current().flow.get_info(name)?.value()?.style.clone())
     }
 
+    /// Get the flow idx for `name` in the current scope.
+    ///
+    /// Returns `None` if there is no current flow (which may mean the
+    /// name is uninitialized in the current scope, or is not in scope at all).
+    pub fn current_flow_idx(&self, name: &Name) -> Option<Idx<Key>> {
+        Some(self.current().flow.get_info(name)?.value()?.idx)
+    }
+
     /// Return the current binding index and flow style for `name`, if it exists
     /// in any enclosing scope.
     pub fn binding_idx_for_name(&self, name: &Name) -> Option<(Idx<Key>, FlowStyle)> {

pyrefly/lib/binding/stmt.rs

@@ -58,7 +58,6 @@ use crate::binding::narrow::NarrowOps;
 use crate::binding::narrow::NarrowingSubject;
 use crate::binding::scope::FlowStyle;
 use crate::binding::scope::LoopExit;
-use crate::binding::scope::NameReadInfo;
 use crate::binding::scope::Scope;
 use crate::config::error_kind::ErrorKind;
 use crate::error::context::ErrorInfo;
@@ -829,19 +828,6 @@ impl<'a> BindingsBuilder<'a> {
                     );
                 }
                 if let Expr::Name(name) = *x.name {
-                    if let NameReadInfo::Flow { .. } = self
-                        .scopes
-                        .look_up_name_for_read(Hashed::new(&name.id), &Usage::StaticTypeInformation)
-                    {
-                        self.error(
-                            name.range(),
-                            ErrorInfo::Kind(ErrorKind::Redefinition),
-                            format!(
-                                "Cannot redefine existing name `{}` as a type alias",
-                                name.id
-                            ),
-                        );
-                    }
                     // Create a new scope for the type alias type parameters
                     self.scopes.push(Scope::type_alias(x.range));
                     if let Some(params) = &mut x.type_params {

pyrefly/lib/test/type_alias.rs

@@ -1141,14 +1141,61 @@ testcase!(
     test_type_statement_redeclaration_conformance,
     r#"
 type BadTypeAlias14 = int
-type BadTypeAlias14 = int # E: Cannot redefine existing name `BadTypeAlias14` as a type alias
+type BadTypeAlias14 = int # E: Cannot redefine existing type alias `BadTypeAlias14`
 
 class C:
     type T = int
-    type T = int # E: Cannot redefine existing name `T` as a type alias
+    type T = int # E: Cannot redefine existing type alias `T`
 "#,
 );
 
+testcase!(
+    test_redeclare_type_alias_as_non_type_alias,
+    r#"
+type BadTypeAlias14 = int
+BadTypeAlias14 = 0  # E: Cannot redefine existing type alias `BadTypeAlias14`
+"#,
+);
+
+testcase!(
+    test_redeclare_non_type_alias_as_type_alias,
+    r#"
+BadTypeAlias14 = 0
+type BadTypeAlias14 = int  # E: Cannot redefine existing name `BadTypeAlias14` as a type alias
+"#,
+);
+
+testcase!(
+    test_redeclare_legacy_type_alias,
+    r#"
+from typing import TypeAlias, Union
+
+X1: TypeAlias = int
+X1 = 0  # E: Cannot redefine existing type alias `X1`
+
+X2 = Union[int, str]
+X2 = 0  # E: Cannot redefine existing type alias `X2`
+    "#,
+);
+
+testcase!(
+    test_redeclare_typealiastype,
+    r#"
+from typing import TypeAliasType
+X = TypeAliasType("X", int)
+X = 0  # E: Cannot redefine existing type alias `X`
+    "#,
+);
+
+testcase!(
+    test_redeclare_type_alias_in_nested_scope_ok,
+    r#"
+type X = int
+class C:
+    type X = str
+    "#,
+);
+
 testcase!(
     test_display_instance_vs_type,
     r#"