pyrefly spaghetti error reports in scipy-stubs

For example:

ERROR Class member `_rv_continuous_0.stats` overrides parent class `rv_continuous` in an inconsistent manner [bad-override]
   --> scipy-stubs/stats/_distn_infrastructure.pyi:929:9
    |
929 |     def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    |         ^^^^^
    |
  `_rv_continuous_0.stats` has type `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]]]`, which is not assignable to `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64, (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64 | ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]]]]`, the type of `rv_continuous.stats`

which in "reality" looks like

    # overrides of rv_generic
    @overload  # loc: 0-d, scale: 0-d, moments: 1 (positional)
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 1 (keyword)
    def stats(self, /, loc: onp.ToFloat = 0, scale: onp.ToFloat = 1, *, moment: _Moment1) -> _Float: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 2 (default)
    def stats(self, /, loc: onp.ToFloat = 0, scale: onp.ToFloat = 1, moment: _Moment2 = "mv") -> _Tuple2[_Float]: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 3 (positional)
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment3) -> _Tuple3[_Float]: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 3 (keyword)
    def stats(self, /, loc: onp.ToFloat = 0, scale: onp.ToFloat = 1, *, moment: _Moment3) -> _Tuple3[_Float]: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 4 (positional)
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment4) -> _Tuple4[_Float]: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 4 (keyword)
    def stats(self, /, loc: onp.ToFloat = 0, scale: onp.ToFloat = 1, *, moment: _Moment4) -> _Tuple4[_Float]: ...

    #
    @overload  # loc: 0-d, scale: n-d (positional), moments: 1
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloatND, moment: _Moment1) -> _FloatND: ...
    @overload  # loc: 0-d, scale: n-d (positional), moments: 2 (default)
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloatND, moment: _Moment2 = "mv") -> _Tuple2[_FloatND]: ...
    @overload  # loc: 0-d, scale: n-d (positional), moments: 3
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloatND, moment: _Moment3) -> _Tuple3[_FloatND]: ...
    @overload  # loc: 0-d, scale: n-d (positional), moments: 4
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloatND, moment: _Moment4) -> _Tuple4[_FloatND]: ...

    #
    @overload  # loc: 0-d, scale: n-d (keyword), moments: 1
    def stats(self, /, loc: onp.ToFloat = 0, *, scale: onp.ToFloatND, moment: _Moment1) -> _FloatND: ...
    @overload  # loc: 0-d, scale: n-d (keyword), moments: 2 (default)
    def stats(self, /, loc: onp.ToFloat = 0, *, scale: onp.ToFloatND, moment: _Moment2 = "mv") -> _Tuple2[_FloatND]: ...
    @overload  # loc: 0-d, scale: n-d (keyword), moments: 3
    def stats(self, /, loc: onp.ToFloat = 0, *, scale: onp.ToFloatND, moment: _Moment3) -> _Tuple3[_FloatND]: ...
    @overload  # loc: 0-d, scale: n-d (keyword), moments: 4
    def stats(self, /, loc: onp.ToFloat = 0, *, scale: onp.ToFloatND, moment: _Moment4) -> _Tuple4[_FloatND]: ...

    #
    @overload  # loc: n-d, scale: ?-d, moments: 1 (positional)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND, moment: _Moment1) -> _FloatND: ...
    @overload  # loc: n-d, scale: ?-d, moments: 1 (keyword)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment1) -> _FloatND: ...
    @overload  # loc: n-d, scale: ?-d, moments: 2 (default)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND = 1, moment: _Moment2 = "mv") -> _Tuple2[_FloatND]: ...
    @overload  # loc: n-d, scale: ?-d, moments: 3 (positional)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND, moment: _Moment3) -> _Tuple3[_FloatND]: ...
    @overload  # loc: n-d, scale: ?-d, moments: 3 (keyword)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment3) -> _Tuple3[_FloatND]: ...
    @overload  # loc: n-d, scale: ?-d, moments: 4 (positional)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND, moment: _Moment4) -> _Tuple4[_FloatND]: ...
    @overload  # loc: n-d, scale: ?-d, moments: 4 (keyword)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment4) -> _Tuple4[_FloatND]: ...

https://github.com/scipy/scipy-stubs/blob/a9a9d611c907da0330569e224f0ce83b0fd93454/scipy-stubs/stats/_distn_infrastructure.pyi#L928-L941

This amount of overloads might look pretty ridiculous, but truth be told, methods like this one are pretty common in scipy-stubs (I try to keep in under 64 overloads though 😅).

Anyway, I think it would help a lot if pyrefly wouldn't "expand" the type-aliases, and just print their names.

Oct 01 '25 07:10 jorenham

