fix

Author: asukaminato0721

crates/pyrefly_types/src/display.rs

@@ -26,6 +26,7 @@ use starlark_map::smallmap;
 use crate::callable::Function;
 use crate::class::Class;
 use crate::literal::Lit;
+use crate::stdlib::Stdlib;
 use crate::tuple::Tuple;
 use crate::type_output::DisplayOutput;
 use crate::type_output::OutputWithLocations;
@@ -92,11 +93,19 @@ pub struct TypeDisplayContext<'a> {
     /// Should we display for IDE Hover? This makes type names more readable but less precise.
     hover: bool,
     always_display_module_name: bool,
+    tuple_qname: Option<&'a QName>,
 }
 
 impl<'a> TypeDisplayContext<'a> {
     pub fn new(xs: &[&'a Type]) -> Self {
-        let mut res = Self::default();
+        Self::new_with_tuple(xs, None)
+    }
+
+    pub fn new_with_tuple(xs: &[&'a Type], tuple_qname: Option<&'a QName>) -> Self {
+        let mut res = Self {
+            tuple_qname,
+            ..Self::default()
+        };
         for x in xs {
             res.add(x);
         }
@@ -120,6 +129,10 @@ impl<'a> TypeDisplayContext<'a> {
         })
     }
 
+    pub(crate) fn tuple_qname(&self) -> Option<&'a QName> {
+        self.tuple_qname
+    }
+
     /// Force that we always display at least the module name for qualified names.
     pub fn always_display_module_name(&mut self) {
         // We pretend that every qname is also in a fake module, and thus requires disambiguating.
@@ -786,7 +799,21 @@ impl Type {
     }
 
     pub fn get_types_with_locations(&self) -> Vec<(String, Option<TextRangeWithModule>)> {
-        let ctx = TypeDisplayContext::new(&[self]);
+        self.get_types_with_locations_with_tuple_qname(None)
+    }
+
+    pub fn get_types_with_locations_with_stdlib(
+        &self,
+        stdlib: &Stdlib,
+    ) -> Vec<(String, Option<TextRangeWithModule>)> {
+        self.get_types_with_locations_with_tuple_qname(Some(stdlib.tuple_object().qname()))
+    }
+
+    fn get_types_with_locations_with_tuple_qname(
+        &self,
+        tuple_qname: Option<&QName>,
+    ) -> Vec<(String, Option<TextRangeWithModule>)> {
+        let ctx = TypeDisplayContext::new_with_tuple(&[self], tuple_qname);
         let mut output = OutputWithLocations::new(&ctx);
         ctx.fmt_helper_generic(self, false, &mut output).unwrap();
         output.parts().to_vec()
@@ -1661,6 +1688,15 @@ def overloaded_func[T](
         output.parts().to_vec()
     }
 
+    fn get_parts_with_tuple_qname(
+        t: &Type,
+        tuple_qname: &pyrefly_python::qname::QName,
+    ) -> Vec<(String, Option<TextRangeWithModule>)> {
+        let ctx = TypeDisplayContext::new_with_tuple(&[t], Some(tuple_qname));
+        let output = ctx.get_types_with_location(t, false);
+        output.parts().to_vec()
+    }
+
     fn parts_to_string(parts: &[(String, Option<TextRangeWithModule>)]) -> String {
         parts.iter().map(|(s, _)| s.as_str()).collect::<String>()
     }
@@ -1865,20 +1901,25 @@ def overloaded_func[T](
         let bar = fake_class("Bar", "test", 55);
         let foo_type = Type::ClassType(ClassType::new(foo, TArgs::default()));
         let bar_type = Type::ClassType(ClassType::new(bar, TArgs::default()));
+        let tuple_cls = fake_class("tuple", "builtins", 5);
 
         // Test concrete tuple: tuple[Foo, Bar]
         let concrete_tuple = Type::Tuple(Tuple::Concrete(vec![foo_type.clone(), bar_type.clone()]));
         let parts = get_parts(&concrete_tuple);
         for expected in &["tuple", "Foo", "Bar"] {
             assert_output_contains(&parts, expected);
         }
+        let parts_with_location = get_parts_with_tuple_qname(&concrete_tuple, tuple_cls.qname());
+        assert_part_has_location(&parts_with_location, "tuple", "builtins", 5);
 
         // Test unbounded tuple: tuple[Foo, ...]
         let unbounded_tuple = Type::Tuple(Tuple::Unbounded(Box::new(foo_type)));
         let parts2 = get_parts(&unbounded_tuple);
         for expected in &["tuple", "Foo", "..."] {
             assert_output_contains(&parts2, expected);
         }
+        let parts_unbounded = get_parts_with_tuple_qname(&unbounded_tuple, tuple_cls.qname());
+        assert_part_has_location(&parts_unbounded, "tuple", "builtins", 5);
     }
 
     #[test]

crates/pyrefly_types/src/tuple.rs

@@ -64,7 +64,7 @@ impl Tuple {
         output: &mut O,
         write_type: &impl Fn(&Type, &mut O) -> fmt::Result,
     ) -> fmt::Result {
-        output.write_str("tuple")?;
+        output.write_tuple_keyword()?;
         output.write_str("[")?;
         match self {
             Self::Concrete(elts) => {

crates/pyrefly_types/src/type_output.rs

@@ -26,6 +26,9 @@ pub trait TypeOutput {
     fn write_lit(&mut self, lit: &Lit) -> fmt::Result;
     fn write_targs(&mut self, targs: &TArgs) -> fmt::Result;
     fn write_type(&mut self, ty: &Type) -> fmt::Result;
+    fn write_tuple_keyword(&mut self) -> fmt::Result {
+        self.write_str("tuple")
+    }
 }
 
 /// Implementation of `TypeOutput` that writes formatted types to plain text.
@@ -140,6 +143,16 @@ impl TypeOutput for OutputWithLocations<'_> {
         // Format the type and extract location if it has a qname
         self.context.fmt_helper_generic(ty, false, self)
     }
+
+    fn write_tuple_keyword(&mut self) -> fmt::Result {
+        if let Some(qname) = self.context.tuple_qname() {
+            let location = TextRangeWithModule::new(qname.module().clone(), qname.range());
+            self.parts.push((qname.id().to_string(), Some(location)));
+            Ok(())
+        } else {
+            self.write_str("tuple")
+        }
+    }
 }
 
 #[cfg(test)]
@@ -482,9 +495,8 @@ mod tests {
 
     #[test]
     fn test_output_with_locations_tuple_base_not_clickable() {
-        // TODO(jvansch): When implementing clickable support for the base type in generics like tuple[int],
-        // update this test to verify that "tuple" has a location and is clickable.
-        // Expected future behavior: [("tuple", Some(location)), ("[", None), ("int", Some(location)), ("]", None)]
+        // Without stdlib context we don't attach a location to the `tuple` keyword.
+        // (See `test_output_with_locations_tuple_base_clickable_when_qname_available`.)
 
         // Create tuple[int] type
         let int_class = fake_class("int", "builtins", 10);
@@ -522,6 +534,32 @@ mod tests {
         assert!(parts[3].1.is_none(), "] should not have location");
     }
 
+    #[test]
+    fn test_output_with_locations_tuple_base_clickable_when_qname_available() {
+        let tuple_cls = fake_class("tuple", "builtins", 5);
+        let int_class = fake_class("int", "builtins", 10);
+        let int_type = Type::ClassType(ClassType::new(int_class, TArgs::default()));
+        let tuple_type = Type::Tuple(Tuple::Concrete(vec![int_type]));
+
+        let ctx = TypeDisplayContext::new_with_tuple(&[&tuple_type], Some(tuple_cls.qname()));
+        let mut output = OutputWithLocations::new(&ctx);
+
+        ctx.fmt_helper_generic(&tuple_type, false, &mut output)
+            .unwrap();
+
+        let tuple_part = output
+            .parts()
+            .iter()
+            .find(|(text, _)| text == "tuple")
+            .expect("tuple keyword should be present");
+        let location = tuple_part
+            .1
+            .as_ref()
+            .expect("tuple should now have a location");
+        assert_eq!(location.module.name(), ModuleName::from_str("builtins"));
+        assert_eq!(location.range.start(), TextSize::new(5));
+    }
+
     #[test]
     fn test_output_with_locations_literal_base_not_clickable() {
         // TODO(jvansch): When implementing clickable support for the base type in special forms like Literal[1],

pyrefly/lib/lsp/wasm/inlay_hints.rs

@@ -119,6 +119,7 @@ impl<'a> Transaction<'a> {
                 }
         };
         let bindings = self.get_bindings(handle)?;
+        let stdlib = self.get_stdlib(handle);
         let mut res = Vec::new();
         for idx in bindings.keys::<Key>() {
             match bindings.idx_to_key(idx) {
@@ -139,8 +140,9 @@ impl<'a> Transaction<'a> {
                                     {
                                         ty = return_ty;
                                     }
-                                    // Use get_types_with_locations to get type parts with location info
-                                    let type_parts = ty.get_types_with_locations();
+                                    // Use get_types_with_locations_with_stdlib to get type parts with location info
+                                    let type_parts =
+                                        ty.get_types_with_locations_with_stdlib(stdlib.as_ref());
                                     let label_parts = once((" -> ".to_owned(), None))
                                         .chain(
                                             type_parts
@@ -181,8 +183,8 @@ impl<'a> Transaction<'a> {
                     if let Some(e) = e
                         && is_interesting(e, &ty, class_name)
                     {
-                        // Use get_types_with_locations to get type parts with location info
-                        let type_parts = ty.get_types_with_locations();
+                        // Use get_types_with_locations_with_stdlib to get type parts with location info
+                        let type_parts = ty.get_types_with_locations_with_stdlib(stdlib.as_ref());
                         let label_parts = once((": ".to_owned(), None))
                             .chain(
                                 type_parts