Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions conformance/third_party/conformance.exp
Original file line number Diff line number Diff line change
Expand Up @@ -3844,8 +3844,8 @@
{
"code": -2,
"column": 12,
"concise_description": "revealed type: (*args: Any, **kwargs: Any) -> NoReturn",
"description": "revealed type: (*args: Any, **kwargs: Any) -> NoReturn",
"concise_description": "revealed type: (...) -> NoReturn",
"description": "revealed type: (...) -> NoReturn",
"line": 99,
"name": "reveal-type",
"severity": "info",
Expand Down
209 changes: 104 additions & 105 deletions pyrefly/lib/solver/subset.rs
Original file line number Diff line number Diff line change
Expand Up @@ -160,19 +160,6 @@ fn params_have_any_args_and_kwargs(params: &Params) -> bool {
}
}

/// Whether a callable-typed value should be treated as having gradual (`...`) parameters
/// because its definition had both `*args` and `**kwargs` typed `Any`. For a `Function` we
/// trust the definition-time flag, so an `Any` introduced by type-parameter substitution (e.g.
/// `Proto[Any]` over `*args: T, **kwargs: T`) does not count. A bare `Callable` has no such
/// metadata, so we fall back to inspecting its params.
fn sig_is_gradual_variadic(ty: &Type) -> bool {
match ty {
Type::Function(f) => f.metadata.flags.has_gradual_variadic_params,
Type::Callable(c) => params_have_any_args_and_kwargs(&c.params),
_ => false,
}
}

fn all<T>(
it: impl Iterator<Item = T>,
mut check: impl FnMut(T) -> Result<(), SubsetError>,
Expand Down Expand Up @@ -205,6 +192,25 @@ struct FreshForall {
}

impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
/// Whether `*args: Any, **kwargs: Any` in `params` form a gradual tail, which is equivalent
/// to `...`. `strict_callable_subtyping` turns this off.
fn params_have_gradual_tail(&self, params: &[Param]) -> bool {
!self.solver.config.strict_callable_subtyping && params_are_gradual_variadic(params)
}

/// Like `params_have_gradual_tail`, for the signature of a callable-typed value. For a
/// `Function` we trust the definition-time flag, so an `Any` introduced by type-parameter
/// substitution (e.g. `Proto[Any]` over `*args: T, **kwargs: T`) does not count. A bare
/// `Callable` has no such metadata, so we fall back to inspecting its params.
fn sig_has_gradual_tail(&self, ty: &Type) -> bool {
!self.solver.config.strict_callable_subtyping
&& match ty {
Type::Function(f) => f.metadata.flags.has_gradual_variadic_params,
Type::Callable(c) => params_have_any_args_and_kwargs(&c.params),
_ => false,
}
}

fn is_subset_literal_int_size(
&mut self,
literal: i64,
Expand Down Expand Up @@ -236,28 +242,17 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
}

/// Can a function with l_args be called as a function with u_args?
///
/// If `u_gradual` is set, the `*args: Any` and `**kwargs: Any` parameters of `u_args` are a
/// gradual tail (like `...`) that is compatible with whatever parameters of `l_args` remain
/// after matching the other parameters of `u_args`. A gradual `l_args` needs no flag: its
/// `*args: Any` and `**kwargs: Any` already accept every parameter of `u_args` that the
/// other parameters of `l_args` do not match.
fn is_subset_param_list(
&mut self,
l_args: &[Param],
u_args: &[Param],
l_gradual: bool,
u_gradual: bool,
) -> Result<(), SubsetError> {
// Don't short-circuit because we may want to pin/solve variables
let result = self.is_subset_param_list_impl(l_args, u_args);
match result {
Err(_) if !self.solver.config.strict_callable_subtyping && (l_gradual || u_gradual) => {
Ok(())
}
_ => result,
}
}

/// Can a function with l_args be called as a function with u_args?
fn is_subset_param_list_impl(
&mut self,
l_args: &[Param],
u_args: &[Param],
) -> Result<(), SubsetError> {
let mut l_args = l_args.iter();
let mut u_args = u_args.iter();
Expand All @@ -278,6 +273,15 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
break;
}
}
// The gradual `*args` of `u` stands for any remaining positional parameters of `l`.
// A `*args` of `l` is still matched below, so that `u` gives it context.
(
None
| Some(
Param::PosOnly(..) | Param::Pos(..) | Param::KwOnly(..) | Param::Kwargs(..),
),
Some(Param::Varargs(..)),
) if u_gradual => break,
(
Some(Param::PosOnly(_, l, l_req) | Param::Pos(_, l, l_req)),
Some(Param::PosOnly(_, u, u_req)),
Expand Down Expand Up @@ -472,7 +476,7 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
l_arg = l_args.next();
u_arg = u_args.next();
}
(Some(_), Some(Param::KwOnly(_, _, _) | Param::Kwargs(_, _))) => {
(_, Some(Param::KwOnly(_, _, _) | Param::Kwargs(_, _))) => {
break;
}
(None, Some(Param::PosOnly(_, ty, _) | Param::Pos(_, ty, _))) => {
Expand Down Expand Up @@ -588,7 +592,8 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
self.is_subset_eq(&u, &l)?;
Some(l)
}
(None, Some(_)) => {
// The gradual `**kwargs` of `u` stands for any remaining keyword parameters of `l`.
(None, Some(_)) if !u_gradual => {
return Err(SubsetError::Other);
}
(l_kwargs, _) => l_kwargs,
Expand Down Expand Up @@ -622,22 +627,22 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
return Err(SubsetError::Other);
}
}
for (_, l_req) in l_keywords.values() {
if *l_req {
return Err(SubsetError::Other);
}
if !u_gradual && l_keywords.values().any(|(_, l_req)| *l_req) {
return Err(SubsetError::Other);
}
Ok(())
}

