Implement literal promotion

Author: MichaReiser

crates/ty_ide/src/goto.rs

@@ -895,6 +895,8 @@ pub(crate) fn find_goto_target(
             | TokenKind::Float
             | TokenKind::Int => 1,
 
+            TokenKind::Comment => -1,
+
             // if we have a<CURSOR>+b`, prefer the `+` token (by respecting the token ordering)
             // This matches VS Code's behavior where it sends the start of the clicked token as offset.
             kind if kind.as_binary_operator().is_some() || kind.as_unary_operator().is_some() => 1,

crates/ty_ide/src/goto_definition.rs

@@ -1284,25 +1284,7 @@ class Test:
             )
             .build();
 
-        assert_snapshot!(test.goto_definition(), @r"
-        info[goto-definition]: Definition
-         --> main.py:3:9
-          |
-        2 | class Test:
-        3 |     def __add__(self, other):
-          |         ^^^^^^^
-        4 |         return Test()
-          |
-        info: Source
-          --> main.py:8:5
-           |
-         7 |   (
-         8 | /     Test()  # comment
-         9 | |     + Test()
-           | |____________^
-        10 |   )
-           |
-        ");
+        assert_snapshot!(test.goto_definition(), @"No goto target found");
     }
 
     #[test]

crates/ty_ide/src/hover.rs

@@ -2522,15 +2522,14 @@ def ab(a: int, *, c: int):
         "#,
         );
 
-        // TODO: It would be ncie to show `int.__add__(...)` instead of `Literal[5].__add__(...)` here.
         assert_snapshot!(test.hover(), @r"
-        bound method Literal[5].__add__(value: int, /) -> int
+        bound method int.__add__(value: int, /) -> int
         ---------------------------------------------
         Return self+value.
 
         ---------------------------------------------
         ```python
-        bound method Literal[5].__add__(value: int, /) -> int
+        bound method int.__add__(value: int, /) -> int
         ```
         ---
         ```text

crates/ty_python_semantic/src/types.rs

@@ -9970,6 +9970,14 @@ impl<'db> BoundMethodType<'db> {
         self_instance
     }
 
+    pub(crate) fn map_self_type(
+        self,
+        db: &'db dyn Db,
+        f: impl FnOnce(Type<'db>) -> Type<'db>,
+    ) -> Self {
+        Self::new(db, self.function(db), f(self.self_instance(db)))
+    }
+
     #[salsa::tracked(cycle_fn=into_callable_type_cycle_recover, cycle_initial=into_callable_type_cycle_initial, heap_size=ruff_memory_usage::heap_size)]
     pub(crate) fn into_callable_type(self, db: &'db dyn Db) -> CallableType<'db> {
         let function = self.function(db);

crates/ty_python_semantic/src/types/ide_support.rs

@@ -943,7 +943,8 @@ pub fn definitions_for_bin_op<'db>(
         return None;
     };
 
-    let callable_type = bindings.callable_type();
+    let callable_type = promote_literals_for_self(db, bindings.callable_type());
+
     let definitions: Vec<_> = bindings
         .into_iter()
         .flat_map(std::iter::IntoIterator::into_iter)
@@ -981,7 +982,7 @@ pub fn definitions_for_unary_op<'db>(
         return None;
     };
 
-    let callable_type = bindings.callable_type();
+    let callable_type = promote_literals_for_self(db, bindings.callable_type());
 
     let definitions = bindings
         .into_iter()
@@ -996,6 +997,24 @@ pub fn definitions_for_unary_op<'db>(
     Some((definitions, callable_type))
 }
 
+/// Promotes literal types in `self` positions to their fallback instance types.
+///
+/// This is so that we show `int.__add__` instead of `IntLiteral.__add__`.
+fn promote_literals_for_self<'db>(db: &'db dyn Db, ty: Type<'db>) -> Type<'db> {
+    match ty {
+        Type::BoundMethod(method) => Type::BoundMethod(method.map_self_type(db, |self_ty| {
+            self_ty.literal_fallback_instance(db).unwrap_or(self_ty)
+        })),
+        Type::Union(elements) => elements.map(db, |ty| match ty {
+            Type::BoundMethod(method) => Type::BoundMethod(method.map_self_type(db, |self_ty| {
+                self_ty.literal_fallback_instance(db).unwrap_or(self_ty)
+            })),
+            _ => *ty,
+        }),
+        ty => ty,
+    }
+}
+
 /// Find the active signature index from `CallSignatureDetails`.
 /// The active signature is the first signature where all arguments present in the call
 /// have valid mappings to parameters (i.e., none of the mappings are None).