Python
/
ruff
mirror of https://github.com/astral-sh/ruff
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rip out value handling

This commit is contained in:
Aria Desires 2025-12-16 12:55:57 -05:00
parent 6825e9e234
commit 2e2a668b30
5 changed files with 38 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/ty_ide/src/completion.rs
View File

@ -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__, ...]]

2
crates/ty_python_semantic/resources/mdtest/call/getattr_static.md
View File

@ -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"))
```

10
crates/ty_python_semantic/resources/mdtest/cycle.md
View File

@ -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
```

20
crates/ty_python_semantic/src/types/display.rs
View File

@ -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("...")?,
}

234
crates/ty_python_semantic/src/types/signatures.rs
View File

@ -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,
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<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 {
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(),