Clean up some dangling names and comments

Summary:
Suggested in review earlier in this stack: always use PossibleLegacyTParam for
the names of both keys and bindings, patch up the comments, and fix up the
function that gets the Key to use the same naming convention.

Reviewed By: rchen152

Differential Revision: D83186813

fbshipit-source-id: f426dc067e7c359cf414abe376aa75cced7b134d

Author: stroxler

pyrefly/lib/alt/solve.rs

@@ -1965,7 +1965,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     TypeInfo::of_ty(Type::never())
                 }
             }
-            Binding::CheckLegacyTypeParam(key, range_if_scoped_params_exist) => {
+            Binding::PossibleLegacyTParam(key, range_if_scoped_params_exist) => {
                 let ty = match &*self.get_idx(*key) {
                     LegacyTypeParameterLookup::Parameter(p) => {
                         // This class or function has scoped (PEP 695) type parameters. Mixing legacy-style parameters is an error.
@@ -2270,7 +2270,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             | Binding::Narrow(..)
             | Binding::AssignToAttribute(..)
             | Binding::AssignToSubscript(..)
-            | Binding::CheckLegacyTypeParam(..) => {
+            | Binding::PossibleLegacyTParam(..) => {
                 // These forms require propagating attribute narrowing information, so they
                 // are handled in `binding_to_type_info`
                 self.binding_to_type_info(binding, errors).into_ty()

pyrefly/lib/binding/binding.rs

@@ -459,7 +459,7 @@ impl DisplayWith<ModuleInfo> for Key {
             Self::Delete(r) => write!(f, "Key::Delete({})", ctx.display(r)),
             Self::SelfTypeLiteral(r) => write!(f, "Key::SelfTypeLiteral({})", ctx.display(r)),
             Self::PossibleLegacyTParam(r) => {
-                write!(f, "Key::CheckLegacyTypeParam({})", ctx.display(r))
+                write!(f, "Key::PossibleLegacyTParam({})", ctx.display(r))
             }
             Self::PatternNarrow(r) => write!(f, "Key::PatternNarrow({})", ctx.display(r)),
         }
@@ -1226,13 +1226,10 @@ pub enum Binding {
     /// with the previous import to this binding (in which case merge the modules).
     Module(ModuleName, Vec<Name>, Option<Idx<Key>>),
     /// A name that might be a legacy type parameter. Solving this gives the Quantified type if so.
-    /// The TextRange is optional and should be set at most once per identifier
-    /// to avoid duplicate type errors (this is not type safe, because we might
-    /// produce multiple `CheckLegacyTypeParam` bindings for the same
-    /// identifier).
-    /// It controls whether to produce an error saying there are scoped type parameters for this
-    /// function / class, and therefore the use of legacy type parameters is invalid.
-    CheckLegacyTypeParam(Idx<KeyLegacyTypeParam>, Option<TextRange>),
+    /// The TextRange is optional and controls whether to produce an error
+    /// saying there are scoped type parameters for this function / class, and
+    /// therefore the use of legacy type parameters is invalid.
+    PossibleLegacyTParam(Idx<KeyLegacyTypeParam>, Option<TextRange>),
     /// An assignment to a name.
     NameAssign(
         Name,
@@ -1371,8 +1368,8 @@ impl DisplayWith<Bindings> for Binding {
             Self::TypeParameter(tp) => {
                 write!(f, "TypeParameter({}, {}, ..)", tp.unique, tp.kind)
             }
-            Self::CheckLegacyTypeParam(k, _) => {
-                write!(f, "CheckLegacyTypeParam({})", ctx.display(*k))
+            Self::PossibleLegacyTParam(k, _) => {
+                write!(f, "PossibleLegacyTParam({})", ctx.display(*k))
             }
             Self::AnnotatedType(k1, k2) => {
                 write!(
@@ -1549,7 +1546,7 @@ impl Binding {
             | Binding::ParamSpec(_, _, _)
             | Binding::TypeVarTuple(_, _, _)
             | Binding::TypeParameter(_)
-            | Binding::CheckLegacyTypeParam(_, _) => Some(SymbolKind::TypeParameter),
+            | Binding::PossibleLegacyTParam(_, _) => Some(SymbolKind::TypeParameter),
             Binding::Global(_) => Some(SymbolKind::Variable),
             Binding::Function(_, _, _) => Some(SymbolKind::Function),
             Binding::Import(_, _, _) => {

pyrefly/lib/binding/bindings.rs

@@ -979,7 +979,7 @@ impl LegacyTParamId {
     /// Note that the range here is not the range of the full `LegacyTParamId`, but
     /// just of the name being bound (which in the `Attr` case is just the base
     /// rather than the entire identifier).
-    fn as_check_legacy_tparam_key(&self) -> Key {
+    fn as_possible_legacy_tparam_key(&self) -> Key {
         Key::PossibleLegacyTParam(self.as_identifier().range)
     }
 
@@ -1145,8 +1145,8 @@ impl<'a> BindingsBuilder<'a> {
         let tparam_idx = Self::make_legacy_tparam(&id, original_binding, original_idx)
             .map(|(k, v)| self.insert_binding(k, v))?;
         let idx = self.insert_binding(
-            id.as_check_legacy_tparam_key(),
-            Binding::CheckLegacyTypeParam(
+            id.as_possible_legacy_tparam_key(),
+            Binding::PossibleLegacyTParam(
                 tparam_idx,
                 if has_scoped_type_params {
                     Some(id.range())

pyrefly/lib/state/ide.rs

@@ -77,7 +77,7 @@ fn find_definition_key_from<'a>(bindings: &'a Bindings, key: &'a Key) -> Option<
                 current_idx = *k;
             }
             Binding::Phi(ks) if !ks.is_empty() => current_idx = *ks.iter().next().unwrap(),
-            Binding::CheckLegacyTypeParam(k, _) => {
+            Binding::PossibleLegacyTParam(k, _) => {
                 let binding = bindings.get(*k);
                 current_idx = binding.idx();
             }
@@ -114,7 +114,7 @@ fn create_intermediate_definition_from(
     while !gas.stop() {
         match current_binding {
             Binding::Forward(k) => current_binding = bindings.get(*k),
-            Binding::CheckLegacyTypeParam(k, _) => {
+            Binding::PossibleLegacyTParam(k, _) => {
                 let binding = bindings.get(*k);
                 current_binding = bindings.get(binding.idx());
             }