Thanks for reporting this @jorenham! Definitely an unreadable resolve type, though I'm not too sure about how that should be handled. Maybe try to match the closest overloads and show only those?

Thoughts @stroxler, @yangdanny97, @rchen152?

Oct 02 '25 02:10 connernilsen

if pyrefly wouldn't "expand" the type-aliases, and just print their names.

This sounds like a good idea, we can expand them if the type we're printing is just that type alias, but if they're nested inside some other type I think we can print the name

https://github.com/facebook/pyrefly/blob/513c79b0004bfd4226c2dbadc6bfa2ef9833aad9/crates/pyrefly_types/src/types.rs#L357

Oct 02 '25 03:10 yangdanny97

The type alias printing improvements are included in v0.36.0 from today. When you get a chance to try it, please let me know how it is and what else we can improve on!

Oct 06 '25 22:10 yangdanny97

The same error is now reported as follows

ERROR Class member `_rv_continuous_0.stats` overrides parent class `rv_continuous` in an inconsistent manner [bad-override]
   --> scipy-stubs/stats/_distn_infrastructure.pyi:929:9
    |
929 |     def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    |         ^^^^^
    |
  `_rv_continuous_0.stats` has type `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]]]`, which is not assignable to `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64, (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64 | ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]]]]`, the type of `rv_continuous.stats`

I don't think there's a difference. (I double checked that this is indeed pyrefly 0.36.1.)

I've created a demo-PR so you can see for yourself: https://github.com/scipy/scipy-stubs/pull/921

Oct 07 '25 18:10 jorenham

Hum, maybe the type alias gets expanded before we get to that point. Will investigate further, sorry about that!

Oct 07 '25 23:10 yangdanny97

Hum, maybe the type alias gets expanded before we get to that point. Will investigate further, sorry about that!

Haha no worries; I'm glad that you're working on it, and don't mind helping :)

Oct 08 '25 02:10 jorenham

This issue has someone assigned, but has not had recent activity for more than 2 weeks.

If you are still working on this issue, please add a comment so everyone knows. Otherwise, please unassign yourself and allow someone else to take over.

Thank you for your contributions!

Oct 29 '25 00:10 github-actions[bot]

Just to follow up here w/ an update, I've looked into it and have a potential fix, but it's very invasive and has the potential to break a lot of type checking behavior if I'm not careful, so I'm holding off on it for a bit while I think of alternatives.

The TLDR of the root cause is that in untype_opt we expand type aliases, and we lose the information that it was previously an alias afterwards.

My potential fix is to add a new TypeAliasValue type, which wraps another type + the name of the type alias. It would behave like the wrapped type, but when we print it we would only show the name. Plumbing through this new type and changing everything to handle this is tricky, and I haven't stamped out all the regressions yet, so that's why it's taking a while.

Oct 31 '25 15:10 yangdanny97

Oof yea that sounds tricky. But I can imagine that knowing the names of type-alias can be useful in other places as well. For example for rejecting isinstance checks with TypeAliasType and allow them in case of TypeAlias. Maybe it could also help a bit for performance of equivalence checks, because I can imagine that for type Spam = <long union> it could be faster to compare the Spam names themselves. But note that I have zero knowledge about the codebase, so I based that on totally nothing.

Oct 31 '25 15:10 jorenham

because I can imagine that for type Spam = it could be faster to compare the Spam names themselves

Yeah, this is something I've been thinking about as well. Pyrefly need a different representation for type aliases to support recursive type aliases, and the representation I had in mind does allow comparisons like this just like how we can compare classes nominally. I haven;t had time to build that out yet, but I think this could be a step towards that.

Oct 31 '25 21:10 yangdanny97

I have a potential solution that is less invasive and does not affect type checking behavior, with some tradeoffs:

