rip out value handling

crates/ty_ide/src/completion.rs

@@ -3212,7 +3212,7 @@ quux.<CURSOR>
         assert_snapshot!(
             builder.skip_keywords().skip_builtins().type_signatures().build().snapshot(), @r"
         count :: bound method Quux.count(value: Any, /) -> int
-        index :: bound method Quux.index(value: Any, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int
+        index :: bound method Quux.index(value: Any, start: SupportsIndex = 0, stop: SupportsIndex = ..., /) -> int
         x :: int
         y :: str
         __add__ :: Overload[(value: tuple[int | str, ...], /) -> tuple[int | str, ...], (value: tuple[_T@__add__, ...], /) -> tuple[int | str | _T@__add__, ...]]

crates/ty_python_semantic/resources/mdtest/call/getattr_static.md

@@ -144,7 +144,7 @@ from typing import Any
 def _(a: Any, tuple_of_any: tuple[Any]):
     reveal_type(inspect.getattr_static(a, "x", "default"))  # revealed: Any | Literal["default"]
 
-    # revealed: def index(self, value: Any, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int
+    # revealed: def index(self, value: Any, start: SupportsIndex = 0, stop: SupportsIndex = ..., /) -> int
     reveal_type(inspect.getattr_static(tuple_of_any, "index", "default"))
 ```
 

crates/ty_python_semantic/resources/mdtest/cycle.md

@@ -87,25 +87,25 @@ class C:
         def inner_a(positional=self.a):
             return
         self.a = inner_a
-        # revealed: def inner_a(positional=self.a) -> Unknown
+        # revealed: def inner_a(positional=...) -> Unknown
         reveal_type(inner_a)
 
         def inner_b(*, kw_only=self.b):
             return
         self.b = inner_b
-        # revealed: def inner_b(*, kw_only=self.b) -> Unknown
+        # revealed: def inner_b(*, kw_only=...) -> Unknown
         reveal_type(inner_b)
 
         def inner_c(positional_only=self.c, /):
             return
         self.c = inner_c
-        # revealed: def inner_c(positional_only=self.c, /) -> Unknown
+        # revealed: def inner_c(positional_only=..., /) -> Unknown
         reveal_type(inner_c)
 
         def inner_d(*, kw_only=self.d):
             return
         self.d = inner_d
-        # revealed: def inner_d(*, kw_only=self.d) -> Unknown
+        # revealed: def inner_d(*, kw_only=...) -> Unknown
         reveal_type(inner_d)
 ```
 
@@ -114,7 +114,7 @@ We do, however, still check assignability of the default value to the parameter
 ```py
 class D:
     def f(self: "D"):
-        # error: [invalid-parameter-default] "Default value of type `Unknown | (def inner_a(a: int = self.a) -> Unknown)` is not assignable to annotated parameter type `int`"
+        # error: [invalid-parameter-default] "Default value of type `Unknown | (def inner_a(a: int = ...) -> Unknown)` is not assignable to annotated parameter type `int`"
         def inner_a(a: int = self.a): ...
         self.a = inner_a
 ```

crates/ty_python_semantic/src/types/display.rs

@@ -1838,21 +1838,7 @@ impl<'db> FmtDetailed<'db> for DisplayParameter<'_, 'db> {
                 }
             }
             // Default value can only be specified if `name` is given.
-            if let Some(default_value) = self.param.default_value() {
+            if let Some(default_type) = self.param.default_type() {
-                if self.param.annotated_type().is_some() {
-                    f.write_str(" = ")?;
-                } else {
-                    f.write_str("=")?;
-                }
-                // Omit long default values or ones that contain newlines
-                if default_value.len() > 12 || default_value.contains('\n') {
-                    f.write_str("...")?;
-                } else {
-                    f.write_str(default_value)?;
-                }
-            } else if let Some(default_type) = self.param.default_type() {
-                // Ideally we'd never end up in here, but complex situations like dataclasses
-                // can result in us computing the type Literal[1] but not having the default_value set
                 if self.param.annotated_type().is_some() {
                     f.write_str(" = ")?;
                 } else {
@@ -1875,10 +1861,10 @@ impl<'db> FmtDetailed<'db> for DisplayParameter<'_, 'db> {
 
                         match (class, class.known(self.db)) {
                             (_, Some(KnownClass::NoneType)) => {
-                                f.with_type(default_type).write_str("None")?
+                                f.with_type(default_type).write_str("None")?;
                             }
                             (_, Some(KnownClass::NoDefaultType)) => {
-                                f.with_type(default_type).write_str("NoDefault")?
+                                f.with_type(default_type).write_str("NoDefault")?;
                             }
                             _ => f.write_str("...")?,
                         }

crates/ty_python_semantic/src/types/signatures.rs

@@ -917,12 +917,10 @@ impl<'db> Signature<'db> {
                     ParameterKind::PositionalOrKeyword {
                         name: self_name,
                         default_type: self_default,
-                        default_value: _,
                     },
                     ParameterKind::PositionalOrKeyword {
                         name: other_name,
                         default_type: other_default,
-                        default_value: _,
                     },
                 ) if self_default.is_some() == other_default.is_some()
                     && self_name == other_name => {}
@@ -933,12 +931,10 @@ impl<'db> Signature<'db> {
                     ParameterKind::KeywordOnly {
                         name: self_name,
                         default_type: self_default,
-                        default_value: _,
                     },
                     ParameterKind::KeywordOnly {
                         name: other_name,
                         default_type: other_default,
-                        default_value: _,
                     },
                 ) if self_default.is_some() == other_default.is_some()
                     && self_name == other_name => {}
@@ -1222,12 +1218,10 @@ impl<'db> Signature<'db> {
                             ParameterKind::PositionalOrKeyword {
                                 name: self_name,
                                 default_type: self_default,
-                                default_value: _,
                             },
                             ParameterKind::PositionalOrKeyword {
                                 name: other_name,
                                 default_type: other_default,
-                                default_value: _,
                             },
                         ) => {
                             if self_name != other_name {
@@ -1365,12 +1359,10 @@ impl<'db> Signature<'db> {
                 ParameterKind::KeywordOnly {
                     name: other_name,
                     default_type: other_default,
-                    default_value: _,
                 }
                 | ParameterKind::PositionalOrKeyword {
                     name: other_name,
                     default_type: other_default,
-                    default_value: _,
                 } => {
                     if let Some(self_parameter) = self_keywords.remove(other_name.as_str()) {
                         match self_parameter.kind() {
@@ -1697,15 +1689,6 @@ impl<'db> Parameters<'db> {
         };
 
         let pos_only_param = |param: &ast::ParameterWithDefault| {
-            let mut default_value = None;
-            if let Some(default) = &param.default {
-                use ruff_text_size::Ranged;
-                let file = definition.file(db);
-                let source = ruff_db::source::source_text(db, file);
-                let text = source.as_str().get(default.range().to_std_range());
-                default_value = text.map(Box::from);
-            }
-
             Parameter::from_node_and_kind(
                 db,
                 definition,
@@ -1713,7 +1696,6 @@ impl<'db> Parameters<'db> {
                 ParameterKind::PositionalOnly {
                     name: Some(param.parameter.name.id.clone()),
                     default_type: default_type(param),
-                    default_value,
                 },
             )
         };
@@ -1739,15 +1721,6 @@ impl<'db> Parameters<'db> {
         }
 
         let positional_or_keyword = pos_or_keyword_iter.map(|arg| {
-            let mut default_value = None;
-            if let Some(default) = &arg.default {
-                use ruff_text_size::Ranged;
-                let file = definition.file(db);
-                let source = ruff_db::source::source_text(db, file);
-                let text = source.as_str().get(default.range().to_std_range());
-                default_value = text.map(Box::from);
-            }
-
             Parameter::from_node_and_kind(
                 db,
                 definition,
@@ -1755,7 +1728,6 @@ impl<'db> Parameters<'db> {
                 ParameterKind::PositionalOrKeyword {
                     name: arg.parameter.name.id.clone(),
                     default_type: default_type(arg),
-                    default_value,
                 },
             )
         });
@@ -1772,15 +1744,6 @@ impl<'db> Parameters<'db> {
         });
 
         let keyword_only = kwonlyargs.iter().map(|arg| {
-            let mut default_value = None;
-            if let Some(default) = &arg.default {
-                use ruff_text_size::Ranged;
-                let file = definition.file(db);
-                let source = ruff_db::source::source_text(db, file);
-                let text = source.as_str().get(default.range().to_std_range());
-                default_value = text.map(Box::from);
-            }
-
             Parameter::from_node_and_kind(
                 db,
                 definition,
@@ -1788,7 +1751,6 @@ impl<'db> Parameters<'db> {
                 ParameterKind::KeywordOnly {
                     name: arg.parameter.name.id.clone(),
                     default_type: default_type(arg),
-                    default_value,
                 },
             )
         });
@@ -1952,7 +1914,6 @@ impl<'db> Parameter<'db> {
             kind: ParameterKind::PositionalOnly {
                 name,
                 default_type: None,
-                default_value: None,
             },
             form: ParameterForm::Value,
         }
@@ -1965,7 +1926,6 @@ impl<'db> Parameter<'db> {
             kind: ParameterKind::PositionalOrKeyword {
                 name,
                 default_type: None,
-                default_value: None,
             },
             form: ParameterForm::Value,
         }
@@ -1987,7 +1947,6 @@ impl<'db> Parameter<'db> {
             kind: ParameterKind::KeywordOnly {
                 name,
                 default_type: None,
-                default_value: None,
             },
             form: ParameterForm::Value,
         }
@@ -2074,29 +2033,19 @@ impl<'db> Parameter<'db> {
             ParameterKind::PositionalOnly {
                 name: _,
                 default_type,
-                default_value,
             } => ParameterKind::PositionalOnly {
                 name: None,
                 default_type: default_type.map(|_| Type::Never),
-                default_value: default_value.clone(),
             },
+            ParameterKind::PositionalOrKeyword { name, default_type } => {
                 ParameterKind::PositionalOrKeyword {
-                name,
-                default_type,
-                default_value,
-            } => ParameterKind::PositionalOrKeyword {
                     name: name.clone(),
                     default_type: default_type.map(|_| Type::Never),
-                default_value: default_value.clone(),
+                }
-            },
+            }
-            ParameterKind::KeywordOnly {
+            ParameterKind::KeywordOnly { name, default_type } => ParameterKind::KeywordOnly {
-                name,
-                default_type,
-                default_value,
-            } => ParameterKind::KeywordOnly {
                 name: name.clone(),
                 default_type: default_type.map(|_| Type::Never),
-                default_value: default_value.clone(),
             },
             ParameterKind::Variadic { name: _ } => ParameterKind::Variadic {
                 name: Name::new_static("args"),
@@ -2137,11 +2086,7 @@ impl<'db> Parameter<'db> {
         };
 
         let kind = match kind {
-            ParameterKind::PositionalOnly {
+            ParameterKind::PositionalOnly { name, default_type } => ParameterKind::PositionalOnly {
-                name,
-                default_type,
-                default_value,
-            } => ParameterKind::PositionalOnly {
                 name: name.clone(),
                 default_type: match default_type {
                     Some(ty) if nested => Some(ty.recursive_type_normalized_impl(db, div, true)?),
@@ -2151,13 +2096,23 @@ impl<'db> Parameter<'db> {
                     ),
                     None => None,
                 },
-                default_value: default_value.clone(),
             },
+            ParameterKind::PositionalOrKeyword { name, default_type } => {
                 ParameterKind::PositionalOrKeyword {
-                name,
+                    name: name.clone(),
-                default_type,
+                    default_type: match default_type {
-                default_value,
+                        Some(ty) if nested => {
-            } => ParameterKind::PositionalOrKeyword {
+                            Some(ty.recursive_type_normalized_impl(db, div, true)?)
+                        }
+                        Some(ty) => Some(
+                            ty.recursive_type_normalized_impl(db, div, true)
+                                .unwrap_or(div),
+                        ),
+                        None => None,
+                    },
+                }
+            }
+            ParameterKind::KeywordOnly { name, default_type } => ParameterKind::KeywordOnly {
                 name: name.clone(),
                 default_type: match default_type {
                     Some(ty) if nested => Some(ty.recursive_type_normalized_impl(db, div, true)?),
@@ -2167,23 +2122,6 @@ impl<'db> Parameter<'db> {
                     ),
                     None => None,
                 },
-                default_value: default_value.clone(),
-            },
-            ParameterKind::KeywordOnly {
-                name,
-                default_type,
-                default_value,
-            } => ParameterKind::KeywordOnly {
-                name: name.clone(),
-                default_type: match default_type {
-                    Some(ty) if nested => Some(ty.recursive_type_normalized_impl(db, div, true)?),
-                    Some(ty) => Some(
-                        ty.recursive_type_normalized_impl(db, div, true)
-                            .unwrap_or(div),
-                    ),
-                    None => None,
-                },
-                default_value: default_value.clone(),
             },
             ParameterKind::Variadic { name } => ParameterKind::Variadic { name: name.clone() },
             ParameterKind::KeywordVariadic { name } => {
@@ -2300,19 +2238,9 @@ impl<'db> Parameter<'db> {
             ParameterKind::Variadic { .. } | ParameterKind::KeywordVariadic { .. } => None,
         }
     }
-
-    /// Default-value of the parameter, if any.
-    pub(crate) fn default_value(&self) -> Option<&str> {
-        match &self.kind {
-            ParameterKind::PositionalOnly { default_value, .. }
-            | ParameterKind::PositionalOrKeyword { default_value, .. }
-            | ParameterKind::KeywordOnly { default_value, .. } => default_value.as_deref(),
-            ParameterKind::Variadic { .. } | ParameterKind::KeywordVariadic { .. } => None,
-        }
-    }
 }
 
-#[derive(Clone, Debug, salsa::Update, get_size2::GetSize)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, salsa::Update, get_size2::GetSize)]
 pub enum ParameterKind<'db> {
     /// Positional-only parameter, e.g. `def f(x, /): ...`
     PositionalOnly {
@@ -2322,7 +2250,6 @@ pub enum ParameterKind<'db> {
         /// nameless (e.g. via `Callable` annotations).
         name: Option<Name>,
         default_type: Option<Type<'db>>,
-        default_value: Option<Box<str>>,
     },
 
     /// Positional-or-keyword parameter, e.g. `def f(x): ...`
@@ -2330,7 +2257,6 @@ pub enum ParameterKind<'db> {
         /// Parameter name.
         name: Name,
         default_type: Option<Type<'db>>,
-        default_value: Option<Box<str>>,
     },
 
     /// Variadic parameter, e.g. `def f(*args): ...`
@@ -2344,7 +2270,6 @@ pub enum ParameterKind<'db> {
         /// Parameter name.
         name: Name,
         default_type: Option<Type<'db>>,
-        default_value: Option<Box<str>>,
     },
 
     /// Variadic keywords parameter, e.g. `def f(**kwargs): ...`
@@ -2354,94 +2279,6 @@ pub enum ParameterKind<'db> {
     },
 }
 
-impl PartialEq for ParameterKind<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (
-                Self::PositionalOnly {
-                    name: l_name,
-                    default_type: l_default_type,
-                    default_value: _,
-                },
-                Self::PositionalOnly {
-                    name: r_name,
-                    default_type: r_default_type,
-                    default_value: _,
-                },
-            ) => l_name == r_name && l_default_type == r_default_type,
-            (
-                Self::PositionalOrKeyword {
-                    name: l_name,
-                    default_type: l_default_type,
-                    default_value: _,
-                },
-                Self::PositionalOrKeyword {
-                    name: r_name,
-                    default_type: r_default_type,
-                    default_value: _,
-                },
-            ) => l_name == r_name && l_default_type == r_default_type,
-            (Self::Variadic { name: l_name }, Self::Variadic { name: r_name }) => l_name == r_name,
-            (
-                Self::KeywordOnly {
-                    name: l_name,
-                    default_type: l_default_type,
-                    default_value: _,
-                },
-                Self::KeywordOnly {
-                    name: r_name,
-                    default_type: r_default_type,
-                    default_value: _,
-                },
-            ) => l_name == r_name && l_default_type == r_default_type,
-            (Self::KeywordVariadic { name: l_name }, Self::KeywordVariadic { name: r_name }) => {
-                l_name == r_name
-            }
-            _ => false,
-        }
-    }
-}
-
-impl Eq for ParameterKind<'_> {}
-
-impl std::hash::Hash for ParameterKind<'_> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        core::mem::discriminant(self).hash(state);
-        match self {
-            ParameterKind::PositionalOnly {
-                name,
-                default_type,
-                default_value: _,
-            } => {
-                name.hash(state);
-                default_type.hash(state);
-            }
-            ParameterKind::PositionalOrKeyword {
-                name,
-                default_type,
-                default_value: _,
-            } => {
-                name.hash(state);
-                default_type.hash(state);
-            }
-            ParameterKind::Variadic { name } => {
-                name.hash(state);
-            }
-            ParameterKind::KeywordOnly {
-                name,
-                default_type,
-                default_value: _,
-            } => {
-                name.hash(state);
-                default_type.hash(state);
-            }
-            ParameterKind::KeywordVariadic { name } => {
-                name.hash(state);
-            }
-        }
-    }
-}
-
 impl<'db> ParameterKind<'db> {
     fn apply_type_mapping_impl<'a>(
         &self,
@@ -2461,31 +2298,16 @@ impl<'db> ParameterKind<'db> {
         };
 
         match self {
-            Self::PositionalOnly {
+            Self::PositionalOnly { default_type, name } => Self::PositionalOnly {
-                default_type,
-                default_value,
-                name,
-            } => Self::PositionalOnly {
                 default_type: apply_to_default_type(default_type),
-                default_value: default_value.clone(),
                 name: name.clone(),
             },
-            Self::PositionalOrKeyword {
+            Self::PositionalOrKeyword { default_type, name } => Self::PositionalOrKeyword {
-                default_type,
-                default_value,
-                name,
-            } => Self::PositionalOrKeyword {
                 default_type: apply_to_default_type(default_type),
-                default_value: default_value.clone(),
                 name: name.clone(),
             },
-            Self::KeywordOnly {
+            Self::KeywordOnly { default_type, name } => Self::KeywordOnly {
-                default_type,
-                default_value,
-                name,
-            } => Self::KeywordOnly {
                 default_type: apply_to_default_type(default_type),
-                default_value: default_value.clone(),
                 name: name.clone(),
             },
             Self::Variadic { .. } | Self::KeywordVariadic { .. } => self.clone(),