/// `l_gradual` and `u_gradual` say whether `l_params` and `u_params` have a gradual tail; see
/// `params_have_gradual_tail`.
fn is_subset_params(
&mut self,
l_params: &Params,
u_params: &Params,
l_gradual: bool,
u_gradual: bool,
) -> Result<(), SubsetError> {
let result = match (l_params, u_params) {
match (l_params, u_params) {
(Params::Ellipsis, Params::ParamSpec(_, pspec)) => {
self.is_subset_eq(&Type::Ellipsis, pspec)
}
Expand Down Expand Up @@ -668,12 +673,12 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
(
Params::List(l_args) | Params::Partial(l_args),
Params::List(u_args) | Params::Partial(u_args),
) => self.is_subset_param_list(l_args.items(), u_args.items(), l_gradual, u_gradual),
) => self.is_subset_param_list(l_args.items(), u_args.items(), u_gradual),
(Params::List(ls) | Params::Partial(ls), Params::ParamSpec(args, pspec)) => {
self.is_paramlist_subset_of_paramspec(ls, args, pspec)
self.is_paramlist_subset_of_paramspec(ls, l_gradual, args, pspec)
}
(Params::ParamSpec(args, pspec), Params::List(ls) | Params::Partial(ls)) => {
self.is_paramspec_subset_of_paramlist(args, pspec, ls)
self.is_paramspec_subset_of_paramlist(args, pspec, ls, u_gradual)
}
(Params::ParamSpec(ls, p1), Params::ParamSpec(us, p2)) => {
self.is_paramspec_subset_of_paramspec(ls, p1, us, p2)
Expand All @@ -685,15 +690,9 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
l_params,
&Params::List(ParamList::everything()),
l_gradual,
true,
!self.solver.config.strict_callable_subtyping,
)
}
};
match result {
Err(_) if !self.solver.config.strict_callable_subtyping && (l_gradual || u_gradual) => {
Ok(())
}
_ => result,
}
}

Expand Down Expand Up @@ -1082,9 +1081,27 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
}
}

/// The ParamSpec value for the parameters that remain after matching a `Concatenate` prefix.
/// If they are only the gradual `*args: Any, **kwargs: Any` tail of the signature, they are
/// equivalent to `...`.
fn param_spec_remainder(&self, params: &[Param], gradual: bool) -> Type {
if gradual
&& params
.iter()
.all(|p| matches!(p, Param::Varargs(..) | Param::Kwargs(..)))
{
Type::Ellipsis
} else {
self.solver
.heap
.mk_param_spec_value(ParamList::new(params.to_vec()))
}
}

fn is_paramlist_subset_of_paramspec(
&mut self,
got: &ParamList,
got_gradual: bool,
want_ts: &[PrefixParam],
want_pspec: &Type,
) -> Result<(), SubsetError> {
Expand All @@ -1094,55 +1111,37 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
if got.len() < args.len() {
// Run the regular parameter matcher first so it can distinguish a type mismatch
// from parameters that are genuinely absent. A variadic parameter may consume the
// whole prefix, but inferring the remaining ParamSpec from it is not supported.
self.is_subset_param_list(
got.items(),
&args,
params_are_gradual_variadic(got.items()),
params_are_gradual_variadic(&args),
)?;
return Err(SubsetError::Other);
// whole prefix, but inferring the remaining ParamSpec from it is only supported
// for a gradual tail, which leaves `...`.
self.is_subset_param_list(got.items(), &args, false)?;
if !got_gradual {
return Err(SubsetError::Other);
}
return self.is_subset_eq(&Type::Ellipsis, want_pspec);
}
let (pre, post) = got.items().split_at(args.len());
self.is_subset_param_list(
pre,
&args,
params_are_gradual_variadic(pre),
params_are_gradual_variadic(&args),
)?;
self.is_subset_eq(
&self
.solver
.heap
.mk_param_spec_value(ParamList::new(post.to_vec())),
want_pspec,
)
self.is_subset_param_list(pre, &args, false)?;
self.is_subset_eq(&self.param_spec_remainder(post, got_gradual), want_pspec)
}

