diff --git a/crates/ty_ide/src/completion.rs b/crates/ty_ide/src/completion.rs index 68cf6a44c3..35aad8bb02 100644 --- a/crates/ty_ide/src/completion.rs +++ b/crates/ty_ide/src/completion.rs @@ -3212,7 +3212,7 @@ quux. 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__, ...]] diff --git a/crates/ty_python_semantic/resources/mdtest/call/getattr_static.md b/crates/ty_python_semantic/resources/mdtest/call/getattr_static.md index ba117b769e..04e57dea02 100644 --- a/crates/ty_python_semantic/resources/mdtest/call/getattr_static.md +++ b/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")) ``` diff --git a/crates/ty_python_semantic/resources/mdtest/cycle.md b/crates/ty_python_semantic/resources/mdtest/cycle.md index fd7982ee90..775b4e8ac6 100644 --- a/crates/ty_python_semantic/resources/mdtest/cycle.md +++ b/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 ``` diff --git a/crates/ty_python_semantic/src/types/display.rs b/crates/ty_python_semantic/src/types/display.rs index 7294dcc9c6..1120bff415 100644 --- a/crates/ty_python_semantic/src/types/display.rs +++ b/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 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 let Some(default_type) = self.param.default_type() { 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("...")?, } diff --git a/crates/ty_python_semantic/src/types/signatures.rs b/crates/ty_python_semantic/src/types/signatures.rs index 370bb0a84e..dd6fe02334 100644 --- a/crates/ty_python_semantic/src/types/signatures.rs +++ b/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) = ¶m.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, - default_value, - } => ParameterKind::PositionalOrKeyword { + ParameterKind::PositionalOrKeyword { name, default_type } => { + ParameterKind::PositionalOrKeyword { + name: name.clone(), + default_type: default_type.map(|_| Type::Never), + } + } + ParameterKind::KeywordOnly { name, default_type } => ParameterKind::KeywordOnly { name: name.clone(), default_type: default_type.map(|_| Type::Never), - default_value: default_value.clone(), - }, - 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 { - name, - default_type, - default_value, - } => ParameterKind::PositionalOnly { + ParameterKind::PositionalOnly { name, default_type } => 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, - default_value, - } => ParameterKind::PositionalOrKeyword { + ParameterKind::PositionalOrKeyword { name, default_type } => { + ParameterKind::PositionalOrKeyword { + 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, + }, + } + } + 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, default_type: Option>, - default_value: Option>, }, /// Positional-or-keyword parameter, e.g. `def f(x): ...` @@ -2330,7 +2257,6 @@ pub enum ParameterKind<'db> { /// Parameter name. name: Name, default_type: Option>, - default_value: Option>, }, /// Variadic parameter, e.g. `def f(*args): ...` @@ -2344,7 +2270,6 @@ pub enum ParameterKind<'db> { /// Parameter name. name: Name, default_type: Option>, - default_value: Option>, }, /// 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(&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 { - default_type, - default_value, - name, - } => Self::PositionalOnly { + Self::PositionalOnly { default_type, name } => Self::PositionalOnly { default_type: apply_to_default_type(default_type), - default_value: default_value.clone(), name: name.clone(), }, - Self::PositionalOrKeyword { - default_type, - default_value, - name, - } => Self::PositionalOrKeyword { + Self::PositionalOrKeyword { default_type, name } => Self::PositionalOrKeyword { default_type: apply_to_default_type(default_type), - default_value: default_value.clone(), name: name.clone(), }, - Self::KeywordOnly { - default_type, - default_value, - name, - } => Self::KeywordOnly { + Self::KeywordOnly { default_type, 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(),