it will only work if the type alias is of a union (tho that's probably where this makes the biggest difference)
it will show the expanded union if the type alias is the top level type being printed (so it only works if the type alias is nested, which again is where it makes the biggest difference)
if we union the type alias with something else, the name information is lost when we we flatten/simplify the union

Nov 20 '25 21:11 yangdanny97

I have a potential solution that is less invasive and does not affect type checking behavior, with some tradeoffs:

it will only work if the type alias is of a union (tho that's probably where this makes the biggest difference)

it will show the expanded union if the type alias is the top level type being printed (so it works if the type alias is nested)

if we union the type alias with something else, the name information is lost when we we flatten/simplify the union

sounds very reasonable to me

Nov 20 '25 21:11 jorenham

The latest release should have the union type alias display changes - let me know if that makes things a bit more readable for you!

Dec 03 '25 22:12 yangdanny97

Before, the error message was 16,276 characters wide. Now, that's 4,932 — so it shrunk by a factor of 3.3 🎉.

For comparison, here's the before & after:

ERROR Class member `_rv_continuous_0.stats` overrides parent class `rv_continuous` in an inconsistent manner [bad-override]
   --> scipy-stubs/stats/_distn_infrastructure.pyi:929:9
    |
929 |     def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    |         ^^^^^
    |
  `_rv_continuous_0.stats` has type `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]]]`, which is not assignable to `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64, (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64 | ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]]]]`, the type of `rv_continuous.stats`

ERROR Class member `_rv_continuous_0.stats` overrides parent class `rv_continuous` in an inconsistent manner [bad-override]
   --> scipy-stubs/stats/_distn_infrastructure.pyi:929:9
    |
929 |     def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    |         ^^^^^
    |
  `_rv_continuous_0.stats` has type `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloat, moment: _Moment1) -> _Float, (self: _rv_continuous_0, /, loc: ToFloat = 0, scale: ToFloat = 1, *, moment: _Moment1) -> _Float, (self: _rv_continuous_0, /, loc: ToFloat = 0, scale: ToFloat = 1, moment: _Moment2 = 'mv') -> tuple[_Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloat, moment: _Moment3) -> tuple[_Float, _Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat = 0, scale: ToFloat = 1, *, moment: _Moment3) -> tuple[_Float, _Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloat, moment: _Moment4) -> tuple[_Float, _Float, _Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat = 0, scale: ToFloat = 1, *, moment: _Moment4) -> tuple[_Float, _Float, _Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloatND, moment: _Moment1) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloatND, moment: _Moment2 = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloatND, moment: _Moment3) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloatND, moment: _Moment4) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat = 0, *, scale: ToFloatND, moment: _Moment1) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: ToFloat = 0, *, scale: ToFloatND, moment: _Moment2 = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat = 0, *, scale: ToFloatND, moment: _Moment3) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat = 0, *, scale: ToFloatND, moment: _Moment4) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND, moment: _Moment1) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment1) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND = 1, moment: _Moment2 = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND, moment: _Moment3) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment3) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND, moment: _Moment4) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment4) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]]]`, which is not assignable to `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, *args: ToFloat, *, moment: _Moment1, **kwds: ToFloat) -> _Float, (self: _rv_continuous_0, /, *args: ToFloat, *, moment: _Moment2 = ..., **kwds: ToFloat) -> tuple[_Float, _Float], (self: _rv_continuous_0, /, *args: ToFloat, *, moment: _Moment3, **kwds: ToFloat) -> tuple[_Float, _Float, _Float], (self: _rv_continuous_0, /, *args: ToFloat, *, moment: _Moment4, **kwds: ToFloat) -> tuple[_Float, _Float, _Float, _Float], (self: _rv_continuous_0, /, *args: _ToFloatOrND, *, moment: _Moment1, **kwds: _ToFloatOrND) -> _FloatOrND, (self: _rv_continuous_0, /, *args: _ToFloatOrND, *, moment: _Moment2 = ..., **kwds: _ToFloatOrND) -> tuple[_FloatOrND, _FloatOrND], (self: _rv_continuous_0, /, *args: _ToFloatOrND, *, moment: _Moment3, **kwds: _ToFloatOrND) -> tuple[_FloatOrND, _FloatOrND, _FloatOrND], (self: _rv_continuous_0, /, *args: _ToFloatOrND, *, moment: _Moment4, **kwds: _ToFloatOrND) -> tuple[_FloatOrND, _FloatOrND, _FloatOrND, _FloatOrND]]]`, the type of `rv_continuous.stats`

Unless I'm mistaken, this is more readable/concise than either of the three other static type-checkers are able to report it as 👌.

It's still a lot to digest, but I wouldn't know how to decrease the length any further than this. What might help for readability, is formatting it so that the individual overloads are printed on separate lines. Is something like that within the realm of feasibility?

Dec 03 '25 23:12 jorenham

Re: overloads on separate lines, https://github.com/facebook/pyrefly/pull/1447 attempts to do this, tho I see @rchen152 had some concerns w/ that change.

There's also something else I was thinking about, which is replacing common prefixes/suffixes in the parameter list with ... when printing, to better highlight the mismatch. I'm not sure how big of a difference it would make in practice, but worth a try.

Dec 03 '25 23:12 yangdanny97

@yangdanny97 That PR is for something different; it re-formats no-matching-overload by taking every overload (which is already on its own line) and further splitting them up to one-parameter-per-line.

If I understand correctly, the request here is to print BoundMethod[foo, Overload[(...) -> _Float, (...) -> _Float, ...]] with one overload per line, which I have no objections to.

Dec 04 '25 00:12 rchen152

If I understand correctly, the request here is to print BoundMethod[foo, Overload[(...) -> _Float, (...) -> _Float, ...]] with one overload per line

that's right

Dec 04 '25 00:12 jorenham