…rence (#3349)

Handle ValueError during comparison inference (#3342)

Closes #3333


(cherry picked from commit b207a53)

Co-authored-by: Alberto <[email protected]>
Co-authored-by: aipd506 <[email protected]>

…at contain themselves (#3350)

Fix RecursionError on live containers that contain themselves (#3348)

``const_factory`` converts the builtin containers found while building a
module from a live object (C extensions, ``--extension-pkg-allow-list``)
element by element. A container holding itself, directly or through other
containers, made it recurse until ``RecursionError``: ``scipy.special``
keeps ``_modattrs = globals()``, so pylint crashed on
``from scipy.special import erf`` with ``--extension-pkg-allow-list=scipy``.

Track the containers being converted and represent a reference back to one
of them with an ``EmptyNode``, like the objects ``const_factory`` does not
convert. Scalars now return before that bookkeeping, which also makes
``const_factory`` cheaper on mixed data.

Closes pylint-dev/pylint#10459
Refs #2974


(cherry picked from commit 27314d0)

Co-authored-by: Pierre-Yves Le Borgne <[email protected]>
Co-authored-by: Pierre Sassoulas <[email protected]>

… an element is not a source node (#3316)

Fix crash inferring random.sample() when an element is not a source node (#3311)

_clone_node_with_lineno rebuilt every element of the sampled sequence by
passing a filtered set of constructor arguments to its class. Inferred
objects such as Instance are not source nodes: they are proxies whose
__init__ requires the proxied ClassDef, and their _astroid_fields /
_other_fields are forwarded to that class, so rebuilding them raised
"TypeError: Instance.__init__() missing 1 required positional argument:
'proxied'".

Elements that are not NodeNG instances are now kept as they are instead
of being cloned.

Closes #3310



(cherry picked from commit e45ca82)

Co-authored-by: inchang-ing <[email protected]>
Co-authored-by: inchang-ing <[email protected]>
Co-authored-by: Pierre Sassoulas <[email protected]>

… the name of a variadic one (#3361)

Do not crash on an argument that repeats the name of a variadic one (#3260)

``Arguments.default_value()`` narrowed ``arguments`` to the non-variadic
arguments by dropping every entry whose name matched ``vararg`` or
``kwarg``. A name can be shared: ``def f(x, *y, y)`` and
``def f(x, *, y, **y)`` both parse, and only fail later at compile time
with "duplicate argument". The keyword-only ``y`` was dropped along with
the variadic one, so the offset used to index ``defaults`` was computed
from a list one entry too short and ``defaults[0]`` was read from an
empty list, raising ``IndexError`` through ``pylint``'s ``safe_infer``.

Build the list from ``posonlyargs`` and ``args`` instead, which holds
exactly the positional arguments, and offset it by ``defaults`` alone.
The keyword-only arguments are already handled by the ``kw_defaults``
lookup above. This also lets a positional default survive being shadowed:
``def f(y=1, *y)`` used to report no default at all.

Closes #3259


(cherry picked from commit 37ec2fe)

Co-authored-by: renechoi <[email protected]>
Co-authored-by: Pierre Sassoulas <[email protected]>

…ycle (#3362)

Do not let raw building close a parent cycle (#3286)

``InspectBuilder.object_build()`` re-parents nodes it finds in ``_done``
when the same live class shows up again under a different owner. A class
that exposes itself, or a sibling, as one of its own attributes therefore
ended up as its own ancestor, and ``NodeNG.root()`` spun forever on the
resulting loop.

pyo3 complex enums have exactly that shape: every variant is attached to
the enum class, so each variant sees itself and its siblings through
inheritance. Linting a project that imports such a module hung with 99%
of the time spent in the ``while parent.parent`` walk of ``root()``.

Only register the name when re-parenting would close a cycle.

Closes #3284

(cherry picked from commit 282ec00)

Co-authored-by: Pierre Sassoulas <[email protected]>

…Uninferable, like pass (#3347) (#3363)

A function whose body is only ``...`` is a placeholder, the same as a
body that is only ``pass``. ``pass`` was already inferred as
``Uninferable`` through ``is_abstract``, but ``...`` was inferred as
returning ``None``. Calling a ``...`` property stub, such as the
``sqlalchemy.func`` helpers declared under ``TYPE_CHECKING``, then looked
like calling ``None`` and pylint emitted ``not-callable``.

Refs pylint-dev/pylint#8138
(cherry picked from commit d13435c)

towncrier links the fragment's stem to the astroid repository, so a pylint
issue number as the stem produced a link to an unrelated astroid issue.

towncrier links a fragment's file name to the astroid repository. The
check required the file name to match the first reference, but accepted a
pylint issue there, so a fragment named after a pylint issue passed and
produced a link to an unrelated astroid issue.

The first reference must now be an astroid issue or pull request. pylint
references can follow it.