fn is_paramspec_subset_of_paramlist(
&mut self,
got_ts: &[PrefixParam],
got_pspec: &Type,
want: &ParamList,
want_gradual: bool,
) -> Result<(), SubsetError> {
if want.len() < got_ts.len() {
return Err(SubsetError::Other);
}
let args: Vec<Param> = got_ts.iter().map(|p| p.to_param_preserve_name()).collect();
let (pre, post) = want.items().split_at(args.len());
self.is_subset_param_list(
&args,
pre,
params_are_gradual_variadic(&args),
params_are_gradual_variadic(pre),
)?;
self.is_subset_eq(
got_pspec,
&self
.solver
.heap
.mk_param_spec_value(ParamList::new(post.to_vec())),
)
// A gradual tail in `want` may stand for the prefix parameters it does not have.
let (pre, post) = if want.len() >= args.len() {
want.items().split_at(args.len())
} else if want_gradual {
(want.items(), &[][..])
} else {
return Err(SubsetError::Other);
};
self.is_subset_param_list(&args, pre, want_gradual)?;
self.is_subset_eq(got_pspec, &self.param_spec_remainder(post, want_gradual))
}

fn is_paramspec_subset_of_paramspec(
Expand Down Expand Up @@ -2256,16 +2255,9 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
(l, Type::Overloaded(branches)) => {
all(branches.iter(), |branch| self.is_subset_eq(l, branch))
}
(l, Type::Overload(overload)) => {
let l_gradual = sig_is_gradual_variadic(l);
let result = all(overload.signatures.iter(), |u| {
self.is_subset_eq(l, &u.as_type())
});
match result {
Err(_) if !self.solver.config.strict_callable_subtyping && l_gradual => Ok(()),
_ => result,
}
}
(l, Type::Overload(overload)) => all(overload.signatures.iter(), |u| {
self.is_subset_eq(l, &u.as_type())
}),
(Type::Quantified(q), u) if !q.restriction().is_restricted() => self.is_subset_eq(
&self
.solver
Expand Down Expand Up @@ -2351,8 +2343,8 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
Type::Function(f) => &f.signature,
_ => unreachable!("guarded by pattern above"),
};
let l_gradual = sig_is_gradual_variadic(got);
let u_gradual = sig_is_gradual_variadic(want);
let l_gradual = self.sig_has_gradual_tail(got);
let u_gradual = self.sig_has_gradual_tail(want);
let argument_side = self.active_call_context.argument_side();
self.with_active_call_context(
Some(
Expand Down Expand Up @@ -2989,15 +2981,22 @@ impl<'solver, 'subset, Ans: LookupAnswer> Subset<'solver, 'subset, Ans> {
(Type::ParamSpecValue(ls), Type::ParamSpecValue(us)) => self.is_subset_param_list(
ls.items(),
us.items(),
params_are_gradual_variadic(ls.items()),
params_are_gradual_variadic(us.items()),
self.params_have_gradual_tail(us.items()),
),
(Type::ParamSpecValue(ls), Type::Concatenate(us, u_pspec)) => {
self.is_paramlist_subset_of_paramspec(ls, us, u_pspec)
}
(Type::Concatenate(ls, l_pspec), Type::ParamSpecValue(us)) => {
self.is_paramspec_subset_of_paramlist(ls, l_pspec, us)
}
(Type::ParamSpecValue(ls), Type::Concatenate(us, u_pspec)) => self
.is_paramlist_subset_of_paramspec(
ls,
self.params_have_gradual_tail(ls.items()),
us,
u_pspec,
),
(Type::Concatenate(ls, l_pspec), Type::ParamSpecValue(us)) => self
.is_paramspec_subset_of_paramlist(
ls,
l_pspec,
us,
self.params_have_gradual_tail(us.items()),
),
(Type::Concatenate(ls, l_pspec), Type::Concatenate(us, u_pspec)) => {
self.is_paramspec_subset_of_paramspec(ls, l_pspec, us, u_pspec)
}
Expand Down
Loading
Loading