Fix typos in comments and docstrings (#2101)

Found by codespell:
- curent -> current (classes.py)
- suppport -> support, propeties -> properties (inference/__init__.py)
- existance -> existence (inference/analysis.py)
- Propably -> Probably (inference/value/instance.py)

Co-authored-by: maxtaran2010 <ocotifuzo727@gmail.com>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

.github/workflows/ci.yml

@@ -1,31 +1,33 @@
 name: ci
-on: [push, pull_request]
+on: [push, pull_request, workflow_dispatch]
 
 jobs:
   tests:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-20.04, windows-2019]
+        os: [ubuntu-24.04, windows-2022]
-        python-version: ["3.10", "3.9", "3.8", "3.7", "3.6"]
+        python-version: ["3.14", "3.13", "3.12", "3.11", "3.10"]
-        environment: ['3.8', '3.10', '3.9', '3.7', '3.6', 'interpreter']
+        environment: ['3.14', '3.13', '3.12', '3.11', '3.10', 'interpreter']
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           submodules: recursive
 
-      - uses: actions/setup-python@v2
+      - uses: actions/setup-python@v5
         if: ${{ matrix.environment != 'interpreter' }}
         with:
           python-version: ${{ matrix.environment }}
+          allow-prereleases: true
 
-      - uses: actions/setup-python@v2
+      - uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
 
       - name: Install dependencies
-        run: 'pip install .[testing]'
+        run: 'pip install .[dev]'
 
       - name: Run tests
         run: python -m pytest
@@ -33,32 +35,32 @@ jobs:
           JEDI_TEST_ENVIRONMENT: ${{ matrix.environment }}
 
   code-quality:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           submodules: recursive
 
       - name: Install dependencies
-        run: 'pip install .[qa]'
+        run: 'pip install .[dev]'
 
       - name: Run tests
         run: |
-          python -m flake8 jedi setup.py
+          python -m flake8 jedi test setup.py
-          python -m mypy jedi sith.py
+          zuban check
 
   coverage:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           submodules: recursive
 
       - name: Install dependencies
-        run: 'pip install .[testing] coverage'
+        run: 'pip install .[dev] coverage'
 
       - name: Run tests
         run: |

.readthedocs.yml

@@ -9,3 +9,13 @@ python:
 
 submodules:
   include: all
+
+sphinx:
+  configuration: docs/conf.py
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.14"
+  apt_packages:
+    - graphviz

AUTHORS.txt

@@ -63,6 +63,9 @@ Code Contributors
 - Leo Ryu (@Leo-Ryu)
 - Joseph Birkner (@josephbirkner)
 - Márcio Mazza (@marciomazza)
+- Martin Vielsmaier (@moser) <martin@vielsmaier.net>
+- TingJia Wu (@WutingjiaX) <wutingjia@bytedance.com>
+- Nguyễn Hồng Quân <ng.hong.quan@gmail.com>
 
 And a few more "anonymous" contributors.
 

CHANGELOG.rst

@@ -6,6 +6,36 @@ Changelog
 Unreleased
 ++++++++++
 
+0.20.0 (2026-05-02)
++++++++++++++++++++
+
+- Python 3.14 support
+- Removed support for Python 3.8 and 3.9
+- Upgraded Typeshed
+- Better support for Final/ClassVar
+- ``__new__`` is now also recognized as a signature and TypeVar inference
+- Support for ``Self``
+- Support for ``TypeAlias``, generics for ``type[...]`` and ``tuple[...]``
+
+0.19.2 (2024-11-10)
++++++++++++++++++++
+
+- Python 3.13 support
+
+0.19.1 (2023-10-02)
++++++++++++++++++++
+
+- Python 3.12 support (Thanks Peter!)
+
+0.19.0 (2023-07-29)
++++++++++++++++++++
+
+- Python 3.11 support
+- Massive improvements in performance for ``Interpreter`` (e.g. IPython) users.
+  This especially affects ``pandas`` users with large datasets.
+- Add ``jedi.settings.allow_unsafe_interpreter_executions`` to make it easier
+  for IPython users to avoid unsafe executions.
+
 0.18.2 (2022-11-21)
 +++++++++++++++++++
 

README.rst

@@ -2,6 +2,9 @@
 Jedi - an awesome autocompletion, static analysis and refactoring library for Python
 ####################################################################################
 
+**I released the successor to Jedi: A
+Mypy-Compatible Python Language Server Built in Rust** - `Zuban <https://github.com/zubanls/zuban>`_
+
 .. image:: http://isitmaintained.com/badge/open/davidhalter/jedi.svg
     :target: https://github.com/davidhalter/jedi/issues
     :alt: The percentage of open issues and pull requests
@@ -10,7 +13,7 @@ Jedi - an awesome autocompletion, static analysis and refactoring library for Py
     :target: https://github.com/davidhalter/jedi/issues
     :alt: The resolution time is the median time an issue or pull request stays open.
 
-.. image:: https://github.com/davidhalter/jedi/workflows/ci/badge.svg?branch=master
+.. image:: https://github.com/davidhalter/jedi/actions/workflows/ci.yml/badge.svg?branch=master
     :target: https://github.com/davidhalter/jedi/actions
     :alt: Tests
 
@@ -42,7 +45,7 @@ Jedi can currently be used with the following editors/projects:
 - `GNOME Builder`_ (with support for GObject Introspection)
 - Gedit (gedi_)
 - wdb_ - Web Debugger
-- `Eric IDE`_ (Available as a plugin)
+- `Eric IDE`_
 - `IPython 6.0.0+ <https://ipython.readthedocs.io/en/stable/whatsnew/version6.html>`_
 - `xonsh shell <https://xon.sh/contents.html>`_ has `jedi extension <https://xon.sh/xontribs.html#jedi>`_
 
@@ -51,7 +54,8 @@ and many more!
 There are a few language servers that use Jedi:
 
 - `jedi-language-server <https://github.com/pappasam/jedi-language-server>`_
-- `python-language-server <https://github.com/palantir/python-language-server>`_
+- `python-language-server <https://github.com/palantir/python-language-server>`_ (currently unmaintained)
+- `python-lsp-server <https://github.com/python-lsp/python-lsp-server>`_ (fork from python-language-server)
 - `anakin-language-server <https://github.com/muffinmad/anakin-language-server>`_
 
 Here are some pictures taken from jedi-vim_:
@@ -98,7 +102,7 @@ Features and Limitations
 Jedi's features are listed here:
 `Features <https://jedi.readthedocs.org/en/latest/docs/features.html>`_.
 
-You can run Jedi on Python 3.6+ but it should also
+You can run Jedi on Python 3.10+ but it should also
 understand code that is older than those versions. Additionally you should be
 able to use `Virtualenvs <https://jedi.readthedocs.org/en/latest/docs/api.html#environments>`_
 very well.
@@ -179,10 +183,10 @@ The test suite uses ``pytest``::
 
     pip install pytest
 
-If you want to test only a specific Python version (e.g. Python 3.8), it is as
+If you want to test only a specific Python version (e.g. Python 3.14), it is as
 easy as::
 
-    python3.8 -m pytest
+    python3.14 -m pytest
 
 For more detailed information visit the `testing documentation
 <https://jedi.readthedocs.org/en/latest/docs/testing.html>`_.

SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+If security issues arise, we will try to fix those as soon as possible.
+
+Due to Jedi's nature, Security Issues will probably be extremely rare, but we will of course treat them seriously.
+
+## Reporting Security Problems
+
+If you need to report a security vulnerability, please send an email to davidhalter88@gmail.com. Typically, I will respond in the next few business days.

conftest.py

@@ -42,7 +42,7 @@ def pytest_addoption(parser):
                      help="Warnings are treated as errors.")
 
     parser.addoption("--env", action='store',
-                     help="Execute the tests in that environment (e.g. 39 for python3.9).")
+                     help="Execute the tests in that environment (e.g. 314 for python3.14).")
     parser.addoption("--interpreter-env", "-I", action='store_true',
                      help="Don't use subprocesses to guarantee having safe "
                           "code execution. Useful for debugging.")
@@ -133,11 +133,13 @@ def goto_or_help(request, Script):
 
 @pytest.fixture(scope='session', params=['goto', 'help', 'infer'])
 def goto_or_help_or_infer(request, Script):
-    def do(code, *args, **kwargs):
+    class GotoOrHelpOrInfer:
-        return getattr(Script(code), request.param)(*args, **kwargs)
+        def __call__(self, code, *args, **kwargs):
+            return getattr(Script(code), request.param)(*args, **kwargs)
 
-    do.type = request.param
+        type = request.param
-    return do
+
+    return GotoOrHelpOrInfer()
 
 
 @pytest.fixture(scope='session', params=['goto', 'complete', 'help'])
@@ -157,16 +159,8 @@ def jedi_path():
 
 
 @pytest.fixture()
-def skip_pre_python38(environment):
+def skip_pre_python311(environment):
-    if environment.version_info < (3, 8):
+    if environment.version_info < (3, 11):
-        # This if is just needed to avoid that tests ever skip way more than
-        # they should for all Python versions.
-        pytest.skip()
-
-
-@pytest.fixture()
-def skip_pre_python37(environment):
-    if environment.version_info < (3, 7):
         # This if is just needed to avoid that tests ever skip way more than
         # they should for all Python versions.
         pytest.skip()

docs/docs/acknowledgements.rst

@@ -35,7 +35,7 @@ to write my own version of a completion engine.
 The first idea was to execute non-dangerous code. But I soon realized, that
 this would not work. So I started to build a static analysis tool.
 The biggest problem that I had at the time was that I did not know a thing
-about parsers.I did not did not even know the word static analysis. It turns
+about parsers. I did not even know the word static analysis. It turns
 out they are the foundation of a good static analysis tool. I of course did not
 know that and tried to write my own poor version of a parser that I ended up
 throwing away two years later.
@@ -53,7 +53,7 @@ quick and is pretty much feature complete.
 
 --------
 
-I will leave you with a small annectote that happend in 2012, if I remember
+I will leave you with a small anecdote that happened in 2012, if I remember
 correctly. After I explained Guido van Rossum, how some parts of my
 auto-completion work, he said:
 

docs/docs/api.rst

@@ -107,7 +107,7 @@ Completions
    >>> code = '''import json; json.l'''
    >>> script = jedi.Script(code, path='example.py')
    >>> script
-   <Script: 'example.py' <SameEnvironment: 3.9.0 in /usr>>
+   <Script: 'example.py' <SameEnvironment: 3.14.0 in /usr>>
    >>> completions = script.complete(1, 19)
    >>> completions
    [<Completion: load>, <Completion: loads>]

docs/docs/features.rst

@@ -16,7 +16,7 @@ Jedi's main API calls and features are:
 Basic Features
 --------------
 
-- Python 3.6+ support
+- Python 3.10+ support
 - Ignores syntax errors and wrong indentation
 - Can deal with complex module / function / class structures
 - Great ``virtualenv``/``venv`` support
@@ -77,7 +77,7 @@ Performance Issues
 
 Importing ``numpy`` can be quite slow sometimes, as well as loading the
 builtins the first time. If you want to speed things up, you could preload
-libriaries in |jedi|, with :func:`.preload_module`. However, once loaded, this
+libraries in |jedi|, with :func:`.preload_module`. However, once loaded, this
 should not be a problem anymore.  The same is true for huge modules like
 ``PySide``, ``wx``, ``tensorflow``, ``pandas``, etc.
 

docs/docs/installation.rst

@@ -38,7 +38,7 @@ using pip::
 
 If you want to install the current development version (master branch)::
 
-    sudo pip install -e git://github.com/davidhalter/jedi.git#egg=jedi
+    sudo pip install -e git+https://github.com/davidhalter/jedi.git#egg=jedi
 
 
 System-wide installation via a package manager

docs/docs/testing.rst

@@ -7,10 +7,10 @@ The test suite depends on ``pytest``::
 
     pip install pytest
 
-If you want to test only a specific Python version (e.g. Python 3.8), it is as
+If you want to test only a specific Python version (e.g. Python 3.14), it is as
 easy as::
 
-    python3.8 -m pytest
+    python3.14 -m pytest
 
 Tests are also run automatically on `GitHub Actions
 <https://github.com/davidhalter/jedi/actions>`_.

docs/docs/usage.rst

@@ -3,8 +3,8 @@
 Using Jedi
 ==========
 
-|jedi| is can be used with a variety of :ref:`plugins <editor-plugins>`,
+|jedi| can be used with a variety of :ref:`plugins <editor-plugins>`,
-`language servers <language-servers>` and other software.
+:ref:`language servers <language-servers>` and other software.
 It is also possible to use |jedi| in the :ref:`Python shell or with IPython
 <repl-completion>`.
 
@@ -13,10 +13,11 @@ Below you can also find a list of :ref:`recipes for type hinting <recipes>`.
 .. _language-servers:
 
 Language Servers
---------------
+----------------
 
 - `jedi-language-server <https://github.com/pappasam/jedi-language-server>`_
-- `python-language-server <https://github.com/palantir/python-language-server>`_
+- `python-language-server <https://github.com/palantir/python-language-server>`_ (currently unmaintained)
+- `python-lsp-server <https://github.com/python-lsp/python-lsp-server>`_ (fork from python-language-server)
 - `anakin-language-server <https://github.com/muffinmad/anakin-language-server>`_
 
 .. _editor-plugins:
@@ -86,7 +87,7 @@ Gedit
 Eric IDE
 ~~~~~~~~
 
-- `Eric IDE`_ (Available as a plugin)
+- `Eric IDE`_
 
 Web Debugger
 ~~~~~~~~~~~~
@@ -96,7 +97,7 @@ Web Debugger
 xonsh shell
 ~~~~~~~~~~~
 
-Jedi is a preinstalled extension in `xonsh shell <https://xon.sh/contents.html>`_. 
+Jedi is a preinstalled extension in `xonsh shell <https://xon.sh/contents.html>`_.
 Run the following command to enable:
 
 ::

jedi/__init__.py

@@ -27,7 +27,7 @@ ad
 load
 """
 
-__version__ = '0.18.2'
+__version__ = '0.20.0'
 
 from jedi.api import Script, Interpreter, set_debug_function, preload_module
 from jedi import settings

jedi/_compatibility.py

@@ -5,11 +5,24 @@ different Python versions.
 import errno
 import sys
 import pickle
+from typing import Any
+
+
+class Unpickler(pickle.Unpickler):
+    def find_class(self, module: str, name: str) -> Any:
+        # Python 3.13 moved pathlib implementation out of __init__.py as part of
+        # generalising its implementation. Ensure that we support loading
+        # pickles from 3.13 on older version of Python. Since 3.13 maintained a
+        # compatible API, pickles from older Python work natively on the newer
+        # version.
+        if module == 'pathlib._local':
+            module = 'pathlib'
+        return super().find_class(module, name)
 
 
 def pickle_load(file):
     try:
-        return pickle.load(file)
+        return Unpickler(file).load()
     # Python on Windows don't throw EOF errors for pipes. So reraise them with
     # the correct type, which is caught upwards.
     except OSError:

jedi/api/__init__.py

@@ -206,6 +206,7 @@ class Script:
             before magic methods and name mangled names that start with ``__``.
         :rtype: list of :class:`.Completion`
         """
+        self._inference_state.reset_recursion_limitations()
         with debug.increase_indent_cm('complete'):
             completion = Completion(
                 self._inference_state, self._get_module_context(), self._code_lines,
@@ -230,6 +231,7 @@ class Script:
         :param prefer_stubs: Prefer stubs to Python objects for this method.
         :rtype: list of :class:`.Name`
         """
+        self._inference_state.reset_recursion_limitations()
         pos = line, column
         leaf = self._module_node.get_name_of_position(pos)
         if leaf is None:
@@ -273,6 +275,7 @@ class Script:
         :param prefer_stubs: Prefer stubs to Python objects for this method.
         :rtype: list of :class:`.Name`
         """
+        self._inference_state.reset_recursion_limitations()
         tree_name = self._module_node.get_name_of_position((line, column))
         if tree_name is None:
             # Without a name we really just want to jump to the result e.g.
@@ -365,10 +368,17 @@ class Script:
 
         :rtype: list of :class:`.Name`
         """
+        self._inference_state.reset_recursion_limitations()
         definitions = self.goto(line, column, follow_imports=True)
         if definitions:
             return definitions
         leaf = self._module_node.get_leaf_for_position((line, column))
+
+        if leaf is not None and leaf.end_pos == (line, column) and leaf.type == 'newline':
+            next_ = leaf.get_next_leaf()
+            if next_ is not None and next_.start_pos == leaf.end_pos:
+                leaf = next_
+
         if leaf is not None and leaf.type in ('keyword', 'operator', 'error_leaf'):
             def need_pydoc():
                 if leaf.value in ('(', ')', '[', ']'):
@@ -400,6 +410,7 @@ class Script:
             the current module only.
         :rtype: list of :class:`.Name`
         """
+        self._inference_state.reset_recursion_limitations()
 
         def _references(include_builtins=True, scope='project'):
             if scope not in ('project', 'file'):
@@ -434,6 +445,7 @@ class Script:
 
         :rtype: list of :class:`.Signature`
         """
+        self._inference_state.reset_recursion_limitations()
         pos = line, column
         call_details = helpers.get_signature_details(self._module_node, pos)
         if call_details is None:
@@ -471,7 +483,7 @@ class Script:
 
         module_context = self._get_module_context()
 
-        n = tree.search_ancestor(leaf, 'funcdef', 'classdef')
+        n = leaf.search_ancestor('funcdef', 'classdef')
         if n is not None and n.start_pos < pos <= n.children[-1].start_pos:
             # This is a bit of a special case. The context of a function/class
             # name/param/keyword is always it's parent context, not the
@@ -553,6 +565,7 @@ class Script:
         return parso_to_jedi_errors(self._inference_state.grammar, self._module_node)
 
     def _names(self, all_scopes=False, definitions=True, references=False):
+        self._inference_state.reset_recursion_limitations()
         # Set line/column to a random position, because they don't matter.
         module_context = self._get_module_context()
         defs = [
@@ -708,7 +721,6 @@ class Interpreter(Script):
     :param namespaces: A list of namespace dictionaries such as the one
         returned by :func:`globals` and :func:`locals`.
     """
-    _allow_descriptor_getattr_default = True
 
     def __init__(self, code, namespaces, *, project=None, **kwds):
         try:
@@ -729,7 +741,16 @@ class Interpreter(Script):
         super().__init__(code, environment=environment, project=project, **kwds)
 
         self.namespaces = namespaces
-        self._inference_state.allow_descriptor_getattr = self._allow_descriptor_getattr_default
+        self._inference_state.allow_unsafe_executions = \
+            settings.allow_unsafe_interpreter_executions
+        # Dynamic params search is important when we work on functions that are
+        # called by other pieces of code. However for interpreter completions
+        # this is not important at all, because the current code is always new
+        # and will never be called by something.
+        # Also sometimes this logic goes a bit too far like in
+        # https://github.com/ipython/ipython/issues/13866, where it takes
+        # seconds to do a simple completion.
+        self._inference_state.do_dynamic_params_search = False
 
     @cache.memoize_method
     def _get_module_context(self):
@@ -758,8 +779,7 @@ def preload_module(*modules):
     :param modules: different module names, list of string.
     """
     for m in modules:
-        s = "import %s as x; x." % m
+        Script(f"import {m}").infer()
-        Script(s).complete(1, len(s))
 
 
 def set_debug_function(func_cb=debug.print_to_stdout, warnings=True,

jedi/api/classes.py

@@ -17,8 +17,6 @@ import re
 from pathlib import Path
 from typing import Optional
 
-from parso.tree import search_ancestor
-
 from jedi import settings
 from jedi import debug
 from jedi.inference.utils import unite
@@ -98,15 +96,14 @@ class BaseName:
     @property
     def module_path(self) -> Optional[Path]:
         """
-        Shows the file path of a module. e.g. ``/usr/lib/python3.9/os.py``
+        Shows the file path of a module. e.g. ``/usr/lib/python3.14/os.py``
         """
         module = self._get_module_context()
         if module.is_stub() or not module.is_compiled():
             # Compiled modules should not return a module path even if they
             # have one.
             path: Optional[Path] = self._get_module_context().py__file__()
-            if path is not None:
+            return path
-                return path
 
         return None
 
@@ -510,7 +507,7 @@ class BaseName:
             # - param: The parent_context of a param is not its function but
             #   e.g. the outer class or module.
             cls_or_func_node = self._name.tree_name.get_definition()
-            parent = search_ancestor(cls_or_func_node, 'funcdef', 'classdef', 'file_input')
+            parent = cls_or_func_node.search_ancestor('funcdef', 'classdef', 'file_input')
             context = self._get_module_context().create_value(parent).as_context()
         else:
             context = self._name.parent_context
@@ -834,7 +831,7 @@ class Signature(BaseSignature):
     def index(self):
         """
         Returns the param index of the current cursor position.
-        Returns None if the index cannot be found in the curent call.
+        Returns None if the index cannot be found in the current call.
 
         :rtype: int
         """

jedi/api/completion.py

@@ -1,10 +1,11 @@
 import re
 from textwrap import dedent
+from typing import Any
 from inspect import Parameter
 
 from parso.python.token import PythonTokenTypes
 from parso.python import tree
-from parso.tree import search_ancestor, Leaf
+from parso.tree import Leaf
 from parso import split_lines
 
 from jedi import debug
@@ -65,12 +66,15 @@ def _must_be_kwarg(signatures, positional_count, used_kwargs):
     return must_be_kwarg
 
 
-def filter_names(inference_state, completion_names, stack, like_name, fuzzy, cached_name):
+def filter_names(inference_state, completion_names, stack, like_name, fuzzy,
+                 imported_names, cached_name):
     comp_dct = set()
     if settings.case_insensitive_completion:
         like_name = like_name.lower()
     for name in completion_names:
         string = name.string_name
+        if string in imported_names and string != like_name:
+            continue
         if settings.case_insensitive_completion:
             string = string.lower()
         if helpers.match(string, like_name, fuzzy=fuzzy):
@@ -138,6 +142,11 @@ class Completion:
 
         self._fuzzy = fuzzy
 
+    # Return list of completions in this order:
+    # - Beginning with what user is typing
+    # - Public (alphabet)
+    # - Private ("_xxx")
+    # - Dunder ("__xxx")
     def complete(self):
         leaf = self._module_node.get_leaf_for_position(
             self._original_position,
@@ -169,14 +178,19 @@ class Completion:
 
         cached_name, completion_names = self._complete_python(leaf)
 
+        imported_names = []
+        if leaf.parent is not None and leaf.parent.type in ['import_as_names', 'dotted_as_names']:
+            imported_names.extend(extract_imported_names(leaf.parent))
+
         completions = list(filter_names(self._inference_state, completion_names,
                                         self.stack, self._like_name,
-                                        self._fuzzy, cached_name=cached_name))
+                                        self._fuzzy, imported_names, cached_name=cached_name))
 
         return (
             # Removing duplicates mostly to remove False/True/None duplicates.
             _remove_duplicates(prefixed_completions, completions)
-            + sorted(completions, key=lambda x: (x.name.startswith('__'),
+            + sorted(completions, key=lambda x: (not x.name.startswith(self._like_name),
+                                                 x.name.startswith('__'),
                                                  x.name.startswith('_'),
                                                  x.name.lower()))
         )
@@ -231,8 +245,8 @@ class Completion:
             if previous_leaf is not None:
                 stmt = previous_leaf
                 while True:
-                    stmt = search_ancestor(
+                    stmt = stmt.search_ancestor(
-                        stmt, 'if_stmt', 'for_stmt', 'while_stmt', 'try_stmt',
+                        'if_stmt', 'for_stmt', 'while_stmt', 'try_stmt',
                         'error_node',
                     )
                     if stmt is None:
@@ -252,7 +266,7 @@ class Completion:
                         elif type_ == 'for_stmt':
                             allowed_transitions.append('else')
 
-        completion_names = []
+        completion_names: list[Any] = []
 
         kwargs_only = False
         if any(t in allowed_transitions for t in (PythonTokenTypes.NAME,
@@ -277,6 +291,8 @@ class Completion:
                 )
             elif nonterminals[-1] in ('trailer', 'dotted_name') and nodes[-1] == '.':
                 dot = self._module_node.get_leaf_for_position(self._position)
+                if dot.type == "newline":
+                    dot = dot.get_previous_leaf()
                 if dot.type == "endmarker":
                     # This is a bit of a weird edge case, maybe we can somehow
                     # generalize this.
@@ -343,7 +359,7 @@ class Completion:
             stack_node = self.stack[-3]
         if stack_node.nonterminal == 'funcdef':
             context = get_user_context(self._module_context, self._position)
-            node = search_ancestor(leaf, 'error_node', 'funcdef')
+            node = leaf.search_ancestor('error_node', 'funcdef')
             if node is not None:
                 if node.type == 'error_node':
                     n = node.children[0]
@@ -413,7 +429,7 @@ class Completion:
         Autocomplete inherited methods when overriding in child class.
         """
         leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True)
-        cls = tree.search_ancestor(leaf, 'classdef')
+        cls = leaf.search_ancestor('classdef')
         if cls is None:
             return
 
@@ -442,6 +458,7 @@ class Completion:
         - Having some doctest code that starts with `>>>`
         - Having backticks that doesn't have whitespace inside it
         """
+
         def iter_relevant_lines(lines):
             include_next_line = False
             for l in code_lines:
@@ -664,3 +681,19 @@ def search_in_module(inference_state, module_context, names, wanted_names,
                     def_ = classes.Name(inference_state, n2)
                 if not wanted_type or wanted_type == def_.type:
                     yield def_
+
+
+def extract_imported_names(node):
+    imported_names = []
+
+    if node.type in ['import_as_names', 'dotted_as_names', 'dotted_as_name', 'import_as_name']:
+        for index, child in enumerate(node.children):
+            if child.type == 'name':
+                if (index > 1 and node.children[index - 1].type == "keyword"
+                        and node.children[index - 1].value == "as"):
+                    continue
+                imported_names.append(child.value)
+            elif child.type in ('import_as_name', 'dotted_as_name'):
+                imported_names.extend(extract_imported_names(child))
+
+    return imported_names

jedi/api/environment.py

@@ -8,6 +8,7 @@ import hashlib
 import filecmp
 from collections import namedtuple
 from shutil import which
+from typing import TYPE_CHECKING, Any
 
 from jedi.cache import memoize_method, time_cache
 from jedi.inference.compiled.subprocess import CompiledSubprocess, \
@@ -15,9 +16,13 @@ from jedi.inference.compiled.subprocess import CompiledSubprocess, \
 
 import parso
 
-_VersionInfo = namedtuple('VersionInfo', 'major minor micro')
+if TYPE_CHECKING:
+    from jedi.inference import InferenceState
 
-_SUPPORTED_PYTHONS = ['3.10', '3.9', '3.8', '3.7', '3.6']
+
+_VersionInfo = namedtuple('VersionInfo', 'major minor micro')  # type: ignore[name-match]
+
+_SUPPORTED_PYTHONS = ['3.14', '3.13', '3.12', '3.11', '3.10']
 _SAFE_PATHS = ['/usr/bin', '/usr/local/bin']
 _CONDA_VAR = 'CONDA_PREFIX'
 _CURRENT_VERSION = '%s.%s' % (sys.version_info.major, sys.version_info.minor)
@@ -31,6 +36,9 @@ class InvalidPythonEnvironment(Exception):
 
 
 class _BaseEnvironment:
+    version_info: Any
+    executable: Any
+
     @memoize_method
     def get_grammar(self):
         version_string = '%s.%s' % (self.version_info.major, self.version_info.minor)
@@ -102,7 +110,10 @@ class Environment(_BaseEnvironment):
         version = '.'.join(str(i) for i in self.version_info)
         return '<%s: %s in %s>' % (self.__class__.__name__, version, self.path)
 
-    def get_inference_state_subprocess(self, inference_state):
+    def get_inference_state_subprocess(
+        self,
+        inference_state: 'InferenceState',
+    ) -> InferenceStateSubprocess:
         return InferenceStateSubprocess(inference_state, self._get_subprocess())
 
     @memoize_method
@@ -134,7 +145,10 @@ class SameEnvironment(_SameEnvironmentMixin, Environment):
 
 
 class InterpreterEnvironment(_SameEnvironmentMixin, _BaseEnvironment):
-    def get_inference_state_subprocess(self, inference_state):
+    def get_inference_state_subprocess(
+        self,
+        inference_state: 'InferenceState',
+    ) -> InferenceStateSameProcess:
         return InferenceStateSameProcess(inference_state)
 
     def get_sys_path(self):
@@ -240,7 +254,7 @@ def get_cached_default_environment():
     # /path/to/env so we need to fully resolve the paths in order to
     # compare them.
     if var and os.path.realpath(var) != os.path.realpath(environment.path):
-        _get_cached_default_environment.clear_cache()
+        _get_cached_default_environment.clear_cache()  # type: ignore[attr-defined]
         return _get_cached_default_environment()
     return environment
 
@@ -344,7 +358,7 @@ def get_system_environment(version, *, env_vars=None):
             return SameEnvironment()
         return Environment(exe)
 
-    if os.name == 'nt':
+    if sys.platform == "win32":
         for exe in _get_executables_from_windows_registry(version):
             try:
                 return Environment(exe, env_vars=env_vars)
@@ -372,39 +386,42 @@ def _get_executable_path(path, safe=True):
     Returns None if it's not actually a virtual env.
     """
 
-    if os.name == 'nt':
+    if sys.platform == "win32":
-        python = os.path.join(path, 'Scripts', 'python.exe')
+        pythons = [os.path.join(path, 'Scripts', 'python.exe'), os.path.join(path, 'python.exe')]
+    else:
+        pythons = [os.path.join(path, 'bin', 'python')]
+    for python in pythons:
+        if os.path.exists(python):
+            break
     else:
-        python = os.path.join(path, 'bin', 'python')
-    if not os.path.exists(python):
         raise InvalidPythonEnvironment("%s seems to be missing." % python)
 
     _assert_safe(python, safe)
     return python
 
 
-def _get_executables_from_windows_registry(version):
+if sys.platform == "win32":
-    # https://github.com/python/typeshed/pull/3794 adds winreg
+    def _get_executables_from_windows_registry(version):
-    import winreg  # type: ignore[import]
+        import winreg
 
-    # TODO: support Python Anaconda.
+        # TODO: support Python Anaconda.
-    sub_keys = [
+        sub_keys = [
-        r'SOFTWARE\Python\PythonCore\{version}\InstallPath',
+            r'SOFTWARE\Python\PythonCore\{version}\InstallPath',
-        r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}\InstallPath',
+            r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}\InstallPath',
-        r'SOFTWARE\Python\PythonCore\{version}-32\InstallPath',
+            r'SOFTWARE\Python\PythonCore\{version}-32\InstallPath',
-        r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}-32\InstallPath'
+            r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}-32\InstallPath'
-    ]
+        ]
-    for root_key in [winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE]:
+        for root_key in [winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE]:
-        for sub_key in sub_keys:
+            for sub_key in sub_keys:
-            sub_key = sub_key.format(version=version)
+                sub_key = sub_key.format(version=version)
-            try:
+                try:
-                with winreg.OpenKey(root_key, sub_key) as key:
+                    with winreg.OpenKey(root_key, sub_key) as key:
-                    prefix = winreg.QueryValueEx(key, '')[0]
+                        prefix = winreg.QueryValueEx(key, '')[0]
-                    exe = os.path.join(prefix, 'python.exe')
+                        exe = os.path.join(prefix, 'python.exe')
-                    if os.path.isfile(exe):
+                        if os.path.isfile(exe):
-                        yield exe
+                            yield exe
-            except WindowsError:
+                except WindowsError:
-                pass
+                    pass
 
 
 def _assert_safe(executable_path, safe):

jedi/api/interpreter.py

@@ -61,6 +61,7 @@ class MixedModuleContext(ModuleContext):
         )
 
     def get_filters(self, until_position=None, origin_scope=None):
+
         yield MergedFilter(
             MixedParserTreeFilter(
                 parent_context=self,
@@ -72,3 +73,10 @@ class MixedModuleContext(ModuleContext):
 
         for mixed_object in self.mixed_values:
             yield from mixed_object.get_filters(until_position, origin_scope)
+
+        # Now that we have merged the filter for this mixed context we have to
+        # remove the first entry (which is the module itself), but we want to
+        # add the other filters like the star imports.
+        filters = self._value.get_filters(origin_scope)
+        next(filters, None)
+        yield from filters

jedi/api/keywords.py

@@ -5,8 +5,7 @@ from typing import Dict, Optional
 from jedi.inference.names import AbstractArbitraryName
 
 try:
-    # https://github.com/python/typeshed/pull/4351 adds pydoc_data
+    from pydoc_data import topics
-    from pydoc_data import topics  # type: ignore[import]
     pydoc_topics: Optional[Dict[str, str]] = topics.topics
 except ImportError:
     # Python 3.6.8 embeddable does not have pydoc_data.
@@ -42,7 +41,7 @@ def imitate_pydoc(string):
 
     try:
         # is a tuple now
-        label, related = string
+        label, related = string  # type: ignore[misc]
     except TypeError:
         return ''
 

jedi/api/refactoring/__init__.py

@@ -5,6 +5,7 @@ from typing import Dict, Iterable, Tuple
 from parso import split_lines
 
 from jedi.api.exceptions import RefactoringError
+from jedi.inference.value.namespace import ImplicitNSName
 
 EXPRESSION_PARTS = (
     'or_test and_test not_test comparison '
@@ -102,7 +103,12 @@ class Refactoring:
                 to_path=calculate_to_path(path),
                 module_node=next(iter(map_)).get_root_node(),
                 node_to_str_map=map_
-            ) for path, map_ in sorted(self._file_to_node_changes.items())
+            )
+            # We need to use `or`, because the path can be None
+            for path, map_ in sorted(
+                self._file_to_node_changes.items(),
+                key=lambda x: x[0] or Path("")
+            )
         }
 
     def get_renames(self) -> Iterable[Tuple[Path, Path]]:
@@ -116,7 +122,7 @@ class Refactoring:
         project_path = self._inference_state.project.path
         for from_, to in self.get_renames():
             text += 'rename from %s\nrename to %s\n' \
-                % (from_.relative_to(project_path), to.relative_to(project_path))
+                % (_try_relative_to(from_, project_path), _try_relative_to(to, project_path))
 
         return text + ''.join(f.get_diff() for f in self.get_changed_files().values())
 
@@ -146,13 +152,16 @@ def rename(inference_state, definitions, new_name):
         raise RefactoringError("There is no name under the cursor")
 
     for d in definitions:
+        # This private access is ok in a way. It's not public to
+        # protect Jedi users from seeing it.
         tree_name = d._name.tree_name
-        if d.type == 'module' and tree_name is None:
+        if d.type == 'module' and tree_name is None and d.module_path is not None:
-            p = None if d.module_path is None else Path(d.module_path)
+            p = Path(d.module_path)
             file_renames.add(_calculate_rename(p, new_name))
+        elif isinstance(d._name, ImplicitNSName):
+            for p in d._name._value.py__path__():
+                file_renames.add(_calculate_rename(Path(p), new_name))
         else:
-            # This private access is ok in a way. It's not public to
-            # protect Jedi users from seeing it.
             if tree_name is not None:
                 fmap = file_tree_name_map.setdefault(d.module_path, {})
                 fmap[tree_name] = tree_name.prefix + new_name
@@ -246,3 +255,10 @@ def _remove_indent_of_prefix(prefix):
     Removes the last indentation of a prefix, e.g. " \n \n " becomes " \n \n".
     """
     return ''.join(split_lines(prefix, keepends=True)[:-1])
+
+
+def _try_relative_to(path: Path, base: Path) -> Path:
+    try:
+        return path.relative_to(base)
+    except ValueError:
+        return path

jedi/api/replstartup.py

@@ -9,7 +9,7 @@ just use IPython instead::
 Then you will be able to use Jedi completer in your Python interpreter::
 
     $ python
-    Python 3.9.2+ (default, Jul 20 2020, 22:15:08)
+    Python 3.14.0+ (default, Jul 20 2020, 22:15:08)
     [GCC 4.6.1] on linux2
     Type "help", "copyright", "credits" or "license" for more information.
     >>> import os

jedi/api/strings.py

@@ -36,8 +36,11 @@ def complete_dict(module_context, code_lines, leaf, position, string, fuzzy):
             string = cut_value_at_position(leaf, position)
 
         context = module_context.create_context(bracket_leaf)
-        before_bracket_leaf = bracket_leaf.get_previous_leaf()
+
-        if before_bracket_leaf.type in ('atom', 'trailer', 'name'):
+        before_node = before_bracket_leaf = bracket_leaf.get_previous_leaf()
+        if before_node in (')', ']', '}'):
+            before_node = before_node.parent
+        if before_node.type in ('atom', 'trailer', 'name'):
             values = infer_call_of_leaf(context, before_bracket_leaf)
             return list(_completions_for_dicts(
                 module_context.inference_state,

jedi/cache.py

@@ -28,7 +28,7 @@ def clear_time_caches(delete_all: bool = False) -> None:
     :param delete_all: Deletes also the cache that is normally not deleted,
         like parser cache, which is important for faster parsing.
     """
-    global _time_caches
+    global _time_caches  # noqa: F824
 
     if delete_all:
         for cache in _time_caches.values():
@@ -93,7 +93,7 @@ def time_cache(seconds):
             cache[key] = time.time(), result
             return result
 
-        wrapper.clear_cache = lambda: cache.clear()
+        wrapper.clear_cache = lambda: cache.clear()  # type: ignore[attr-defined]
         return wrapper
 
     return decorator

jedi/debug.py

@@ -21,7 +21,7 @@ try:
         raise ImportError
     else:
         # Use colorama for nicer console output.
-        from colorama import Fore, init  # type: ignore[import]
+        from colorama import Fore, init  # type: ignore[import, unused-ignore]
         from colorama import initialise
 
         def _lazy_colorama_init():  # noqa: F811
@@ -36,7 +36,7 @@ try:
                 # pytest resets the stream at the end - causes troubles. Since
                 # after every output the stream is reset automatically we don't
                 # need this.
-                initialise.atexit_done = True
+                initialise.atexit_done = True  # type: ignore[attr-defined]
                 try:
                     init(strip=False)
                 except Exception:

jedi/file_io.py

@@ -1,4 +1,5 @@
 import os
+from typing import Any
 
 from parso import file_io
 
@@ -58,6 +59,8 @@ class FolderIO(AbstractFolderIO):
 
 
 class FileIOFolderMixin:
+    path: Any
+
     def get_parent_folder(self):
         return FolderIO(os.path.dirname(self.path))
 

jedi/inference/__init__.py

@@ -62,6 +62,8 @@ I need to mention now that lazy type inference is really good because it
 only *inferes* what needs to be *inferred*. All the statements and modules
 that are not used are just being ignored.
 """
+from typing import Any
+
 import parso
 from jedi.file_io import FileIO
 
@@ -82,6 +84,8 @@ from jedi.plugins import plugin_manager
 
 
 class InferenceState:
+    analysis_modules: "list[Any]"
+
     def __init__(self, project, environment=None, script_path=None):
         if environment is None:
             environment = project.get_environment()
@@ -90,7 +94,7 @@ class InferenceState:
         self.compiled_subprocess = environment.get_inference_state_subprocess(self)
         self.grammar = environment.get_grammar()
 
-        self.latest_grammar = parso.load_grammar(version='3.10')
+        self.latest_grammar = parso.load_grammar(version='3.13')
         self.memoize_cache = {}  # for memoize decorators
         self.module_cache = imports.ModuleCache()  # does the job of `sys.modules`.
         self.stub_module_cache = {}  # Dict[Tuple[str, ...], Optional[ModuleValue]]
@@ -99,10 +103,11 @@ class InferenceState:
         self.mixed_cache = {}  # see `inference.compiled.mixed._create()`
         self.analysis = []
         self.dynamic_params_depth = 0
+        self.do_dynamic_params_search = settings.dynamic_params
         self.is_analysis = False
         self.project = project
         self.access_cache = {}
-        self.allow_descriptor_getattr = False
+        self.allow_unsafe_executions = False
         self.flow_analysis_enabled = True
 
         self.reset_recursion_limitations()
@@ -120,20 +125,34 @@ class InferenceState:
         debug.dbg('execute result: %s in %s', value_set, value)
         return value_set
 
-    # mypy doesn't suppport decorated propeties (https://github.com/python/mypy/issues/1362)
+    # mypy doesn't support decorated properties (https://github.com/python/mypy/issues/1362)
-    @property  # type: ignore[misc]
+    @property
     @inference_state_function_cache()
     def builtins_module(self):
         module_name = 'builtins'
-        builtins_module, = self.import_module((module_name,), sys_path=())
+        builtins_module, = self.import_module((module_name,), sys_path=[])
         return builtins_module
 
-    @property  # type: ignore[misc]
+    @property
     @inference_state_function_cache()
     def typing_module(self):
         typing_module, = self.import_module(('typing',))
         return typing_module
 
+    @property
+    @inference_state_function_cache()
+    def types_module(self):
+        typing_module, = self.import_module(('types',))
+        return typing_module
+
+    @inference_state_function_cache()
+    def typing_tuple(self):
+        return self.typing_module.py__getattribute__("Tuple")
+
+    @inference_state_function_cache()
+    def typing_type(self):
+        return self.typing_module.py__getattribute__("Type")
+
     def reset_recursion_limitations(self):
         self.recursion_detector = recursion.RecursionDetector()
         self.execution_recursion_detector = recursion.ExecutionRecursionDetector(self)

jedi/inference/analysis.py

@@ -110,7 +110,7 @@ def _check_for_setattr(instance):
 
 def add_attribute_error(name_context, lookup_value, name):
     message = ('AttributeError: %s has no attribute %s.' % (lookup_value, name))
-    # Check for __getattr__/__getattribute__ existance and issue a warning
+    # Check for __getattr__/__getattribute__ existence and issue a warning
     # instead of an error, if that happens.
     typ = Error
     if lookup_value.is_instance() and not lookup_value.is_compiled():

jedi/inference/arguments.py

@@ -1,5 +1,6 @@
 import re
 from itertools import zip_longest
+from typing import Any
 
 from parso.python import tree
 
@@ -134,7 +135,7 @@ class _AbstractArgumentsMixin:
 
 class AbstractArguments(_AbstractArgumentsMixin):
     context = None
-    argument_node = None
+    argument_node: Any = None
     trailer = None
 
 
@@ -164,6 +165,8 @@ def unpack_arglist(arglist):
 
 
 class TreeArguments(AbstractArguments):
+    context: Any
+
     def __init__(self, inference_state, context, argument_node, trailer=None):
         """
         :param argument_node: May be an argument_node or a list of nodes.

jedi/inference/base_value.py

@@ -9,6 +9,7 @@ just one.
 from functools import reduce
 from operator import add
 from itertools import zip_longest
+from typing import TYPE_CHECKING, Any
 
 from parso.python.tree import Name
 
@@ -21,12 +22,25 @@ from jedi.cache import memoize_method
 
 sentinel = object()
 
+if TYPE_CHECKING:
+    from jedi.inference import InferenceState
+
 
 class HasNoContext(Exception):
     pass
 
 
 class HelperValueMixin:
+    parent_context: Any
+    inference_state: "InferenceState"
+    name: Any
+    get_filters: Any
+    is_stub: Any
+    py__getattribute__alternatives: Any
+    py__iter__: Any
+    py__mro__: Any
+    _as_context: Any
+
     def get_root_context(self):
         value = self
         if value.parent_context is None:
@@ -45,7 +59,7 @@ class HelperValueMixin:
         arguments = ValuesArguments([ValueSet([value]) for value in value_list])
         return self.inference_state.execute(self, arguments)
 
-    def execute_annotation(self):
+    def execute_annotation(self, context):
         return self.execute_with_values()
 
     def gather_annotation_classes(self):
@@ -337,11 +351,16 @@ class _ValueWrapperBase(HelperValueMixin):
 
 
 class LazyValueWrapper(_ValueWrapperBase):
-    @safe_property
+    if TYPE_CHECKING:
-    @memoize_method
+        @property
-    def _wrapped_value(self):
+        def _wrapped_value(self) -> Any:
-        with debug.increase_indent_cm('Resolve lazy value wrapper'):
+            return
-            return self._get_wrapped_value()
+    else:
+        @safe_property
+        @memoize_method
+        def _wrapped_value(self):
+            with debug.increase_indent_cm('Resolve lazy value wrapper'):
+                return self._get_wrapped_value()
 
     def __repr__(self):
         return '<%s>' % (self.__class__.__name__)
@@ -499,7 +518,7 @@ class ValueSet:
         return ValueSet.from_sets(_getitem(c, *args, **kwargs) for c in self._set)
 
     def try_merge(self, function_name):
-        value_set = self.__class__([])
+        value_set = ValueSet([])
         for c in self._set:
             try:
                 method = getattr(c, function_name)

jedi/inference/compiled/__init__.py

@@ -14,8 +14,9 @@ def builtin_from_name(inference_state, string):
     else:
         filter_ = next(typing_builtins_module.get_filters())
     name, = filter_.get(string)
-    value, = name.infer()
+    # Most of the time there is only symbol, but sometimes there are different
-    return value
+    # sys.version_infos, where there are multiple ones, just use the first one.
+    return next(iter(name.infer()))
 
 
 class ExactValue(LazyValueWrapper):

jedi/inference/compiled/access.py

@@ -9,7 +9,7 @@ import re
 import builtins
 import typing
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 
 from jedi.inference.compiled.getattr_static import getattr_static
 
@@ -40,7 +40,7 @@ NOT_CLASS_TYPES = (
 MethodDescriptorType = type(str.replace)
 WrapperDescriptorType = type(set.__iter__)
 # `object.__subclasshook__` is an already executed descriptor.
-object_class_dict = type.__dict__["__dict__"].__get__(object)
+object_class_dict = type.__dict__["__dict__"].__get__(object)  # type: ignore[index]
 ClassMethodDescriptorType = type(object_class_dict['__subclasshook__'])
 
 _sentinel = object()
@@ -147,7 +147,7 @@ class AccessPath:
         self.accesses = accesses
 
 
-def create_access_path(inference_state, obj):
+def create_access_path(inference_state, obj) -> AccessPath:
     access = create_access(inference_state, obj)
     return AccessPath(access.get_access_path_tuples())
 
@@ -175,7 +175,7 @@ class DirectObjectAccess:
     def _create_access(self, obj):
         return create_access(self._inference_state, obj)
 
-    def _create_access_path(self, obj):
+    def _create_access_path(self, obj) -> AccessPath:
         return create_access_path(self._inference_state, obj)
 
     def py__bool__(self):
@@ -184,7 +184,7 @@ class DirectObjectAccess:
     def py__file__(self) -> Optional[Path]:
         try:
             return Path(self._obj.__file__)
-        except AttributeError:
+        except (AttributeError, TypeError):
             return None
 
     def py__doc__(self):
@@ -230,8 +230,8 @@ class DirectObjectAccess:
                 return [annotation]
         return None
 
-    def py__simple_getitem__(self, index):
+    def py__simple_getitem__(self, index, *, safe=True):
-        if type(self._obj) not in ALLOWED_GETITEM_TYPES:
+        if safe and type(self._obj) not in ALLOWED_GETITEM_TYPES:
             # Get rid of side effects, we won't call custom `__getitem__`s.
             return None
 
@@ -329,33 +329,37 @@ class DirectObjectAccess:
         except TypeError:
             return False
 
-    def is_allowed_getattr(self, name, safe=True):
+    def is_allowed_getattr(self, name, safe=True) -> Tuple[bool, bool, Optional[AccessPath]]:
         # TODO this API is ugly.
-        if not safe:
-            # Unsafe is mostly used to check for __getattr__/__getattribute__.
-            # getattr_static works for properties, but the underscore methods
-            # are just ignored (because it's safer and avoids more code
-            # execution). See also GH #1378.
-
-            # Avoid warnings, see comment in the next function.
-            with warnings.catch_warnings(record=True):
-                warnings.simplefilter("always")
-                try:
-                    return hasattr(self._obj, name), False
-                except Exception:
-                    # Obviously has an attribute (propably a property) that
-                    # gets executed, so just avoid all exceptions here.
-                    return False, False
         try:
             attr, is_get_descriptor = getattr_static(self._obj, name)
         except AttributeError:
-            return False, False
+            if not safe:
+                # Unsafe is mostly used to check for __getattr__/__getattribute__.
+                # getattr_static works for properties, but the underscore methods
+                # are just ignored (because it's safer and avoids more code
+                # execution). See also GH #1378.
+
+                # Avoid warnings, see comment in the next function.
+                with warnings.catch_warnings(record=True):
+                    warnings.simplefilter("always")
+                    try:
+                        return hasattr(self._obj, name), False, None
+                    except Exception:
+                        # Obviously has an attribute (probably a property) that
+                        # gets executed, so just avoid all exceptions here.
+                        pass
+            return False, False, None
         else:
             if is_get_descriptor and type(attr) not in ALLOWED_DESCRIPTOR_ACCESS:
+                if isinstance(attr, property):
+                    if hasattr(attr.fget, '__annotations__'):
+                        a = DirectObjectAccess(self._inference_state, attr.fget)
+                        return True, True, a.get_return_annotation()
                 # In case of descriptors that have get methods we cannot return
                 # it's value, because that would mean code execution.
-                return True, True
+                return True, True, None
-        return True, False
+        return True, False, None
 
     def getattr_paths(self, name, default=_sentinel):
         try:
@@ -467,18 +471,23 @@ class DirectObjectAccess:
         op = _OPERATORS[operator]
         return self._create_access_path(op(self._obj, other_access._obj))
 
-    def get_annotation_name_and_args(self):
+    def get_annotation_name_and_args(self) -> tuple[str | None, tuple[AccessPath, ...]]:
         """
         Returns Tuple[Optional[str], Tuple[AccessPath, ...]]
         """
         name = None
         args = ()
-        if safe_getattr(self._obj, '__module__', default='') == 'typing':
+        if type(self._obj) is typing.Union:  # zuban: ignore[comparison-overlap]  # TODO zuban
+            # This is mostly formatted like `int | str` and we therefor need to
+            # check the type.
+            args = typing.get_args(self._obj)
+            name = "Union"
+        elif safe_getattr(self._obj, '__module__', default='') == 'typing':
+            # Try regex first (works for most types)
             m = re.match(r'typing.(\w+)\[', repr(self._obj))
             if m is not None:
                 name = m.group(1)
 
-                import typing
                 if sys.version_info >= (3, 8):
                     args = typing.get_args(self._obj)
                 else:
@@ -489,6 +498,18 @@ class DirectObjectAccess:
         return inspect.isclass(self._obj) and self._obj != type
 
     def _annotation_to_str(self, annotation):
+        # In Python 3.14+, Union types are displayed as X | Y instead of Union[X, Y]
+        # We normalize to that for consistency
+        import typing
+        origin = typing.get_origin(annotation)
+        if origin is typing.Union:
+            # Get the args and format them as Union[...]
+            args = typing.get_args(annotation)
+            return ' | '.join(
+                self._annotation_to_str(arg) if hasattr(arg, '__origin__')
+                else getattr(arg, '__name__', str(arg))
+                for arg in args
+            )
         return inspect.formatannotation(annotation)
 
     def get_signature_params(self):
@@ -515,7 +536,7 @@ class DirectObjectAccess:
             # the signature. In that case we just want a simple escape for now.
             raise ValueError
 
-    def get_return_annotation(self):
+    def get_return_annotation(self) -> Optional[AccessPath]:
         try:
             o = self._obj.__annotations__.get('return')
         except AttributeError:

jedi/inference/compiled/getattr_static.py

@@ -39,7 +39,7 @@ def _is_type(obj):
 
 
 def _shadowed_dict(klass):
-    dict_attr = type.__dict__["__dict__"]
+    dict_attr = type.__dict__["__dict__"]  # type: ignore[index]
     for entry in _static_getmro(klass):
         try:
             class_dict = dict_attr.__get__(entry)["__dict__"]
@@ -54,7 +54,7 @@ def _shadowed_dict(klass):
 
 
 def _static_getmro(klass):
-    mro = type.__dict__['__mro__'].__get__(klass)
+    mro = type.__dict__['__mro__'].__get__(klass)  # type: ignore[index]
     if not isinstance(mro, (tuple, list)):
         # There are unfortunately no tests for this, I was not able to
         # reproduce this in pure Python. However should still solve the issue
@@ -90,7 +90,10 @@ def getattr_static(obj, attr, default=_sentinel):
     if not _is_type(obj):
         klass = type(obj)
         dict_attr = _shadowed_dict(klass)
-        if (dict_attr is _sentinel or type(dict_attr) is types.MemberDescriptorType):
+        # In Python 3.15+, __dict__ is a GetSetDescriptorType instead of being _sentinel
+        if (dict_attr is _sentinel
+                or type(dict_attr) is types.MemberDescriptorType
+                or type(dict_attr) is types.GetSetDescriptorType):
             instance_result = _check_instance(obj, attr)
     else:
         klass = obj

jedi/inference/compiled/mixed.py

@@ -142,9 +142,9 @@ class MixedObjectFilter(compiled.CompiledValueFilter):
         super().__init__(inference_state, compiled_value)
         self._tree_value = tree_value
 
-    def _create_name(self, name):
+    def _create_name(self, *args, **kwargs):
         return MixedName(
-            super()._create_name(name),
+            super()._create_name(*args, **kwargs),
             self._tree_value,
         )
 

jedi/inference/compiled/subprocess/__init__.py

@@ -5,6 +5,23 @@ goals:
 1. Making it safer - Segfaults and RuntimeErrors as well as stdout/stderr can
    be ignored and dealt with.
 2. Make it possible to handle different Python versions as well as virtualenvs.
+
+The architecture here is briefly:
+ - For each Jedi `Environment` there is a corresponding subprocess which
+   operates within the target environment. If the subprocess dies it is replaced
+   at this level.
+ - `CompiledSubprocess` manages exactly one subprocess and handles communication
+   from the parent side.
+ - `Listener` runs within the subprocess, processing each request and yielding
+   results.
+ - `InterpreterEnvironment` provides an API which matches that of `Environment`,
+   but runs functionality inline rather than within a subprocess. It is thus
+   used both directly in places where a subprocess is unnecessary and/or
+   undesirable and also within subprocesses themselves.
+ - `InferenceStateSubprocess` (or `InferenceStateSameProcess`) provide high
+   level access to functionality within the subprocess from within the parent.
+   Each `InterpreterState` has an instance of one of these, provided by its
+   environment.
 """
 
 import collections
@@ -16,6 +33,7 @@ import traceback
 import weakref
 from functools import partial
 from threading import Thread
+from typing import Dict, TYPE_CHECKING, Any
 
 from jedi._compatibility import pickle_dump, pickle_load
 from jedi import debug
@@ -25,13 +43,16 @@ from jedi.inference.compiled.access import DirectObjectAccess, AccessPath, \
     SignatureParam
 from jedi.api.exceptions import InternalError
 
+if TYPE_CHECKING:
+    from jedi.inference import InferenceState
+
 
 _MAIN_PATH = os.path.join(os.path.dirname(__file__), '__main__.py')
 PICKLE_PROTOCOL = 4
 
 
 def _GeneralizedPopen(*args, **kwargs):
-    if os.name == 'nt':
+    if sys.platform == "win32":
         try:
             # Was introduced in Python 3.7.
             CREATE_NO_WINDOW = subprocess.CREATE_NO_WINDOW
@@ -83,10 +104,11 @@ def _cleanup_process(process, thread):
 
 
 class _InferenceStateProcess:
-    def __init__(self, inference_state):
+    get_compiled_method_return: Any
+
+    def __init__(self, inference_state: 'InferenceState') -> None:
         self._inference_state_weakref = weakref.ref(inference_state)
-        self._inference_state_id = id(inference_state)
+        self._handles: Dict[int, AccessHandle] = {}
-        self._handles = {}
 
     def get_or_create_access_handle(self, obj):
         id_ = id(obj)
@@ -116,11 +138,49 @@ class InferenceStateSameProcess(_InferenceStateProcess):
 
 
 class InferenceStateSubprocess(_InferenceStateProcess):
-    def __init__(self, inference_state, compiled_subprocess):
+    """
+    API to functionality which will run in a subprocess.
+
+    This mediates the interaction between an `InferenceState` and the actual
+    execution of functionality running within a `CompiledSubprocess`. Available
+    functions are defined in `.functions`, though should be accessed via
+    attributes on this class of the same name.
+
+    This class is responsible for indicating that the `InferenceState` within
+    the subprocess can be removed once the corresponding instance in the parent
+    goes away.
+    """
+
+    def __init__(
+        self,
+        inference_state: 'InferenceState',
+        compiled_subprocess: 'CompiledSubprocess',
+    ) -> None:
         super().__init__(inference_state)
         self._used = False
         self._compiled_subprocess = compiled_subprocess
 
+        # Opaque id we'll pass to the subprocess to identify the context (an
+        # `InferenceState`) which should be used for the request. This allows us
+        # to make subsequent requests which operate on results from previous
+        # ones, while keeping a single subprocess which can work with several
+        # contexts in the parent process. Once it is no longer needed(i.e: when
+        # this class goes away), we also use this id to indicate that the
+        # subprocess can discard the context.
+        #
+        # Note: this id is deliberately coupled to this class (and not to
+        # `InferenceState`) as this class manages access handle mappings which
+        # must correspond to those in the subprocess. This approach also avoids
+        # race conditions from successive `InferenceState`s with the same object
+        # id (as observed while adding support for Python 3.13).
+        #
+        # This value does not need to be the `id()` of this instance, we merely
+        # need to ensure that it enables the (visible) lifetime of the context
+        # within the subprocess to match that of this class. We therefore also
+        # depend on the semantics of `CompiledSubprocess.delete_inference_state`
+        # for correctness.
+        self._inference_state_id = id(self)
+
     def __getattr__(self, name):
         func = _get_function(name)
 
@@ -128,7 +188,7 @@ class InferenceStateSubprocess(_InferenceStateProcess):
             self._used = True
 
             result = self._compiled_subprocess.run(
-                self._inference_state_weakref(),
+                self._inference_state_id,
                 func,
                 args=args,
                 kwargs=kwargs,
@@ -164,6 +224,17 @@ class InferenceStateSubprocess(_InferenceStateProcess):
 
 
 class CompiledSubprocess:
+    """
+    A subprocess which runs inference within a target environment.
+
+    This class manages the interface to a single instance of such a process as
+    well as the lifecycle of the process itself. See `.__main__` and `Listener`
+    for the implementation of the subprocess and details of the protocol.
+
+    A single live instance of this is maintained by `jedi.api.environment.Environment`,
+    so that typically a single subprocess is used at a time.
+    """
+
     is_crashed = False
 
     def __init__(self, executable, env_vars=None):
@@ -213,18 +284,18 @@ class CompiledSubprocess:
                                                   t)
         return process
 
-    def run(self, inference_state, function, args=(), kwargs={}):
+    def run(self, inference_state_id, function, args=(), kwargs={}):
         # Delete old inference_states.
         while True:
             try:
-                inference_state_id = self._inference_state_deletion_queue.pop()
+                delete_id = self._inference_state_deletion_queue.pop()
             except IndexError:
                 break
             else:
-                self._send(inference_state_id, None)
+                self._send(delete_id, None)
 
         assert callable(function)
-        return self._send(id(inference_state), function, args, kwargs)
+        return self._send(inference_state_id, function, args, kwargs)
 
     def get_sys_path(self):
         return self._send(None, functions.get_sys_path, (), {})
@@ -272,21 +343,65 @@ class CompiledSubprocess:
 
     def delete_inference_state(self, inference_state_id):
         """
-        Currently we are not deleting inference_state instantly. They only get
+        Indicate that an inference state (in the subprocess) is no longer
-        deleted once the subprocess is used again. It would probably a better
+        needed.
-        solution to move all of this into a thread. However, the memory usage
+
-        of a single inference_state shouldn't be that high.
+        The state corresponding to the given id will become inaccessible and the
+        id may safely be re-used to refer to a different context.
+
+        Note: it is not guaranteed that the corresponding state will actually be
+        deleted immediately.
         """
-        # With an argument - the inference_state gets deleted.
+        # Warning: if changing the semantics of context deletion see the comment
+        # in `InferenceStateSubprocess.__init__` regarding potential race
+        # conditions.
+
+        # Currently we are not deleting the related state instantly. They only
+        # get deleted once the subprocess is used again. It would probably a
+        # better solution to move all of this into a thread. However, the memory
+        # usage of a single inference_state shouldn't be that high.
         self._inference_state_deletion_queue.append(inference_state_id)
 
 
 class Listener:
+    """
+    Main loop for the subprocess which actually does the inference.
+
+    This class runs within the target environment. It listens to instructions
+    from the parent process, runs inference and returns the results.
+
+    The subprocess has a long lifetime and is expected to process several
+    requests, including for different `InferenceState` instances in the parent.
+    See `CompiledSubprocess` for the parent half of the system.
+
+    Communication is via pickled data sent serially over stdin and stdout.
+    Stderr is read only if the child process crashes.
+
+    The request protocol is a 4-tuple of:
+     * inference_state_id | None: an opaque identifier of the parent's
+       `InferenceState`. An `InferenceState` operating over an
+       `InterpreterEnvironment` is created within this process for each of
+       these, ensuring that each parent context has a corresponding context
+       here. This allows context to be persisted between requests. Unless
+       `None`, the local `InferenceState` will be passed to the given function
+       as the first positional argument.
+     * function | None: the function to run. This is expected to be a member of
+       `.functions`. `None` indicates that the corresponding inference state is
+       no longer needed and should be dropped.
+     * args: positional arguments to the `function`. If any of these are
+       `AccessHandle` instances they will be adapted to the local
+       `InferenceState` before being passed.
+     * kwargs: keyword arguments to the `function`. If any of these are
+       `AccessHandle` instances they will be adapted to the local
+       `InferenceState` before being passed.
+
+    The result protocol is a 3-tuple of either:
+     * (False, None, function result): if the function returns without error, or
+     * (True, traceback, exception): if the function raises an exception
+    """
+
     def __init__(self):
         self._inference_states = {}
-        # TODO refactor so we don't need to process anymore just handle
-        # controlling.
-        self._process = _InferenceStateProcess(Listener)
 
     def _get_inference_state(self, function, inference_state_id):
         from jedi.inference import InferenceState
@@ -308,6 +423,9 @@ class Listener:
         if inference_state_id is None:
             return function(*args, **kwargs)
         elif function is None:
+            # Warning: if changing the semantics of context deletion see the comment
+            # in `InferenceStateSubprocess.__init__` regarding potential race
+            # conditions.
             del self._inference_states[inference_state_id]
         else:
             inference_state = self._get_inference_state(function, inference_state_id)
@@ -348,7 +466,12 @@ class Listener:
 
 
 class AccessHandle:
-    def __init__(self, subprocess, access, id_):
+    def __init__(
+        self,
+        subprocess: _InferenceStateProcess,
+        access: DirectObjectAccess,
+        id_: int,
+    ) -> None:
         self.access = access
         self._subprocess = subprocess
         self.id = id_

jedi/inference/compiled/subprocess/__main__.py

@@ -3,10 +3,6 @@ import sys
 from importlib.abc import MetaPathFinder
 from importlib.machinery import PathFinder
 
-# Remove the first entry, because it's simply a directory entry that equals
-# this directory.
-del sys.path[0]
-
 
 def _get_paths():
     # Get the path to jedi.
@@ -21,11 +17,11 @@ class _ExactImporter(MetaPathFinder):
     def __init__(self, path_dct):
         self._path_dct = path_dct
 
-    def find_module(self, fullname, path=None):
+    def find_spec(self, fullname, path=None, target=None):
         if path is None and fullname in self._path_dct:
             p = self._path_dct[fullname]
-            loader = PathFinder.find_module(fullname, path=[p])
+            spec = PathFinder.find_spec(fullname, path=[p], target=target)
-            return loader
+            return spec
         return None
 
 

jedi/inference/compiled/subprocess/functions.py

@@ -2,7 +2,6 @@ import sys
 import os
 import inspect
 import importlib
-import warnings
 from pathlib import Path
 from zipfile import ZipFile
 from zipimport import zipimporter, ZipImportError
@@ -159,7 +158,10 @@ def _find_module(string, path=None, full_name=None, is_global_search=True):
             if loader is None and not spec.has_location:
                 # This is a namespace package.
                 full_name = string if not path else full_name
-                implicit_ns_info = ImplicitNSInfo(full_name, spec.submodule_search_locations._path)
+                implicit_ns_info = ImplicitNSInfo(
+                    full_name,
+                    spec.submodule_search_locations._path,  # type: ignore[union-attr]
+                )
                 return implicit_ns_info, True
             break
 
@@ -167,17 +169,16 @@ def _find_module(string, path=None, full_name=None, is_global_search=True):
 
 
 def _find_module_py33(string, path=None, loader=None, full_name=None, is_global_search=True):
-    loader = loader or importlib.machinery.PathFinder.find_module(string, path)
+    if not loader:
+        spec = importlib.machinery.PathFinder.find_spec(string, path)
+        if spec is not None:
+            loader = spec.loader
 
     if loader is None and path is None:  # Fallback to find builtins
         try:
-            with warnings.catch_warnings(record=True):
+            spec = importlib.util.find_spec(string)
-                # Mute "DeprecationWarning: Use importlib.util.find_spec()
+            if spec is not None:
-                # instead." While we should replace that in the future, it's
+                loader = spec.loader
-                # probably good to wait until we deprecate Python 3.3, since
-                # it was added in Python 3.4 and find_loader hasn't been
-                # removed in 3.6.
-                loader = importlib.find_loader(string)
         except ValueError as e:
             # See #491. Importlib might raise a ValueError, to avoid this, we
             # just raise an ImportError to fix the issue.

jedi/inference/compiled/value.py

@@ -51,11 +51,10 @@ class CompiledValue(Value):
     def py__call__(self, arguments):
         return_annotation = self.access_handle.get_return_annotation()
         if return_annotation is not None:
-            # TODO the return annotation may also be a string.
             return create_from_access_path(
                 self.inference_state,
                 return_annotation
-            ).execute_annotation()
+            ).execute_annotation(arguments.context)
 
         try:
             self.access_handle.getattr_paths('__call__')
@@ -163,7 +162,10 @@ class CompiledValue(Value):
     def py__simple_getitem__(self, index):
         with reraise_getitem_errors(IndexError, KeyError, TypeError):
             try:
-                access = self.access_handle.py__simple_getitem__(index)
+                access = self.access_handle.py__simple_getitem__(
+                    index,
+                    safe=not self.inference_state.allow_unsafe_executions
+                )
             except AttributeError:
                 return super().py__simple_getitem__(index)
         if access is None:
@@ -239,7 +241,7 @@ class CompiledValue(Value):
         except TypeError:
             return NO_VALUES
 
-    def execute_annotation(self):
+    def execute_annotation(self, context):
         if self.access_handle.get_repr() == 'None':
             # None as an annotation doesn't need to be executed.
             return ValueSet([self])
@@ -250,7 +252,9 @@ class CompiledValue(Value):
             for path in args
         ]
         if name == 'Union':
-            return ValueSet.from_sets(arg.execute_annotation() for arg in arguments)
+            return ValueSet.from_sets(
+                arg.execute_annotation(context)
+                for arg in arguments)
         elif name:
             # While with_generics only exists on very specific objects, we
             # should probably be fine, because we control all the typing
@@ -258,8 +262,8 @@ class CompiledValue(Value):
             return ValueSet([
                 v.with_generics(arguments)
                 for v in self.inference_state.typing_module.py__getattribute__(name)
-            ]).execute_annotation()
+            ]).execute_annotation(context)
-        return super().execute_annotation()
+        return super().execute_annotation(context)
 
     def negate(self):
         return create_from_access_path(self.inference_state, self.access_handle.negate())
@@ -311,11 +315,12 @@ class CompiledModule(CompiledValue):
 
 
 class CompiledName(AbstractNameDefinition):
-    def __init__(self, inference_state, parent_value, name):
+    def __init__(self, inference_state, parent_value, name, is_descriptor):
         self._inference_state = inference_state
         self.parent_context = parent_value.as_context()
         self._parent_value = parent_value
         self.string_name = name
+        self.is_descriptor = is_descriptor
 
     def py__doc__(self):
         return self.infer_compiled_value().py__doc__()
@@ -342,6 +347,11 @@ class CompiledName(AbstractNameDefinition):
 
     @property
     def api_type(self):
+        if self.is_descriptor:
+            # In case of properties we want to avoid executions as much as
+            # possible. Since the api_type can be wrong for other reasons
+            # anyway, we just return instance here.
+            return "instance"
         return self.infer_compiled_value().api_type
 
     def infer(self):
@@ -432,9 +442,10 @@ class CompiledValueFilter(AbstractFilter):
 
     def get(self, name):
         access_handle = self.compiled_value.access_handle
+        safe = not self._inference_state.allow_unsafe_executions
         return self._get(
             name,
-            lambda name, safe: access_handle.is_allowed_getattr(name, safe=safe),
+            lambda name: access_handle.is_allowed_getattr(name, safe=safe),
             lambda name: name in access_handle.dir(),
             check_has_attribute=True
         )
@@ -443,30 +454,34 @@ class CompiledValueFilter(AbstractFilter):
         """
         To remove quite a few access calls we introduced the callback here.
         """
-        if self._inference_state.allow_descriptor_getattr:
+        has_attribute, is_descriptor, property_return_annotation = allowed_getattr_callback(
-            pass
-
-        has_attribute, is_descriptor = allowed_getattr_callback(
             name,
-            safe=not self._inference_state.allow_descriptor_getattr
         )
+        if property_return_annotation is not None:
+            values = create_from_access_path(
+                self._inference_state,
+                property_return_annotation
+            ).execute_annotation(None)
+            if values:
+                return [CompiledValueName(v, name) for v in values]
+
         if check_has_attribute and not has_attribute:
             return []
 
         if (is_descriptor or not has_attribute) \
-                and not self._inference_state.allow_descriptor_getattr:
+                and not self._inference_state.allow_unsafe_executions:
             return [self._get_cached_name(name, is_empty=True)]
 
         if self.is_instance and not in_dir_callback(name):
             return []
-        return [self._get_cached_name(name)]
+        return [self._get_cached_name(name, is_descriptor=is_descriptor)]
 
     @memoize_method
-    def _get_cached_name(self, name, is_empty=False):
+    def _get_cached_name(self, name, is_empty=False, *, is_descriptor=False):
         if is_empty:
             return EmptyCompiledName(self._inference_state, name)
         else:
-            return self._create_name(name)
+            return self._create_name(name, is_descriptor=is_descriptor)
 
     def values(self):
         from jedi.inference.compiled import builtin_from_name
@@ -480,7 +495,7 @@ class CompiledValueFilter(AbstractFilter):
         for name in dir_infos:
             names += self._get(
                 name,
-                lambda name, safe: dir_infos[name],
+                lambda name: dir_infos[name],
                 lambda name: name in dir_infos,
             )
 
@@ -490,11 +505,12 @@ class CompiledValueFilter(AbstractFilter):
                 names += filter.values()
         return names
 
-    def _create_name(self, name):
+    def _create_name(self, name, is_descriptor):
         return CompiledName(
             self._inference_state,
             self.compiled_value,
-            name
+            name,
+            is_descriptor,
         )
 
     def __repr__(self):
@@ -578,7 +594,7 @@ def create_from_name(inference_state, compiled_value, name):
         value = create_cached_compiled_value(
             inference_state,
             access_path,
-            parent_context=None if value is None else value.as_context(),
+            parent_context=None if value is None else value.as_context(),  # type: ignore  # TODO
         )
     return value
 
@@ -596,7 +612,7 @@ def create_from_access_path(inference_state, access_path):
         value = create_cached_compiled_value(
             inference_state,
             access,
-            parent_context=None if value is None else value.as_context()
+            parent_context=None if value is None else value.as_context()  # type: ignore  # TODO
         )
     return value
 

jedi/inference/context.py

@@ -1,9 +1,8 @@
 from abc import abstractmethod
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Any
 
-from parso.tree import search_ancestor
 from parso.python.tree import Name
 
 from jedi.inference.filters import ParserTreeFilter, MergedFilter, \
@@ -17,6 +16,8 @@ from jedi import parser_utils
 
 class AbstractContext:
     # Must be defined: inference_state and tree_node and parent_context as an attribute/property
+    tree_node: Any
+    parent_context: Any
 
     def __init__(self, inference_state):
         self.inference_state = inference_state
@@ -219,6 +220,13 @@ class ValueContext(AbstractContext):
 
 
 class TreeContextMixin:
+    tree_node: Any
+    is_module: Any
+    get_value: Any
+    inference_state: Any
+    is_class: Any
+    parent_context: Any
+
     def infer_node(self, node):
         from jedi.inference.syntax_tree import infer_node
         return infer_node(self, node)
@@ -290,7 +298,7 @@ class TreeContextMixin:
     def create_name(self, tree_name):
         definition = tree_name.get_definition()
         if definition and definition.type == 'param' and definition.name == tree_name:
-            funcdef = search_ancestor(definition, 'funcdef', 'lambdef')
+            funcdef = definition.search_ancestor('funcdef', 'lambdef')
             func = self.create_value(funcdef)
             return AnonymousParamName(func, tree_name)
         else:
@@ -301,7 +309,6 @@ class TreeContextMixin:
 class FunctionContext(TreeContextMixin, ValueContext):
     def get_filters(self, until_position=None, origin_scope=None):
         yield ParserTreeFilter(
-            self.inference_state,
             parent_context=self,
             until_position=until_position,
             origin_scope=origin_scope
@@ -416,13 +423,13 @@ def _get_global_filters_for_name(context, name_or_none, position):
     # function and get inferred in the value before the function. So
     # make sure to exclude the function/class name.
     if name_or_none is not None:
-        ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef', 'lambdef')
+        ancestor = name_or_none.search_ancestor('funcdef', 'classdef', 'lambdef')
         lambdef = None
         if ancestor == 'lambdef':
             # For lambdas it's even more complicated since parts will
             # be inferred later.
             lambdef = ancestor
-            ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef')
+            ancestor = name_or_none.search_ancestor('funcdef', 'classdef')
         if ancestor is not None:
             colon = ancestor.children[-2]
             if position is not None and position < colon.start_pos:

jedi/inference/docstring_utils.py

@@ -16,6 +16,6 @@ class DocstringModuleContext(ModuleContext):
         super().__init__(module_value)
         self._in_module_context = in_module_context
 
-    def get_filters(self, origin_scope=None, until_position=None):
+    def get_filters(self, until_position=None, origin_scope=None):
         yield from super().get_filters(until_position=until_position)
         yield from self._in_module_context.get_filters()

jedi/inference/docstrings.py

@@ -48,7 +48,7 @@ def _get_numpy_doc_string_cls():
     global _numpy_doc_string_cache
     if isinstance(_numpy_doc_string_cache, (ImportError, SyntaxError)):
         raise _numpy_doc_string_cache
-    from numpydoc.docscrape import NumpyDocString  # type: ignore[import]
+    from numpydoc.docscrape import NumpyDocString  # type: ignore[import, unused-ignore]
     _numpy_doc_string_cache = NumpyDocString
     return _numpy_doc_string_cache
 
@@ -109,7 +109,7 @@ def _expand_typestr(type_str):
         yield type_str.split('of')[0]
     # Check if type has is a set of valid literal values eg: {'C', 'F', 'A'}
     elif type_str.startswith('{'):
-        node = parse(type_str, version='3.7').children[0]
+        node = parse(type_str, version='3.13').children[0]
         if node.type == 'atom':
             for leaf in getattr(node.children[1], "children", []):
                 if leaf.type == 'number':
@@ -246,7 +246,7 @@ def _execute_array_values(inference_state, array):
         cls = FakeTuple if array.array_type == 'tuple' else FakeList
         return {cls(inference_state, values)}
     else:
-        return array.execute_annotation()
+        return array.execute_annotation(None)
 
 
 @inference_state_method_cache()

jedi/inference/dynamic_params.py

@@ -66,11 +66,11 @@ def dynamic_param_lookup(function_value, param_index):
     have to look for all calls to ``func`` to find out what ``foo`` possibly
     is.
     """
-    funcdef = function_value.tree_node
+    if not function_value.inference_state.do_dynamic_params_search:
-
-    if not settings.dynamic_params:
         return NO_VALUES
 
+    funcdef = function_value.tree_node
+
     path = function_value.get_root_context().py__file__()
     if path is not None and is_stdlib_path(path):
         # We don't want to search for references in the stdlib. Usually people
@@ -109,7 +109,7 @@ def _search_function_arguments(module_context, funcdef, string_name):
     if string_name == '__init__':
         cls = get_parent_scope(funcdef)
         if cls.type == 'classdef':
-            string_name = cls.name.value
+            string_name = cls.name.value  # type: ignore[union-attr]
             compare_node = cls
 
     found_arguments = False
@@ -203,7 +203,7 @@ def _check_name_for_execution(inference_state, context, compare_node, name, trai
             # Here we're trying to find decorators by checking the first
             # parameter. It's not very generic though. Should find a better
             # solution that also applies to nested decorators.
-            param_names = value.parent_context.get_param_names()
+            param_names = value.parent_context.get_param_names()  # type: ignore[attr-defined]
             if len(param_names) != 1:
                 continue
             values = param_names[0].infer()

jedi/inference/filters.py

@@ -3,10 +3,9 @@ Filters are objects that you can use to filter names in different scopes. They
 are needed for name resolution.
 """
 from abc import abstractmethod
-from typing import List, MutableMapping, Type
+from typing import MutableMapping, Type, Any
 import weakref
 
-from parso.tree import search_ancestor
 from parso.python.tree import Name, UsedNamesMapping
 
 from jedi.inference import flow_analysis
@@ -17,8 +16,8 @@ from jedi.inference.utils import to_list
 from jedi.inference.names import TreeNameDefinition, ParamName, \
     AnonymousParamName, AbstractNameDefinition, NameWrapper
 
-_definition_name_cache: MutableMapping[UsedNamesMapping, List[Name]]
+_definition_name_cache: 'MutableMapping[UsedNamesMapping, dict[str, tuple[Name, ...]]]' \
-_definition_name_cache = weakref.WeakKeyDictionary()
+    = weakref.WeakKeyDictionary()
 
 
 class AbstractFilter:
@@ -181,7 +180,7 @@ class _FunctionExecutionFilter(ParserTreeFilter):
     @to_list
     def _convert_names(self, names):
         for name in names:
-            param = search_ancestor(name, 'param')
+            param = name.search_ancestor('param')
             # Here we don't need to check if the param is a default/annotation,
             # because those are not definitions and never make it to this
             # point.
@@ -347,6 +346,9 @@ class _OverwriteMeta(type):
 
 
 class _AttributeOverwriteMixin:
+    overwritten_methods: Any
+    _wrapped_value: Any
+
     def get_filters(self, *args, **kwargs):
         yield SpecialMethodFilter(self, self.overwritten_methods, self._wrapped_value)
         yield from self._wrapped_value.get_filters(*args, **kwargs)

jedi/inference/finder.py

@@ -15,7 +15,6 @@ Unfortunately every other thing is being ignored (e.g. a == '' would be easy to
 check for -> a is a string). There's big potential in these checks.
 """
 
-from parso.tree import search_ancestor
 from parso.python.tree import Name
 
 from jedi import settings
@@ -76,7 +75,7 @@ def check_flow_information(value, flow, search_name, pos):
         ])
 
         for name in names:
-            ass = search_ancestor(name, 'assert_stmt')
+            ass = name.search_ancestor('assert_stmt')
             if ass is not None:
                 result = _check_isinstance_type(value, ass.assertion, search_name)
                 if result is not None:

jedi/inference/gradual/annotation.py

@@ -32,17 +32,20 @@ def infer_annotation(context, annotation):
     Also checks for forward references (strings)
     """
     value_set = context.infer_node(annotation)
-    if len(value_set) != 1:
+    if len(value_set) == 0:
-        debug.warning("Inferred typing index %s should lead to 1 object, "
+        debug.warning(
-                      " not %s" % (annotation, value_set))
+            "Inferred typing index %s should lead to 1 object, not %s" % (annotation, value_set))
         return value_set
 
-    inferred_value = list(value_set)[0]
+    strings_removed = NO_VALUES
-    if is_string(inferred_value):
+    for part in value_set:
-        result = _get_forward_reference_node(context, inferred_value.get_safe_value())
+        if is_string(part):
-        if result is not None:
+            result = _get_forward_reference_node(context, part.get_safe_value())
-            return context.infer_node(result)
+            if result is not None:
-    return value_set
+                strings_removed |= context.infer_node(result)
+                continue
+        strings_removed |= ValueSet([part])
+    return strings_removed
 
 
 def _infer_annotation_string(context, string, index=None):
@@ -249,12 +252,12 @@ def infer_return_types(function, arguments):
         return _infer_annotation_string(
             context,
             match.group(1).strip()
-        ).execute_annotation()
+        ).execute_annotation(context)
 
     unknown_type_vars = find_unknown_type_vars(context, annotation)
     annotation_values = infer_annotation(context, annotation)
     if not unknown_type_vars:
-        return annotation_values.execute_annotation()
+        return annotation_values.execute_annotation(context)
 
     type_var_dict = infer_type_vars_for_execution(function, arguments, all_annotations)
 
@@ -262,7 +265,7 @@ def infer_return_types(function, arguments):
         ann.define_generics(type_var_dict)
         if isinstance(ann, (DefineGenericBaseClass, TypeVar)) else ValueSet({ann})
         for ann in annotation_values
-    ).execute_annotation()
+    ).execute_annotation(context)
 
 
 def infer_type_vars_for_execution(function, arguments, annotation_dict):
@@ -315,7 +318,7 @@ def infer_return_for_callable(arguments, param_values, result_values):
         if isinstance(v, (DefineGenericBaseClass, TypeVar))
         else ValueSet({v})
         for v in result_values
-    ).execute_annotation()
+    ).execute_annotation(arguments.context)
 
 
 def _infer_type_vars_for_callable(arguments, lazy_params):
@@ -391,7 +394,7 @@ def merge_pairwise_generics(annotation_value, annotated_argument_class):
     for annotation_generics_set, actual_generic_set in zip(annotation_generics, actual_generics):
         merge_type_var_dicts(
             type_var_dict,
-            annotation_generics_set.infer_type_vars(actual_generic_set.execute_annotation()),
+            annotation_generics_set.infer_type_vars(actual_generic_set.execute_annotation(None)),
         )
 
     return type_var_dict
@@ -402,6 +405,10 @@ def find_type_from_comment_hint_for(context, node, name):
 
 
 def find_type_from_comment_hint_with(context, node, name):
+    if len(node.children) > 4:
+        # In case there are multiple with_items, we do not want a type hint for
+        # now.
+        return []
     assert len(node.children[1].children) == 3, \
         "Can only be here when children[1] is 'foo() as f'"
     varlist = node.children[1].children[2]
@@ -434,7 +441,7 @@ def _find_type_from_comment_hint(context, node, varlist, name):
         return []
     return _infer_annotation_string(
         context, match.group(1).strip(), index
-    ).execute_annotation()
+    ).execute_annotation(context)
 
 
 def find_unknown_type_vars(context, node):

jedi/inference/gradual/base.py

@@ -195,7 +195,7 @@ class GenericClass(DefineGenericBaseClass, ClassMixin):
 
     @to_list
     def py__bases__(self):
-        for base in self._wrapped_value.py__bases__():
+        for base in self._wrapped_value.py__bases__():  # type: ignore[attr-defined]
             yield _LazyGenericBaseClass(self, base, self._generics_manager)
 
     def _create_instance_with_generics(self, generics_manager):
@@ -306,7 +306,7 @@ class _GenericInstanceWrapper(ValueWrapper):
             if cls.py__name__() == 'Generator':
                 generics = cls.get_generics()
                 try:
-                    return generics[2].execute_annotation()
+                    return generics[2].execute_annotation(None)
                 except IndexError:
                     pass
             elif cls.py__name__() == 'Iterator':
@@ -384,7 +384,7 @@ class BaseTypingValue(LazyValueWrapper):
         return _PseudoTreeNameClass(self.parent_context, self._tree_name)
 
     def get_signatures(self):
-        return self._wrapped_value.get_signatures()
+        return self._wrapped_value.get_signatures()  # type: ignore[attr-defined]
 
     def __repr__(self):
         return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)
@@ -427,7 +427,7 @@ class BaseTypingInstance(LazyValueWrapper):
         return ValueName(self, self._tree_name)
 
     def _get_wrapped_value(self):
-        object_, = builtin_from_name(self.inference_state, 'object').execute_annotation()
+        object_, = builtin_from_name(self.inference_state, 'object').execute_annotation(None)
         return object_
 
     def __repr__(self):

jedi/inference/gradual/generics.py

@@ -2,6 +2,7 @@
 This module is about generics, like the `int` in `List[int]`. It's not about
 the Generic class.
 """
+from abc import abstractmethod
 
 from jedi import debug
 from jedi.cache import memoize_method
@@ -24,9 +25,17 @@ def _resolve_forward_references(context, value_set):
 
 
 class _AbstractGenericManager:
+    @abstractmethod
+    def __getitem__(self, index):
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_tuple(self):
+        raise NotImplementedError
+
     def get_index_and_execute(self, index):
         try:
-            return self[index].execute_annotation()
+            return self[index].execute_annotation(None)
         except IndexError:
             debug.warning('No param #%s found for annotation %s', index, self)
             return NO_VALUES

jedi/inference/gradual/type_var.py

@@ -100,8 +100,8 @@ class TypeVar(BaseTypingValue):
                 return found
         return ValueSet({self})
 
-    def execute_annotation(self):
+    def execute_annotation(self, context):
-        return self._get_classes().execute_annotation()
+        return self._get_classes().execute_annotation(context)
 
     def infer_type_vars(self, value_set):
         def iterate():
@@ -123,5 +123,5 @@ class TypeWrapper(ValueWrapper):
         super().__init__(wrapped_value)
         self._original_value = original_value
 
-    def execute_annotation(self):
+    def execute_annotation(self, context):
         return ValueSet({self._original_value})

jedi/inference/gradual/typeshed.py

@@ -1,5 +1,4 @@
 import os
-import re
 from functools import wraps
 from collections import namedtuple
 from typing import Dict, Mapping, Tuple
@@ -58,19 +57,8 @@ def _create_stub_map(directory_path_info):
 
 
 def _get_typeshed_directories(version_info):
-    check_version_list = ['2and3', '3']
+    yield PathInfo(str(TYPESHED_PATH.joinpath("stdlib")), False)
-    for base in ['stdlib', 'third_party']:
+    yield PathInfo(str(TYPESHED_PATH.joinpath("stubs")), True)
-        base_path = TYPESHED_PATH.joinpath(base)
-        base_list = os.listdir(base_path)
-        for base_list_entry in base_list:
-            match = re.match(r'(\d+)\.(\d+)$', base_list_entry)
-            if match is not None:
-                if match.group(1) == '3' and int(match.group(2)) <= version_info.minor:
-                    check_version_list.append(base_list_entry)
-
-        for check_version in check_version_list:
-            is_third_party = base != 'stdlib'
-            yield PathInfo(str(base_path.joinpath(check_version)), is_third_party)
 
 
 _version_cache: Dict[Tuple[int, int], Mapping[str, PathInfo]] = {}
@@ -293,7 +281,7 @@ def parse_stub_module(inference_state, file_io):
 
 def create_stub_module(inference_state, grammar, python_value_set,
                        stub_module_node, file_io, import_names):
-    if import_names == ('typing',):
+    if import_names in [('typing',), ('typing_extensions',)]:
         module_cls = TypingModuleWrapper
     else:
         module_cls = StubModuleValue

jedi/inference/gradual/typing.py

@@ -6,6 +6,7 @@ values.
 This file deals with all the typing.py cases.
 """
 import itertools
+from typing import Any
 
 from jedi import debug
 from jedi.inference.compiled import builtin_from_name, create_simple_object
@@ -32,7 +33,8 @@ _TYPE_ALIAS_TYPES = {
     'DefaultDict': 'collections.defaultdict',
     'Deque': 'collections.deque',
 }
-_PROXY_TYPES = 'Optional Union ClassVar'.split()
+_PROXY_TYPES = ['Optional', 'Union', 'ClassVar', 'Annotated', 'Final']
+IGNORE_ANNOTATION_PARTS = ['ClassVar', 'Annotated', 'Final']
 
 
 class TypingModuleName(NameWrapper):
@@ -81,6 +83,9 @@ class TypingModuleName(NameWrapper):
         elif name == 'cast':
             cast_fn, = self._wrapped_name.infer()
             yield CastFunction.create_cached(inference_state, cast_fn)
+        elif name == 'Self':
+            yield SelfClass.create_cached(
+                inference_state, self.parent_context, self.tree_name)
         elif name == 'TypedDict':
             # TODO doesn't even exist in typeshed/typing.py, yet. But will be
             # added soon.
@@ -98,24 +103,24 @@ class TypingModuleFilterWrapper(FilterWrapper):
 
 
 class ProxyWithGenerics(BaseTypingClassWithGenerics):
-    def execute_annotation(self):
+    def execute_annotation(self, context):
         string_name = self._tree_name.value
 
         if string_name == 'Union':
             # This is kind of a special case, because we have Unions (in Jedi
             # ValueSets).
-            return self.gather_annotation_classes().execute_annotation()
+            return self.gather_annotation_classes().execute_annotation(context)
         elif string_name == 'Optional':
             # Optional is basically just saying it's either None or the actual
             # type.
-            return self.gather_annotation_classes().execute_annotation() \
+            return self.gather_annotation_classes().execute_annotation(context) \
                 | ValueSet([builtin_from_name(self.inference_state, 'None')])
         elif string_name == 'Type':
             # The type is actually already given in the index_value
             return self._generics_manager[0]
-        elif string_name == 'ClassVar':
+        elif string_name in IGNORE_ANNOTATION_PARTS:
             # For now don't do anything here, ClassVars are always used.
-            return self._generics_manager[0].execute_annotation()
+            return self._generics_manager[0].execute_annotation(context)
 
         mapped = {
             'Tuple': Tuple,
@@ -186,6 +191,8 @@ class ProxyTypingValue(BaseTypingValue):
 
 
 class _TypingClassMixin(ClassMixin):
+    _tree_name: Any
+
     def py__bases__(self):
         return [LazyKnownValues(
             self.inference_state.builtins_module.py__getattribute__('object')
@@ -213,17 +220,17 @@ class TypingClassWithGenerics(ProxyWithGenerics, _TypingClassMixin):
                 # This is basically a trick to avoid extra code: We execute the
                 # incoming classes to be able to use the normal code for type
                 # var inference.
-                value_set.execute_annotation(),
+                value_set.execute_annotation(None),
             )
 
         elif annotation_name == 'Callable':
             if len(annotation_generics) == 2:
                 return annotation_generics[1].infer_type_vars(
-                    value_set.execute_annotation(),
+                    value_set.execute_annotation(None),
                 )
 
         elif annotation_name == 'Tuple':
-            tuple_annotation, = self.execute_annotation()
+            tuple_annotation, = self.execute_annotation(None)
             return tuple_annotation.infer_type_vars(value_set)
 
         return type_var_dict
@@ -319,7 +326,7 @@ class Tuple(BaseTypingInstance):
             yield LazyKnownValues(self._generics_manager.get_index_and_execute(0))
         else:
             for v in self._generics_manager.to_tuple():
-                yield LazyKnownValues(v.execute_annotation())
+                yield LazyKnownValues(v.execute_annotation(None))
 
     def py__getitem__(self, index_value_set, contextualized_node):
         if self._is_homogenous():
@@ -327,11 +334,11 @@ class Tuple(BaseTypingInstance):
 
         return ValueSet.from_sets(
             self._generics_manager.to_tuple()
-        ).execute_annotation()
+        ).execute_annotation(None)
 
     def _get_wrapped_value(self):
         tuple_, = self.inference_state.builtins_module \
-            .py__getattribute__('tuple').execute_annotation()
+            .py__getattribute__('tuple').execute_annotation(None)
         return tuple_
 
     @property
@@ -388,11 +395,20 @@ class Protocol(BaseTypingInstance):
 
 
 class AnyClass(BaseTypingValue):
-    def execute_annotation(self):
+    def execute_annotation(self, context):
         debug.warning('Used Any - returned no results')
         return NO_VALUES
 
 
+class SelfClass(BaseTypingValue):
+    def execute_annotation(self, context):
+        debug.warning('Used Self')
+        if context is not None:
+            # Execute the class of Self
+            return context.get_value().execute_annotation(None)
+        return NO_VALUES
+
+
 class OverloadFunction(BaseTypingValue):
     @repack_with_argument_clinic('func, /')
     def py__call__(self, func_value_set):
@@ -427,7 +443,7 @@ class NewType(Value):
         return c
 
     def py__call__(self, arguments):
-        return self._type_value_set.execute_annotation()
+        return self._type_value_set.execute_annotation(arguments.context)
 
     @property
     def name(self):
@@ -441,7 +457,7 @@ class NewType(Value):
 class CastFunction(ValueWrapper):
     @repack_with_argument_clinic('type, object, /')
     def py__call__(self, type_value_set, object_value_set):
-        return type_value_set.execute_annotation()
+        return type_value_set.execute_annotation(None)
 
 
 class TypedDictClass(BaseTypingValue):

jedi/inference/gradual/utils.py

@@ -19,7 +19,7 @@ def load_proper_stub_module(inference_state, grammar, file_io, import_names, mod
         # /[...]/stdlib/3/os/__init__.pyi -> stdlib/3/os/__init__
         rest = relative_path.with_suffix('')
         # Remove the stdlib/3 or third_party/3.6 part
-        import_names = rest.parts[2:]
+        import_names = rest.parts[1:]
         if rest.name == '__init__':
             import_names = import_names[:-1]
 

jedi/inference/helpers.py

@@ -5,12 +5,12 @@ import os
 from itertools import chain
 from contextlib import contextmanager
 
-from parso.python import tree
+from parso import tree
 
 
 def is_stdlib_path(path):
     # Python standard library paths look like this:
-    # /usr/lib/python3.9/...
+    # /usr/lib/python3.14/...
     # TODO The implementation below is probably incorrect and not complete.
     parts = path.parts
     if 'dist-packages' in parts or 'site-packages' in parts:

jedi/inference/imports.py

@@ -12,7 +12,6 @@ import os
 from pathlib import Path
 
 from parso.python import tree
-from parso.tree import search_ancestor
 
 from jedi import debug
 from jedi import settings
@@ -95,7 +94,7 @@ def goto_import(context, tree_name):
 
 
 def _prepare_infer_import(module_context, tree_name):
-    import_node = search_ancestor(tree_name, 'import_name', 'import_from')
+    import_node = tree_name.search_ancestor('import_name', 'import_from')
     import_path = import_node.get_path_for_name(tree_name)
     from_import_name = None
     try:
@@ -371,16 +370,16 @@ def import_module_by_names(inference_state, import_names, sys_path=None,
         i.value if isinstance(i, tree.Name) else i
         for i in import_names
     )
-    value_set = [None]
+    base = [None]
     for i, name in enumerate(import_names):
-        value_set = ValueSet.from_sets([
+        base = value_set = ValueSet.from_sets([
             import_module(
                 inference_state,
                 str_import_names[:i+1],
                 parent_module_value,
                 sys_path,
-                prefer_stubs=prefer_stubs,
+                prefer_stubs=prefer_stubs,  # type: ignore[call-arg]
-            ) for parent_module_value in value_set
+            ) for parent_module_value in base
         ])
         if not value_set:
             message = 'No module named ' + '.'.join(str_import_names)
@@ -475,12 +474,12 @@ def _load_python_module(inference_state, file_io,
     )
 
 
-def _load_builtin_module(inference_state, import_names=None, sys_path=None):
+def _load_builtin_module(inference_state, import_names, sys_path):
     project = inference_state.project
     if sys_path is None:
         sys_path = inference_state.get_sys_path()
     if not project._load_unsafe_extensions:
-        safe_paths = project._get_base_sys_path(inference_state)
+        safe_paths = set(project._get_base_sys_path(inference_state))
         sys_path = [p for p in sys_path if p in safe_paths]
 
     dotted_name = '.'.join(import_names)
@@ -549,7 +548,7 @@ def load_namespace_from_path(inference_state, folder_io):
 
 
 def follow_error_node_imports_if_possible(context, name):
-    error_node = tree.search_ancestor(name, 'error_node')
+    error_node = name.search_ancestor('error_node')
     if error_node is not None:
         # Get the first command start of a started simple_stmt. The error
         # node is sometimes a small_stmt and sometimes a simple_stmt. Check

jedi/inference/names.py

@@ -1,11 +1,8 @@
 from abc import abstractmethod
 from inspect import Parameter
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Any
-
-from parso.tree import search_ancestor
 
 from jedi.parser_utils import find_statement_documentation, clean_scope_docstring
-from jedi.inference.utils import unite
 from jedi.inference.base_value import ValueSet, NO_VALUES
 from jedi.inference.cache import inference_state_method_cache
 from jedi.inference import docstrings
@@ -39,7 +36,6 @@ class AbstractNameDefinition:
     def infer(self):
         raise NotImplementedError
 
-    @abstractmethod
     def goto(self):
         # Typically names are already definitions and therefore a goto on that
         # name will always result on itself.
@@ -107,12 +103,15 @@ class AbstractArbitraryName(AbstractNameDefinition):
 
 
 class AbstractTreeName(AbstractNameDefinition):
+    tree_name: Any
+    parent_context: Any
+
     def __init__(self, parent_context, tree_name):
         self.parent_context = parent_context
         self.tree_name = tree_name
 
     def get_qualified_names(self, include_module_names=False):
-        import_node = search_ancestor(self.tree_name, 'import_name', 'import_from')
+        import_node = self.tree_name.search_ancestor('import_name', 'import_from')
         # For import nodes we cannot just have names, because it's very unclear
         # how they would look like. For now we just ignore them in most cases.
         # In case of level == 1, it works always, because it's like a submodule
@@ -196,24 +195,23 @@ class AbstractTreeName(AbstractNameDefinition):
                 new_dotted = deep_ast_copy(par)
                 new_dotted.children[index - 1:] = []
                 values = context.infer_node(new_dotted)
-                return unite(
+                return [
-                    value.goto(name, name_context=context)
+                    n
                     for value in values
-                )
+                    for n in value.goto(name, name_context=context)
+                ]
 
         if node_type == 'trailer' and par.children[0] == '.':
             values = infer_call_of_leaf(context, name, cut_own_trailer=True)
             return values.goto(name, name_context=context)
         else:
-            stmt = search_ancestor(
+            stmt = name.search_ancestor('expr_stmt', 'lambdef') or name
-                name, 'expr_stmt', 'lambdef'
-            ) or name
             if stmt.type == 'lambdef':
                 stmt = name
             return context.goto(name, position=stmt.start_pos)
 
     def is_import(self):
-        imp = search_ancestor(self.tree_name, 'import_from', 'import_name')
+        imp = self.tree_name.search_ancestor('import_from', 'import_name')
         return imp is not None
 
     @property
@@ -226,6 +224,9 @@ class AbstractTreeName(AbstractNameDefinition):
 
 
 class ValueNameMixin:
+    _value: Any
+    parent_context: Any
+
     def infer(self):
         return ValueSet([self._value])
 
@@ -244,7 +245,7 @@ class ValueNameMixin:
     def get_root_context(self):
         if self.parent_context is None:  # A module
             return self._value.as_context()
-        return super().get_root_context()
+        return super().get_root_context()  # type: ignore
 
     def get_defining_qualified_value(self):
         context = self.parent_context
@@ -361,14 +362,16 @@ class TreeNameDefinition(AbstractTreeName):
 
 
 class _ParamMixin:
+    get_kind: Any
+
     def maybe_positional_argument(self, include_star=True):
-        options = [Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD]
+        options: list[int] = [Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD]
         if include_star:
             options.append(Parameter.VAR_POSITIONAL)
         return self.get_kind() in options
 
     def maybe_keyword_argument(self, include_stars=True):
-        options = [Parameter.KEYWORD_ONLY, Parameter.POSITIONAL_OR_KEYWORD]
+        options: list[int] = [Parameter.KEYWORD_ONLY, Parameter.POSITIONAL_OR_KEYWORD]
         if include_stars:
             options.append(Parameter.VAR_KEYWORD)
         return self.get_kind() in options
@@ -451,7 +454,7 @@ class _ActualTreeParamName(BaseTreeParamName):
         self.function_value = function_value
 
     def _get_param_node(self):
-        return search_ancestor(self.tree_name, 'param')
+        return self.tree_name.search_ancestor('param')
 
     @property
     def annotation_node(self):
@@ -463,7 +466,7 @@ class _ActualTreeParamName(BaseTreeParamName):
             self.function_value, self._get_param_node(),
             ignore_stars=ignore_stars)
         if execute_annotation:
-            values = values.execute_annotation()
+            values = values.execute_annotation(self.function_value.get_default_param_context())
         return values
 
     def infer_default(self):
@@ -633,6 +636,10 @@ class NameWrapper:
 
 
 class StubNameMixin:
+    api_type: str
+    tree_name: Any
+    infer: Any
+
     def py__doc__(self):
         from jedi.inference.gradual.conversion import convert_names
         # Stubs are not complicated and we can just follow simple statements
@@ -644,7 +651,7 @@ class StubNameMixin:
 
         names = convert_names(names, prefer_stub_to_compiled=False)
         if self in names:
-            return super().py__doc__()
+            return super().py__doc__()  # type: ignore
         else:
             # We have signatures ourselves in stubs, so don't use signatures
             # from the implementation.

jedi/inference/signature.py

@@ -1,4 +1,5 @@
 from inspect import Parameter
+from typing import Any
 
 from jedi.cache import memoize_method
 from jedi import debug
@@ -6,6 +7,10 @@ from jedi import parser_utils
 
 
 class _SignatureMixin:
+    get_param_names: Any
+    name: Any
+    annotation_string: Any
+
     def to_string(self):
         def param_strings():
             is_positional = False
@@ -36,6 +41,8 @@ class _SignatureMixin:
 
 
 class AbstractSignature(_SignatureMixin):
+    _function_value: Any
+
     def __init__(self, value, is_bound=False):
         self.value = value
         self.is_bound = is_bound

jedi/inference/star_args.py

@@ -12,15 +12,12 @@ The signature here for bar should be `bar(b, c)` instead of bar(*args).
 """
 from inspect import Parameter
 
-from parso import tree
-
 from jedi.inference.utils import to_list
 from jedi.inference.names import ParamNameWrapper
 from jedi.inference.helpers import is_big_annoying_library
 
 
 def _iter_nodes_for_param(param_name):
-    from parso.python.tree import search_ancestor
     from jedi.inference.arguments import TreeArguments
 
     execution_context = param_name.parent_context
@@ -28,7 +25,7 @@ def _iter_nodes_for_param(param_name):
     # tree rather than going via the execution context so that we're agnostic of
     # the specific scope we're evaluating within (i.e: module or function,
     # etc.).
-    function_node = tree.search_ancestor(param_name.tree_name, 'funcdef', 'lambdef')
+    function_node = param_name.tree_name.search_ancestor('funcdef', 'lambdef')
     module_node = function_node.get_root_node()
     start = function_node.children[-1].start_pos
     end = function_node.children[-1].end_pos
@@ -38,7 +35,7 @@ def _iter_nodes_for_param(param_name):
             argument = name.parent
             if argument.type == 'argument' \
                     and argument.children[0] == '*' * param_name.star_count:
-                trailer = search_ancestor(argument, 'trailer')
+                trailer = argument.search_ancestor('trailer')
                 if trailer is not None:  # Make sure we're in a function
                     context = execution_context.create_context(trailer)
                     if _goes_to_param_name(param_name, context, name):

jedi/inference/syntax_tree.py

@@ -30,6 +30,8 @@ from jedi.inference.names import TreeNameDefinition
 from jedi.inference.context import CompForContext
 from jedi.inference.value.decorator import Decoratee
 from jedi.plugins import plugin_manager
+from jedi.inference.gradual.typing import ProxyTypingValue, IGNORE_ANNOTATION_PARTS
+from jedi.inference.gradual.type_var import TypeVar
 
 operator_to_magic_method = {
     '+': '__add__',
@@ -89,6 +91,7 @@ def infer_node(context, element):
     if isinstance(context, CompForContext):
         return _infer_node(context, element)
 
+    name_dicts = [{}]
     if_stmt = element
     while if_stmt is not None:
         if_stmt = if_stmt.parent
@@ -104,7 +107,6 @@ def infer_node(context, element):
     if predefined_if_name_dict is None and if_stmt \
             and if_stmt.type == 'if_stmt' and context.inference_state.is_analysis:
         if_stmt_test = if_stmt.children[1]
-        name_dicts = [{}]
         # If we already did a check, we don't want to do it again -> If
         # value.predefined_names is filled, we stop.
         # We don't want to check the if stmt itself, it's just about
@@ -238,7 +240,7 @@ def _infer_node(context, element):
         return context.infer_node(element.children[0])
     elif typ == 'annassign':
         return annotation.infer_annotation(context, element.children[1]) \
-            .execute_annotation()
+            .execute_annotation(context)
     elif typ == 'yield_expr':
         if len(element.children) and element.children[1].type == 'yield_arg':
             # Implies that it's a yield from.
@@ -251,6 +253,8 @@ def _infer_node(context, element):
         return NO_VALUES
     elif typ == 'namedexpr_test':
         return context.infer_node(element.children[2])
+    elif typ == 'star_expr':
+        return NO_VALUES
     else:
         return infer_or_test(context, element)
 
@@ -288,7 +292,7 @@ def infer_atom(context, atom):
     state = context.inference_state
     if atom.type == 'name':
         # This is the first global lookup.
-        stmt = tree.search_ancestor(atom, 'expr_stmt', 'lambdef', 'if_stmt') or atom
+        stmt = atom.search_ancestor('expr_stmt', 'lambdef', 'if_stmt') or atom
         if stmt.type == 'if_stmt':
             if not any(n.start_pos <= atom.start_pos < n.end_pos for n in stmt.get_test_nodes()):
                 stmt = atom
@@ -329,8 +333,8 @@ def infer_atom(context, atom):
         c = atom.children
         # Parentheses without commas are not tuples.
         if c[0] == '(' and not len(c) == 2 \
-                and not(c[1].type == 'testlist_comp'
+                and not (c[1].type == 'testlist_comp'
-                        and len(c[1].children) > 1):
+                         and len(c[1].children) > 1):
             return context.infer_node(c[1])
 
         try:
@@ -434,7 +438,7 @@ def _infer_expr_stmt(context, stmt, seek_name=None):
         else:
             operator = copy.copy(first_operator)
             operator.value = operator.value[:-1]
-            for_stmt = tree.search_ancestor(stmt, 'for_stmt')
+            for_stmt = stmt.search_ancestor('for_stmt')
             if for_stmt is not None and for_stmt.type == 'for_stmt' and value_set \
                     and parser_utils.for_stmt_defines_one_name(for_stmt):
                 # Iterate through result and add the values, that's possible
@@ -493,8 +497,10 @@ def infer_factor(value_set, operator):
         elif operator == 'not':
             b = value.py__bool__()
             if b is None:  # Uncertainty.
-                return
+                yield list(value.inference_state.builtins_module.py__getattribute__('bool')
-            yield compiled.create_simple_object(value.inference_state, not b)
+                           .execute_annotation(None)).pop()
+            else:
+                yield compiled.create_simple_object(value.inference_state, not b)
         else:
             yield value
 
@@ -525,7 +531,7 @@ def _infer_comparison(context, left_values, operator, right_values):
         result = (left_values or NO_VALUES) | (right_values or NO_VALUES)
         return _literals_to_types(state, result)
     elif operator_str == "|" and all(
-        value.is_class() or value.is_compiled()
+        value.is_class() or value.is_compiled() or isinstance(value, TypeVar)
         for value in itertools.chain(left_values, right_values)
     ):
         # ^^^ A naive hack for PEP 604
@@ -545,7 +551,7 @@ def _infer_comparison(context, left_values, operator, right_values):
 
 
 def _is_annotation_name(name):
-    ancestor = tree.search_ancestor(name, 'param', 'funcdef', 'expr_stmt')
+    ancestor = name.search_ancestor('param', 'funcdef', 'expr_stmt')
     if ancestor is None:
         return False
 
@@ -645,7 +651,9 @@ def _infer_comparison_part(inference_state, context, left, operator, right):
             _bool_to_value(inference_state, False)
         ])
     elif str_operator in ('in', 'not in'):
-        return NO_VALUES
+        return inference_state.builtins_module.py__getattribute__('bool').execute_annotation(
+            context
+        )
 
     def check(obj):
         """Checks if a Jedi object is either a float or an int."""
@@ -695,11 +703,29 @@ def tree_name_to_values(inference_state, context, tree_name):
 
             if expr_stmt.type == "expr_stmt" and expr_stmt.children[1].type == "annassign":
                 correct_scope = parser_utils.get_parent_scope(name) == context.tree_node
-                if correct_scope:
+                ann_assign = expr_stmt.children[1]
-                    found_annotation = True
+                first = ann_assign.children[1]
-                    value_set |= annotation.infer_annotation(
+                code = first.get_code()
+                if correct_scope and not (code.endswith(".TypeAlias")
+                                          or code.strip() == "TypeAlias"):
+                    if (
+                        (first.type == 'name')
+                        and (ann_assign.children[1].value == tree_name.value)
+                        and context.parent_context
+                    ):
+                        context = context.parent_context
+                    found = annotation.infer_annotation(
                         context, expr_stmt.children[1].children[1]
-                    ).execute_annotation()
+                    )
+                    set_found_annotation = True
+                    if len(found) == 1:
+                        first = next(iter(found))
+                        set_found_annotation = not (
+                            isinstance(first, ProxyTypingValue)
+                            and first.name.string_name in IGNORE_ANNOTATION_PARTS
+                        )
+                    found_annotation = set_found_annotation
+                    value_set |= found.execute_annotation(context)
         if found_annotation:
             return value_set
 
@@ -757,7 +783,7 @@ def tree_name_to_values(inference_state, context, tree_name):
             coro = enter_methods.execute_with_values()
             return coro.py__await__().py__stop_iteration_returns()
         enter_methods = value_managers.py__getattribute__('__enter__')
-        return enter_methods.execute_with_values()
+        return enter_methods.execute_annotation(context)
     elif typ in ('import_from', 'import_name'):
         types = imports.infer_import(context, tree_name)
     elif typ in ('funcdef', 'classdef'):
@@ -843,10 +869,16 @@ def check_tuple_assignments(name, value_set):
             # For no star unpacking is not possible.
             return NO_VALUES
         i = 0
+        lazy_value = None
         while i <= index:
             try:
                 lazy_value = next(iterated)
             except StopIteration:
+                # A desperate attempt to fix inference for tuples from an
+                # iterator.
+                if lazy_value is not None:
+                    return lazy_value.infer()
+
                 # We could do this with the default param in next. But this
                 # would allow this loop to run for a very long time if the
                 # index number is high. Therefore break if the loop is

jedi/inference/utils.py

@@ -74,7 +74,6 @@ class PushBackIterator:
     def __init__(self, iterator):
         self.pushes = []
         self.iterator = iterator
-        self.current = None
 
     def push_back(self, value):
         self.pushes.append(value)

jedi/inference/value/function.py

@@ -1,4 +1,4 @@
-from parso.python import tree
+from typing import Any
 
 from jedi import debug
 from jedi.inference.cache import inference_state_method_cache, CachedMetaClass
@@ -55,6 +55,10 @@ class FunctionAndClassBase(TreeValue):
 
 class FunctionMixin:
     api_type = 'function'
+    tree_node: Any
+    py__class__: Any
+    as_context: Any
+    get_signature_functions: Any
 
     def get_filters(self, origin_scope=None):
         cls = self.py__class__()
@@ -262,8 +266,8 @@ class BaseFunctionExecutionContext(ValueContext, TreeContextMixin):
     @recursion.execution_recursion_decorator(default=iter([]))
     def get_yield_lazy_values(self, is_async=False):
         # TODO: if is_async, wrap yield statements in Awaitable/async_generator_asend
-        for_parents = [(y, tree.search_ancestor(y, 'for_stmt', 'funcdef',
+        for_parents = [(y, y.search_ancestor('for_stmt', 'funcdef',
-                                                'while_stmt', 'if_stmt'))
+                                             'while_stmt', 'if_stmt'))
                        for y in get_yield_exprs(self.inference_state, self.tree_node)]
 
         # Calculate if the yields are placed within the same for loop.
@@ -334,15 +338,15 @@ class BaseFunctionExecutionContext(ValueContext, TreeContextMixin):
                 return ValueSet(
                     GenericClass(c, TupleGenericManager(generics))
                     for c in async_generator_classes
-                ).execute_annotation()
+                ).execute_annotation(None)
             else:
-                async_classes = inference_state.typing_module.py__getattribute__('Coroutine')
+                async_classes = inference_state.types_module.py__getattribute__('CoroutineType')
                 return_values = self.get_return_values()
                 # Only the first generic is relevant.
-                generics = (return_values.py__class__(), NO_VALUES, NO_VALUES)
+                generics = (NO_VALUES, NO_VALUES, return_values.py__class__())
                 return ValueSet(
                     GenericClass(c, TupleGenericManager(generics)) for c in async_classes
-                ).execute_annotation()
+                ).execute_annotation(None)
         else:
             # If there are annotations, prefer them over anything else.
             if self.is_generator() and not self.infer_annotations():

jedi/inference/value/instance.py

@@ -1,6 +1,5 @@
 from abc import abstractproperty
-
+from typing import Any
-from parso.tree import search_ancestor
 
 from jedi import debug
 from jedi import settings
@@ -18,7 +17,7 @@ from jedi.inference.arguments import ValuesArguments, TreeArgumentsWrapper
 from jedi.inference.value.function import \
     FunctionValue, FunctionMixin, OverloadedFunctionValue, \
     BaseFunctionExecutionContext, FunctionExecutionContext, FunctionNameInClass
-from jedi.inference.value.klass import ClassFilter
+from jedi.inference.value.klass import ClassFilter, init_or_new_func
 from jedi.inference.value.dynamic_arrays import get_dynamic_array_instance
 from jedi.parser_utils import function_is_staticmethod, function_is_classmethod
 
@@ -156,8 +155,9 @@ class AbstractInstanceValue(Value):
             return super().py__iter__(contextualized_node)
 
         def iterate():
-            for generator in self.execute_function_slots(iter_slot_names):
+            yield LazyKnownValues(
-                yield from generator.py__next__(contextualized_node)
+                self.execute_function_slots(iter_slot_names).py__next__(contextualized_node).infer()
+            )
         return iterate()
 
     def __repr__(self):
@@ -189,6 +189,9 @@ class CompiledInstance(AbstractInstanceValue):
 
 
 class _BaseTreeInstance(AbstractInstanceValue):
+    get_defined_names: Any
+    _arguments: Any
+
     @property
     def array_type(self):
         name = self.class_value.py__name__()
@@ -221,7 +224,7 @@ class _BaseTreeInstance(AbstractInstanceValue):
             elif isinstance(f, CompiledValueFilter):
                 yield CompiledInstanceClassFilter(self, f)
             else:
-                # Propably from the metaclass.
+                # Probably from the metaclass.
                 yield f
 
     @inference_state_method_cache()
@@ -229,7 +232,7 @@ class _BaseTreeInstance(AbstractInstanceValue):
         new = node
         while True:
             func_node = new
-            new = search_ancestor(new, 'funcdef', 'classdef')
+            new = new.search_ancestor('funcdef', 'classdef')
             if class_context.tree_node is new:
                 func = FunctionValue.from_context(class_context, func_node)
                 bound_method = BoundMethod(self, class_context, func)
@@ -324,7 +327,7 @@ class TreeInstance(_BaseTreeInstance):
             infer_type_vars_for_execution
 
         args = InstanceArguments(self, self._arguments)
-        for signature in self.class_value.py__getattribute__('__init__').get_signatures():
+        for signature in init_or_new_func(self.class_value).get_signatures():
             # Just take the first result, it should always be one, because we
             # control the typeshed code.
             funcdef = signature.value.tree_node
@@ -498,13 +501,13 @@ class SelfName(TreeNameDefinition):
         return self._instance
 
     def infer(self):
-        stmt = search_ancestor(self.tree_name, 'expr_stmt')
+        stmt = self.tree_name.search_ancestor('expr_stmt')
         if stmt is not None:
             if stmt.children[1].type == "annassign":
                 from jedi.inference.gradual.annotation import infer_annotation
                 values = infer_annotation(
                     self.parent_context, stmt.children[1].children[1]
-                ).execute_annotation()
+                ).execute_annotation(None)
                 if values:
                     return values
         return super().infer()

jedi/inference/value/iterable.py

@@ -2,6 +2,8 @@
 Contains all classes and functions to deal with lists, dicts, generators and
 iterators in general.
 """
+from typing import Any
+
 from jedi.inference import compiled
 from jedi.inference import analysis
 from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \
@@ -20,6 +22,9 @@ from jedi.inference.value.dynamic_arrays import check_array_additions
 
 
 class IterableMixin:
+    py__iter__: Any
+    inference_state: Any
+
     def py__next__(self, contextualized_node=None):
         return self.py__iter__(contextualized_node)
 
@@ -39,11 +44,11 @@ class GeneratorBase(LazyAttributeOverwrite, IterableMixin):
     array_type = None
 
     def _get_wrapped_value(self):
-        instance, = self._get_cls().execute_annotation()
+        instance, = self._get_cls().execute_annotation(None)
         return instance
 
     def _get_cls(self):
-        generator, = self.inference_state.typing_module.py__getattribute__('Generator')
+        generator, = self.inference_state.types_module.py__getattribute__('GeneratorType')
         return generator
 
     def py__bool__(self):
@@ -128,6 +133,12 @@ def comprehension_from_atom(inference_state, value, atom):
 
 
 class ComprehensionMixin:
+    _defining_context: Any
+    _entry_node: Any
+    array_type: Any
+    _value_node: Any
+    _sync_comp_for_node: Any
+
     @inference_state_method_cache()
     def _get_comp_for_context(self, parent_context, comp_for):
         return CompForContext(parent_context, comp_for)
@@ -176,6 +187,8 @@ class ComprehensionMixin:
 
 
 class _DictMixin:
+    get_mapping_item_values: Any
+
     def _get_generics(self):
         return tuple(c_set.py__class__() for c_set in self.get_mapping_item_values())
 
@@ -201,7 +214,7 @@ class Sequence(LazyAttributeOverwrite, IterableMixin):
         c, = GenericClass(
             klass,
             TupleGenericManager(self._cached_generics())
-        ).execute_annotation()
+        ).execute_annotation(None)
         return c
 
     def py__bool__(self):
@@ -220,7 +233,7 @@ class Sequence(LazyAttributeOverwrite, IterableMixin):
 class _BaseComprehension(ComprehensionMixin):
     def __init__(self, inference_state, defining_context, sync_comp_for_node, entry_node):
         assert sync_comp_for_node.type == 'sync_comp_for'
-        super().__init__(inference_state)
+        super().__init__(inference_state)  # type: ignore[call-arg]
         self._defining_context = defining_context
         self._sync_comp_for_node = sync_comp_for_node
         self._entry_node = entry_node
@@ -248,6 +261,9 @@ class GeneratorComprehension(_BaseComprehension, GeneratorBase):
 
 
 class _DictKeyMixin:
+    _dict_keys: Any
+    _dict_values: Any
+
     # TODO merge with _DictMixin?
     def get_mapping_item_values(self):
         return self._dict_keys(), self._dict_values()

jedi/inference/value/klass.py

@@ -36,6 +36,10 @@ py__doc__()                            Returns the docstring for a value.
 ====================================== ========================================
 
 """
+from __future__ import annotations
+
+from typing import List, Optional, Tuple, TYPE_CHECKING, Any
+
 from jedi import debug
 from jedi.parser_utils import get_cached_parent_scope, expr_is_dotted, \
     function_is_property
@@ -47,11 +51,18 @@ from jedi.inference.filters import ParserTreeFilter
 from jedi.inference.names import TreeNameDefinition, ValueName
 from jedi.inference.arguments import unpack_arglist, ValuesArguments
 from jedi.inference.base_value import ValueSet, iterator_to_value_set, \
-    NO_VALUES
+    NO_VALUES, ValueWrapper
 from jedi.inference.context import ClassContext
-from jedi.inference.value.function import FunctionAndClassBase
+from jedi.inference.value.function import FunctionAndClassBase, FunctionMixin
+from jedi.inference.value.decorator import Decoratee
 from jedi.inference.gradual.generics import LazyGenericManager, TupleGenericManager
 from jedi.plugins import plugin_manager
+from inspect import Parameter
+from jedi.inference.names import BaseTreeParamName
+from jedi.inference.signature import AbstractSignature
+
+if TYPE_CHECKING:
+    from jedi.inference import InferenceState
 
 
 class ClassName(TreeNameDefinition):
@@ -129,7 +140,75 @@ class ClassFilter(ParserTreeFilter):
         return [name for name in names if self._access_possible(name)]
 
 
+def init_param_value(arg_nodes) -> Optional[bool]:
+    """
+    Returns:
+
+    - ``True`` if ``@dataclass(init=True)``
+    - ``False`` if ``@dataclass(init=False)``
+    - ``None`` if not specified ``@dataclass()``
+    """
+    for arg_node in arg_nodes:
+        if (
+            arg_node.type == "argument"
+            and arg_node.children[0].value == "init"
+        ):
+            if arg_node.children[2].value == "False":
+                return False
+            elif arg_node.children[2].value == "True":
+                return True
+
+    return None
+
+
+def get_dataclass_param_names(cls) -> List[DataclassParamName]:
+    """
+    ``cls`` is a :class:`ClassMixin`. The type is only documented as mypy would
+    complain that some fields are missing.
+
+    .. code:: python
+
+        @dataclass
+        class A:
+            a: int
+            b: str = "toto"
+
+    For the previous example, the param names would be ``a`` and ``b``.
+    """
+    param_names = []
+    filter_ = cls.as_context().get_global_filter()
+    for name in sorted(filter_.values(), key=lambda name: name.start_pos):
+        d = name.tree_name.get_definition()
+        annassign = d.children[1]
+        if d.type == 'expr_stmt' and annassign.type == 'annassign':
+            node = annassign.children[1]
+            if node.type == "atom_expr" and node.children[0].value == "ClassVar":
+                continue
+
+            if len(annassign.children) < 4:
+                default = None
+            else:
+                default = annassign.children[3]
+
+            param_names.append(DataclassParamName(
+                parent_context=cls.parent_context,
+                tree_name=name.tree_name,
+                annotation_node=annassign.children[1],
+                default_node=default,
+            ))
+    return param_names
+
+
 class ClassMixin:
+    tree_node: Any
+    parent_context: Any
+    inference_state: InferenceState
+    py__bases__: Any
+    get_metaclasses: Any
+    get_metaclass_filters: Any
+    get_metaclass_signatures: Any
+    list_type_vars: Any
+
     def is_class(self):
         return True
 
@@ -206,7 +285,6 @@ class ClassMixin:
         if not is_instance and include_type_when_class:
             from jedi.inference.compiled import builtin_from_name
             type_ = builtin_from_name(self.inference_state, 'type')
-            assert isinstance(type_, ClassValue)
             if type_ != self:
                 # We are not using execute_with_values here, because the
                 # plugin function for type would get executed instead of an
@@ -221,6 +299,73 @@ class ClassMixin:
                     assert x is not None
                     yield x
 
+    def _has_dataclass_transform_metaclasses(self) -> Tuple[bool, Optional[bool]]:
+        for meta in self.get_metaclasses():  # type: ignore[attr-defined]
+            if (
+                isinstance(meta, Decoratee)
+                # Internal leakage :|
+                and isinstance(meta._wrapped_value, DataclassTransformer)
+            ):
+                return True, meta._wrapped_value.init_mode_from_new()
+
+        return False, None
+
+    def _get_dataclass_transform_signatures(self) -> List[DataclassSignature]:
+        """
+        Returns: A non-empty list if the class has dataclass semantics else an
+        empty list.
+
+        The dataclass-like semantics will be assumed for any class that directly
+        or indirectly derives from the decorated class or uses the decorated
+        class as a metaclass.
+        """
+        param_names = []
+        is_dataclass_transform = False
+        default_init_mode: Optional[bool] = None
+        for cls in reversed(list(self.py__mro__())):
+            if not is_dataclass_transform:
+
+                # If dataclass_transform is applied to a class, dataclass-like semantics
+                # will be assumed for any class that directly or indirectly derives from
+                # the decorated class or uses the decorated class as a metaclass.
+                if (
+                    isinstance(cls, DataclassTransformer)
+                    and cls.init_mode_from_init_subclass
+                ):
+                    is_dataclass_transform = True
+                    default_init_mode = cls.init_mode_from_init_subclass
+
+                elif (
+                    # Some object like CompiledValues would not be compatible
+                    isinstance(cls, ClassMixin)
+                ):
+                    is_dataclass_transform, default_init_mode = (
+                        cls._has_dataclass_transform_metaclasses()
+                    )
+
+                # Attributes on the decorated class and its base classes are not
+                # considered to be fields.
+                if is_dataclass_transform:
+                    continue
+
+            # All inherited classes behave like dataclass semantics
+            if (
+                is_dataclass_transform
+                and isinstance(cls, ClassValue)
+                and (
+                    cls.init_param_mode()
+                    or (cls.init_param_mode() is None and default_init_mode)
+                )
+            ):
+                param_names.extend(
+                    get_dataclass_param_names(cls)
+                )
+
+        if is_dataclass_transform:
+            return [DataclassSignature(cls, param_names)]
+        else:
+            return []
+
     def get_signatures(self):
         # Since calling staticmethod without a function is illegal, the Jedi
         # plugin doesn't return anything. Therefore call directly and get what
@@ -231,8 +376,14 @@ class ClassMixin:
             if sigs:
                 return sigs
         args = ValuesArguments([])
-        init_funcs = self.py__call__(args).py__getattribute__('__init__')
+        instance = self.py__call__(args)
-        return [sig.bind(self) for sig in init_funcs.get_signatures()]
+        init_funcs = init_or_new_func(instance)
+
+        dataclass_sigs = self._get_dataclass_transform_signatures()
+        if dataclass_sigs:
+            return dataclass_sigs
+        else:
+            return [sig.bind(self) for sig in init_funcs.get_signatures()]
 
     def _as_context(self):
         return ClassContext(self)
@@ -319,6 +470,175 @@ class ClassMixin:
         return ValueSet({self})
 
 
+def init_or_new_func(value):
+    init_funcs = value.py__getattribute__('__init__')
+    if len(init_funcs) == 1:
+        init = next(iter(init_funcs))
+        try:
+            class_context = init.class_context
+        except AttributeError:
+            pass
+        else:
+            # In the case where we are on object.__init__, we try to use
+            # __new__.
+            if class_context.get_root_context().is_builtins_module() \
+                    and init.class_context.name.string_name == "object":
+                return value.py__getattribute__('__new__')
+    return init_funcs
+
+
+class DataclassParamName(BaseTreeParamName):
+    """
+    Represent a field declaration on a class with dataclass semantics.
+    """
+
+    def __init__(self, parent_context, tree_name, annotation_node, default_node):
+        super().__init__(parent_context, tree_name)
+        self.annotation_node = annotation_node
+        self.default_node = default_node
+
+    def get_kind(self):
+        return Parameter.POSITIONAL_OR_KEYWORD
+
+    def infer(self):
+        if self.annotation_node is None:
+            return NO_VALUES
+        else:
+            return self.parent_context.infer_node(self.annotation_node)
+
+
+class DataclassSignature(AbstractSignature):
+    """
+    It represents the ``__init__`` signature of a class with dataclass semantics.
+
+    .. code:: python
+
+    """
+    def __init__(self, value, param_names):
+        super().__init__(value)
+        self._param_names = param_names
+
+    def get_param_names(self, resolve_stars=False):
+        return self._param_names
+
+
+class DataclassDecorator(ValueWrapper, FunctionMixin):
+    """
+    A dataclass(-like) decorator with custom parameters.
+
+    .. code:: python
+
+        @dataclass(init=True) # this
+        class A: ...
+
+        @dataclass_transform
+        def create_model(*, init=False): pass
+
+        @create_model(init=False) # or this
+        class B: ...
+    """
+
+    def __init__(self, function, arguments, default_init: bool = True):
+        """
+        Args:
+            function: Decoratee | function
+            arguments: The parameters to the dataclass function decorator
+            default_init: Boolean to indicate the default init value
+        """
+        super().__init__(function)
+        argument_init = self._init_param_value(arguments)
+        self.init_param_mode = (
+            argument_init if argument_init is not None else default_init
+        )
+
+    def _init_param_value(self, arguments) -> Optional[bool]:
+        if not arguments.argument_node:
+            return None
+
+        arg_nodes = (
+            arguments.argument_node.children
+            if arguments.argument_node.type == "arglist"
+            else [arguments.argument_node]
+        )
+
+        return init_param_value(arg_nodes)
+
+
+class DataclassTransformer(ValueWrapper, ClassMixin):
+    """
+    A class decorated with the ``dataclass_transform`` decorator. dataclass-like
+    semantics will be assumed for any class that directly or indirectly derives
+    from the decorated class or uses the decorated class as a metaclass.
+    Attributes on the decorated class and its base classes are not considered to
+    be fields.
+    """
+    def __init__(self, wrapped_value):
+        super().__init__(wrapped_value)
+
+    def init_mode_from_new(self) -> bool:
+        """Default value if missing is ``True``"""
+        new_methods = self._wrapped_value.py__getattribute__("__new__")
+
+        if not new_methods:
+            return True
+
+        new_method = list(new_methods)[0]
+
+        for param in new_method.get_param_names():
+            if (
+                param.string_name == "init"
+                and param.default_node
+                and param.default_node.type == "keyword"
+            ):
+                if param.default_node.value == "False":
+                    return False
+                elif param.default_node.value == "True":
+                    return True
+
+        return True
+
+    @property
+    def init_mode_from_init_subclass(self) -> Optional[bool]:
+        # def __init_subclass__(cls) -> None: ... is hardcoded in the typeshed
+        # so the extra parameters can not be inferred.
+        return True
+
+
+class DataclassWrapper(ValueWrapper, ClassMixin):
+    """
+    A class with dataclass semantics from a decorator. The init parameters are
+    only from the current class and parent classes decorated where the ``init``
+    parameter was ``True``.
+
+    .. code:: python
+
+        @dataclass
+        class A: ... # this
+
+        @dataclass_transform
+        def create_model(): pass
+
+        @create_model()
+        class B: ... # or this
+    """
+
+    def __init__(
+        self, wrapped_value, should_generate_init: bool
+    ):
+        super().__init__(wrapped_value)
+        self.should_generate_init = should_generate_init
+
+    def get_signatures(self):
+        param_names = []
+        for cls in reversed(list(self.py__mro__())):
+            if (
+                isinstance(cls, DataclassWrapper)
+                and cls.should_generate_init
+            ):
+                param_names.extend(get_dataclass_param_names(cls))
+        return [DataclassSignature(cls, param_names)]
+
+
 class ClassValue(ClassMixin, FunctionAndClassBase, metaclass=CachedMetaClass):
     api_type = 'class'
 
@@ -385,6 +705,22 @@ class ClassValue(ClassMixin, FunctionAndClassBase, metaclass=CachedMetaClass):
                         return values
         return NO_VALUES
 
+    def init_param_mode(self) -> Optional[bool]:
+        """
+        It returns ``True`` if ``class X(init=False):`` else ``False``.
+        """
+        bases_arguments = self._get_bases_arguments()
+
+        if bases_arguments is None:
+            return None
+
+        if bases_arguments.argument_node.type != "arglist":
+            # If it is not inheriting from the base model and having
+            # extra parameters, then init behavior is not changed.
+            return None
+
+        return init_param_value(bases_arguments.argument_node.children)
+
     @plugin_manager.decorate()
     def get_metaclass_signatures(self, metaclasses):
         return []

jedi/inference/value/module.py

@@ -1,6 +1,6 @@
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Optional, TYPE_CHECKING, Any
 
 from jedi.inference.cache import inference_state_method_cache
 from jedi.inference.names import AbstractNameDefinition, ModuleName
@@ -13,6 +13,9 @@ from jedi.inference.compiled import create_simple_object
 from jedi.inference.base_value import ValueSet
 from jedi.inference.context import ModuleContext
 
+if TYPE_CHECKING:
+    from jedi.inference import InferenceState
+
 
 class _ModuleAttributeName(AbstractNameDefinition):
     """
@@ -35,6 +38,11 @@ class _ModuleAttributeName(AbstractNameDefinition):
 
 
 class SubModuleDictMixin:
+    inference_state: "InferenceState"
+    is_package: Any
+    py__path__: Any
+    as_context: Any
+
     @inference_state_method_cache()
     def sub_modules_dict(self):
         """
@@ -57,6 +65,10 @@ class SubModuleDictMixin:
 
 class ModuleMixin(SubModuleDictMixin):
     _module_name_class = ModuleName
+    tree_node: Any
+    string_names: Any
+    sub_modules_dict: Any
+    py__file__: Any
 
     def get_filters(self, origin_scope=None):
         yield MergedFilter(
@@ -80,7 +92,7 @@ class ModuleMixin(SubModuleDictMixin):
     def is_stub(self):
         return False
 
-    @property  # type: ignore[misc]
+    @property
     @inference_state_method_cache()
     def name(self):
         return self._module_name_class(self, self.string_names[-1])
@@ -138,7 +150,7 @@ class ModuleValue(ModuleMixin, TreeValue):
     api_type = 'module'
 
     def __init__(self, inference_state, module_node, code_lines, file_io=None,
-                 string_names=None, is_package=False):
+                 string_names=None, is_package=False) -> None:
         super().__init__(
             inference_state,
             parent_context=None,
@@ -149,7 +161,7 @@ class ModuleValue(ModuleMixin, TreeValue):
             self._path: Optional[Path] = None
         else:
             self._path = file_io.path
-        self.string_names = string_names  # Optional[Tuple[str, ...]]
+        self.string_names: Optional[tuple[str, ...]] = string_names
         self.code_lines = code_lines
         self._is_package = is_package
 

jedi/inference/value/namespace.py

@@ -38,7 +38,7 @@ class ImplicitNamespaceValue(Value, SubModuleDictMixin):
     def get_qualified_names(self):
         return ()
 
-    @property  # type: ignore[misc]
+    @property
     @inference_state_method_cache()
     def name(self):
         string_name = self.py__package__()[-1]

jedi/parser_utils.py

@@ -259,7 +259,7 @@ def get_parent_scope(node, include_flows=False):
             # the if, but the parent of the if.
             if not (scope.type == 'if_stmt'
                     and any(n.start_pos <= node.start_pos < n.end_pos
-                            for n in scope.get_test_nodes())):
+                            for n in scope.get_test_nodes())):  # type: ignore[attr-defined]
                 return scope
 
         scope = scope.parent
@@ -320,7 +320,7 @@ def expr_is_dotted(node):
     return node.type == 'name'
 
 
-def _function_is_x_method(*method_names):
+def _function_is_x_method(decorator_checker):
     def wrapper(function_node):
         """
         This is a heuristic. It will not hold ALL the times, but it will be
@@ -330,12 +330,16 @@ def _function_is_x_method(*method_names):
         """
         for decorator in function_node.get_decorators():
             dotted_name = decorator.children[1]
-            if dotted_name.get_code() in method_names:
+            if decorator_checker(dotted_name.get_code()):
                 return True
         return False
     return wrapper
 
 
-function_is_staticmethod = _function_is_x_method('staticmethod')
+function_is_staticmethod = _function_is_x_method(lambda m: m == "staticmethod")
-function_is_classmethod = _function_is_x_method('classmethod')
+function_is_classmethod = _function_is_x_method(lambda m: m == "classmethod")
-function_is_property = _function_is_x_method('property', 'cached_property')
+function_is_property = _function_is_x_method(
+    lambda m: m == "property"
+    or m == "cached_property"
+    or (m.endswith(".setter"))
+)

jedi/plugins/django.py

@@ -2,6 +2,7 @@
 Module is used to infer Django model fields.
 """
 from inspect import Parameter
+from typing import Any
 
 from jedi import debug
 from jedi.inference.cache import inference_state_function_cache
@@ -45,7 +46,7 @@ _FILTER_LIKE_METHODS = ('create', 'filter', 'exclude', 'update', 'get',
 def _get_deferred_attributes(inference_state):
     return inference_state.import_module(
         ('django', 'db', 'models', 'query_utils')
-    ).py__getattribute__('DeferredAttribute').execute_annotation()
+    ).py__getattribute__('DeferredAttribute').execute_annotation(None)
 
 
 def _infer_scalar_field(inference_state, field_name, field_tree_instance, is_instance):
@@ -129,7 +130,7 @@ def _create_manager_for(cls, manager_cls='BaseManager'):
     for m in managers:
         if m.is_class_mixin():
             generics_manager = TupleGenericManager((ValueSet([cls]),))
-            for c in GenericClass(m, generics_manager).execute_annotation():
+            for c in GenericClass(m, generics_manager).execute_annotation(None):
                 return c
     return None
 
@@ -140,7 +141,7 @@ def _new_dict_filter(cls, is_instance):
         include_metaclasses=False,
         include_type_when_class=False)
     )
-    dct = {
+    dct: dict[str, Any] = {
         name.string_name: DjangoModelName(cls, name, is_instance)
         for filter_ in reversed(filters)
         for name in filter_.values()

jedi/plugins/pytest.py

@@ -1,6 +1,7 @@
+import sys
+from typing import List
 from pathlib import Path
 
-from parso.tree import search_ancestor
 from jedi.inference.cache import inference_state_method_cache
 from jedi.inference.imports import goto_import, load_module_from_path
 from jedi.inference.filters import ParserTreeFilter
@@ -36,7 +37,7 @@ def infer_anonymous_param(func):
                    == ('typing', 'Generator')
                    for v in result):
                 return ValueSet.from_sets(
-                    v.py__getattribute__('__next__').execute_annotation()
+                    v.py__getattribute__('__next__').execute_annotation(None)
                     for v in result
                 )
             return result
@@ -118,7 +119,7 @@ def _is_a_pytest_param_and_inherited(param_name):
 
     This is a heuristic and will work in most cases.
     """
-    funcdef = search_ancestor(param_name.tree_name, 'funcdef')
+    funcdef = param_name.tree_name.search_ancestor('funcdef')
     if funcdef is None:  # A lambda
         return False, False
     decorators = funcdef.get_decorators()
@@ -131,15 +132,20 @@ def _is_pytest_func(func_name, decorator_nodes):
         or any('fixture' in n.get_code() for n in decorator_nodes)
 
 
-def _find_pytest_plugin_modules():
+def _find_pytest_plugin_modules() -> List[List[str]]:
     """
     Finds pytest plugin modules hooked by setuptools entry points
 
     See https://docs.pytest.org/en/stable/how-to/writing_plugins.html#setuptools-entry-points
     """
-    from pkg_resources import iter_entry_points
+    from importlib.metadata import entry_points
 
-    return [ep.module_name.split(".") for ep in iter_entry_points(group="pytest11")]
+    if sys.version_info >= (3, 10):
+        pytest_entry_points = entry_points(group="pytest11")
+    else:
+        pytest_entry_points = entry_points().get("pytest11", ())
+
+    return [ep.module.split(".") for ep in pytest_entry_points]
 
 
 @inference_state_method_cache()
@@ -160,13 +166,19 @@ def _iter_pytest_modules(module_context, skip_own_module=False):
             if Path(file_io.path) != module_context.py__file__():
                 try:
                     m = load_module_from_path(module_context.inference_state, file_io)
-                    yield m.as_context()
+                    conftest_module = m.as_context()
+                    yield conftest_module
+
+                    plugins_list = m.tree_node.get_used_names().get("pytest_plugins")
+                    if plugins_list:
+                        name = conftest_module.create_name(plugins_list[0])
+                        yield from _load_pytest_plugins(module_context, name)
                 except FileNotFoundError:
                     pass
             folder = folder.get_parent_folder()
 
             # prevent an infinite for loop if the same parent folder is return twice
-            if last_folder is not None and folder.path == last_folder.path:
+            if last_folder is not None and folder.path == last_folder.path:  # type: ignore  # TODO
                 break
             last_folder = folder  # keep track of the last found parent name
 
@@ -175,6 +187,19 @@ def _iter_pytest_modules(module_context, skip_own_module=False):
             yield module_value.as_context()
 
 
+def _load_pytest_plugins(module_context, name):
+    from jedi.inference.helpers import get_str_or_none
+
+    for inferred in name.infer():
+        for seq_value in inferred.py__iter__():
+            for value in seq_value.infer():
+                fq_name = get_str_or_none(value)
+                if fq_name:
+                    names = fq_name.split(".")
+                    for module_value in module_context.inference_state.import_module(names):
+                        yield module_value.as_context()
+
+
 class FixtureFilter(ParserTreeFilter):
     def _filter(self, names):
         for name in super()._filter(names):

jedi/plugins/stdlib.py

@@ -11,7 +11,6 @@ compiled module that returns the types for C-builtins.
 """
 import parso
 import os
-from inspect import Parameter
 
 from jedi import debug
 from jedi.inference.utils import safe_property
@@ -25,15 +24,20 @@ from jedi.inference.value.instance import \
 from jedi.inference.base_value import ContextualizedNode, \
     NO_VALUES, ValueSet, ValueWrapper, LazyValueWrapper
 from jedi.inference.value import ClassValue, ModuleValue
-from jedi.inference.value.klass import ClassMixin
+from jedi.inference.value.decorator import Decoratee
+from jedi.inference.value.klass import (
+    DataclassWrapper,
+    DataclassDecorator,
+    DataclassTransformer,
+)
 from jedi.inference.value.function import FunctionMixin
 from jedi.inference.value import iterable
 from jedi.inference.lazy_value import LazyTreeValue, LazyKnownValue, \
     LazyKnownValues
-from jedi.inference.names import ValueName, BaseTreeParamName
+from jedi.inference.names import ValueName
 from jedi.inference.filters import AttributeOverwrite, publish_method, \
     ParserTreeFilter, DictFilter
-from jedi.inference.signature import AbstractSignature, SignatureWrapper
+from jedi.inference.signature import SignatureWrapper
 
 
 # Copied from Python 3.6's stdlib.
@@ -130,7 +134,7 @@ def execute(callback):
             except KeyError:
                 pass
             else:
-                return func(value, arguments=arguments, callback=call)
+                return func(value, arguments=arguments, callback=call)  # type: ignore
         return call()
 
     return wrapper
@@ -591,63 +595,101 @@ def _random_choice(sequences):
 
 
 def _dataclass(value, arguments, callback):
+    """
+    Decorator entry points for dataclass.
+
+    1. dataclass decorator declaration with parameters
+    2. dataclass semantics on a class from a dataclass(-like) decorator
+    """
     for c in _follow_param(value.inference_state, arguments, 0):
         if c.is_class():
-            return ValueSet([DataclassWrapper(c)])
+            # Declare dataclass semantics on a class from a dataclass decorator
+            should_generate_init = (
+                # Customized decorator, init may be disabled
+                value.init_param_mode
+                if isinstance(value, DataclassDecorator)
+                # Bare dataclass decorator, always with init mode
+                else True
+            )
+            return ValueSet([DataclassWrapper(c, should_generate_init)])
         else:
-            return ValueSet([value])
+            # @dataclass(init=False)
+            # dataclass decorator customization
+            return ValueSet(
+                [
+                    DataclassDecorator(
+                        value,
+                        arguments=arguments,
+                        default_init=True,
+                    )
+                ]
+            )
+
     return NO_VALUES
 
 
-class DataclassWrapper(ValueWrapper, ClassMixin):
+def _dataclass_transform(value, arguments, callback):
-    def get_signatures(self):
+    """
-        param_names = []
+    Decorator entry points for dataclass_transform.
-        for cls in reversed(list(self.py__mro__())):
-            if isinstance(cls, DataclassWrapper):
-                filter_ = cls.as_context().get_global_filter()
-                # .values ordering is not guaranteed, at least not in
-                # Python < 3.6, when dicts where not ordered, which is an
-                # implementation detail anyway.
-                for name in sorted(filter_.values(), key=lambda name: name.start_pos):
-                    d = name.tree_name.get_definition()
-                    annassign = d.children[1]
-                    if d.type == 'expr_stmt' and annassign.type == 'annassign':
-                        if len(annassign.children) < 4:
-                            default = None
-                        else:
-                            default = annassign.children[3]
-                        param_names.append(DataclassParamName(
-                            parent_context=cls.parent_context,
-                            tree_name=name.tree_name,
-                            annotation_node=annassign.children[1],
-                            default_node=default,
-                        ))
-        return [DataclassSignature(cls, param_names)]
 
+    1. dataclass-like decorator instantiation from a dataclass_transform decorator
+    2. dataclass_transform decorator declaration with parameters
+    3. dataclass-like decorator declaration with parameters
+    4. dataclass-like semantics on a class from a dataclass-like decorator
+    """
+    for c in _follow_param(value.inference_state, arguments, 0):
+        if c.is_class():
+            is_dataclass_transform = (
+                value.name.string_name == "dataclass_transform"
+                # The decorator function from dataclass_transform acting as the
+                # dataclass decorator.
+                and not isinstance(value, Decoratee)
+                # The decorator function from dataclass_transform acting as the
+                # dataclass decorator with customized parameters
+                and not isinstance(value, DataclassDecorator)
+            )
 
-class DataclassSignature(AbstractSignature):
+            if is_dataclass_transform:
-    def __init__(self, value, param_names):
+                # Declare base class
-        super().__init__(value)
+                return ValueSet([DataclassTransformer(c)])
-        self._param_names = param_names
+            else:
-
+                # Declare dataclass-like semantics on a class from a
-    def get_param_names(self, resolve_stars=False):
+                # dataclass-like decorator
-        return self._param_names
+                should_generate_init = value.init_param_mode
-
+                return ValueSet([DataclassWrapper(c, should_generate_init)])
-
+        elif c.is_function():
-class DataclassParamName(BaseTreeParamName):
+            # dataclass-like decorator instantiation:
-    def __init__(self, parent_context, tree_name, annotation_node, default_node):
+            # @dataclass_transform
-        super().__init__(parent_context, tree_name)
+            # def create_model()
-        self.annotation_node = annotation_node
+            return ValueSet(
-        self.default_node = default_node
+                [
-
+                    DataclassDecorator(
-    def get_kind(self):
+                        value,
-        return Parameter.POSITIONAL_OR_KEYWORD
+                        arguments=arguments,
-
+                        default_init=True,
-    def infer(self):
+                    )
-        if self.annotation_node is None:
+                ]
-            return NO_VALUES
+            )
+        elif (
+            # @dataclass_transform
+            # def create_model(): pass
+            # @create_model(init=...)
+            isinstance(value, Decoratee)
+        ):
+            # dataclass (or like) decorator customization
+            return ValueSet(
+                [
+                    DataclassDecorator(
+                        value,
+                        arguments=arguments,
+                        default_init=value._wrapped_value.init_param_mode,
+                    )
+                ]
+            )
         else:
-            return self.parent_context.infer_node(self.annotation_node)
+            # dataclass_transform decorator with parameters; nothing impactful
+            return ValueSet([value])
+    return NO_VALUES
 
 
 class ItemGetterCallable(ValueWrapper):
@@ -747,6 +789,13 @@ def _os_path_join(args_set, callback):
     return callback()
 
 
+_path_overrides = {
+    'dirname': _create_string_input_function(os.path.dirname),
+    'abspath': _create_string_input_function(os.path.abspath),
+    'relpath': _create_string_input_function(os.path.relpath),
+    'join': _os_path_join,
+}
+
 _implemented = {
     'builtins': {
         'getattr': builtins_getattr,
@@ -798,26 +847,19 @@ _implemented = {
         # runtime_checkable doesn't really change anything and is just
         # adding logs for infering stuff, so we can safely ignore it.
         'runtime_checkable': lambda value, arguments, callback: NO_VALUES,
+        # Python 3.11+
+        'dataclass_transform': _dataclass_transform,
+    },
+    'typing_extensions': {
+        # Python <3.11
+        'dataclass_transform': _dataclass_transform,
     },
     'dataclasses': {
         # For now this works at least better than Jedi trying to understand it.
         'dataclass': _dataclass
     },
-    # attrs exposes declaration interface roughly compatible with dataclasses
+    'posixpath': _path_overrides,
-    # via attrs.define, attrs.frozen and attrs.mutable
+    'ntpath': _path_overrides,
-    # https://www.attrs.org/en/stable/names.html
-    'attr': {
-        'define': _dataclass,
-    },
-    'attrs': {
-        'define': _dataclass,
-    },
-    'os.path': {
-        'dirname': _create_string_input_function(os.path.dirname),
-        'abspath': _create_string_input_function(os.path.abspath),
-        'relpath': _create_string_input_function(os.path.relpath),
-        'join': _os_path_join,
-    }
 }
 
 
@@ -867,11 +909,38 @@ class EnumInstance(LazyValueWrapper):
             yield f
 
 
+# Make sure tuple[...] behaves like Tuple[...]
+class TupleClassWrapper(ValueWrapper):
+    def py__getitem__(self, index_value_set, contextualized_node):
+        return self.inference_state.typing_tuple().py__getitem__(
+            index_value_set,
+            contextualized_node,
+        )
+
+
+# Make sure type[...] behaves like Type[...]
+class TypeClassWrapper(ValueWrapper):
+    def py__getitem__(self, index_value_set, contextualized_node):
+        return self.inference_state.typing_type().py__getitem__(
+            index_value_set,
+            contextualized_node,
+        )
+
+
 def tree_name_to_values(func):
     def wrapper(inference_state, context, tree_name):
-        if tree_name.value == 'sep' and context.is_module() and context.py__name__() == 'os.path':
+        if tree_name.value == 'sep' \
+                and context.is_module() and context.py__name__() in ('posixpath', 'ntpath'):
             return ValueSet({
                 compiled.create_simple_object(inference_state, os.path.sep),
             })
+        if tree_name.value == 'tuple' \
+                and context.is_module() and context.py__name__() == 'builtins':
+            tup, = func(inference_state, context, tree_name)
+            return ValueSet([TupleClassWrapper(tup)])
+        if tree_name.value == 'type' \
+                and context.is_module() and context.py__name__() == 'builtins':
+            tup, = func(inference_state, context, tree_name)
+            return ValueSet([TypeClassWrapper(tup)])
         return func(inference_state, context, tree_name)
     return wrapper

jedi/settings.py

@@ -143,6 +143,15 @@ This improves autocompletion for libraries that use ``setattr`` or
 ``globals()`` modifications a lot.
 """
 
+allow_unsafe_interpreter_executions = True
+"""
+Controls whether descriptors are evaluated when using an Interpreter. This is
+something you might want to control when using Jedi from a Repl (e.g. IPython)
+
+Generally this setting allows Jedi to execute __getitem__ and descriptors like
+`property`.
+"""
+
 # ----------------
 # Caching Validity
 # ----------------

jedi/utils.py

@@ -2,7 +2,7 @@
 Utilities for end-users.
 """
 
-import __main__  # type: ignore[import]
+import __main__
 from collections import namedtuple
 import logging
 import traceback

pyproject.toml

@@ -0,0 +1,14 @@
+[tool.zuban]
+strict = true
+enable_error_code = ["ignore-without-code"]
+
+# Revert some --strict specific flags:
+allow_untyped_calls = true
+allow_untyped_defs = true
+allow_incomplete_defs = true
+allow_untyped_globals = true
+untyped_strict_optional = false
+implicit_reexport = true
+
+# Exclude our copies of external stubs
+exclude = "^jedi/third_party|^test/(completion|refactor|static_analysis|examples)/"

scripts/diff_parser_profile.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python
-"""
-Profile a piece of Python code with ``cProfile`` that uses the diff parser.
-
-Usage:
-  profile.py <file> [-d] [-s <sort>]
-  profile.py -h | --help
-
-Options:
-  -h --help     Show this screen.
-  -d --debug    Enable Jedi internal debugging.
-  -s <sort>     Sort the profile results, e.g. cumtime, name [default: time].
-"""
-
-import cProfile
-
-from docopt import docopt
-from jedi.parser.python import load_grammar
-from jedi.parser.diff import DiffParser
-from jedi.parser.python import ParserWithRecovery
-from jedi.common import splitlines
-import jedi
-
-
-def run(parser, lines):
-    diff_parser = DiffParser(parser)
-    diff_parser.update(lines)
-    # Make sure used_names is loaded
-    parser.module.used_names
-
-
-def main(args):
-    if args['--debug']:
-        jedi.set_debug_function(notices=True)
-
-    with open(args['<file>']) as f:
-        code = f.read()
-    grammar = load_grammar()
-    parser = ParserWithRecovery(grammar, code)
-    # Make sure used_names is loaded
-    parser.module.used_names
-
-    code = code + '\na\n'  # Add something so the diff parser needs to run.
-    lines = splitlines(code, keepends=True)
-    cProfile.runctx('run(parser, lines)', globals(), locals(), sort=args['-s'])
-
-
-if __name__ == '__main__':
-    args = docopt(__doc__)
-    main(args)

scripts/memory_check.py

@@ -13,7 +13,7 @@ Note: This requires the psutil library, available on PyPI.
 import time
 import sys
 import os
-import psutil
+import psutil  # type: ignore[import-untyped]
 sys.path.insert(0, os.path.abspath(os.path.dirname(__file__) + '/..'))
 import jedi
 

scripts/profile_output.py

@@ -56,7 +56,7 @@ def main(args):
         run(code, i, infer=infer)
 
     if args['--precision']:
-        pstats.f8 = f8
+        pstats.f8 = f8  # type: ignore[attr-defined]  # TODO this does not seem to exist?!
 
     jedi.set_debug_function(notices=args['--debug'])
     if args['--omit']:

scripts/wx_check.py

@@ -17,11 +17,11 @@ import sys
 try:
     import urllib.request as urllib2
 except ImportError:
-    import urllib2
+    import urllib2  # type: ignore[import-not-found, no-redef]
 import gc
 from os.path import abspath, dirname
 
-import objgraph
+import objgraph  # type: ignore[import-untyped]
 
 sys.path.insert(0, dirname(dirname(abspath(__file__))))
 import jedi

setup.cfg

@@ -21,34 +21,13 @@ per-file-ignores =
   jedi/__init__.py:F401
   jedi/inference/compiled/__init__.py:F401
   jedi/inference/value/__init__.py:F401
-exclude = jedi/third_party/* .tox/*
+exclude =
+  .tox/*
+  jedi/third_party/*
+  test/completion/*
+  test/examples/*
+  test/refactor/*
+  test/static_analysis/*
 
 [pycodestyle]
 max-line-length = 100
-
-
-[mypy]
-# Ensure generics are explicit about what they are (e.g: `List[str]` rather than
-# just `List`)
-disallow_any_generics = True
-
-disallow_subclassing_any = True
-
-# Avoid creating future gotchas emerging from bad typing
-warn_redundant_casts = True
-warn_unused_ignores = True
-warn_return_any = True
-warn_unused_configs = True
-
-warn_unreachable = True
-
-# Require values to be explicitly re-exported; this makes things easier for
-# Flake8 too and avoids accidentally importing thing from the "wrong" place
-# (which helps avoid circular imports)
-implicit_reexport = False
-
-strict_equality = True
-
-[mypy-jedi,jedi.inference.compiled,jedi.inference.value,parso]
-# Various __init__.py files which contain re-exports we want to implicitly make.
-implicit_reexport = True

setup.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+from typing import cast
 
 from setuptools import setup, find_packages
 from setuptools.depends import get_module_constant
@@ -9,7 +10,7 @@ __AUTHOR__ = 'David Halter'
 __AUTHOR_EMAIL__ = 'davidhalter88@gmail.com'
 
 # Get the version from within jedi. It's defined in exactly one place now.
-version = get_module_constant("jedi", "__version__")
+version = cast(str, get_module_constant("jedi", "__version__"))
 
 readme = open('README.rst').read() + '\n\n' + open('CHANGELOG.rst').read()
 
@@ -27,53 +28,61 @@ setup(name='jedi',
       maintainer=__AUTHOR__,
       maintainer_email=__AUTHOR_EMAIL__,
       url='https://github.com/davidhalter/jedi',
+      project_urls={
+          "Documentation": 'https://jedi.readthedocs.io/en/latest/',
+      },
       license='MIT',
       keywords='python completion refactoring vim',
       long_description=readme,
       packages=find_packages(exclude=['test', 'test.*']),
-      python_requires='>=3.6',
+      python_requires='>=3.10',
-      install_requires=['parso>=0.8.0,<0.9.0'],
+      # Python 3.13 grammars are added to parso in 0.8.4
+      install_requires=['parso>=0.8.6,<0.9.0'],
       extras_require={
-          'testing': [
+          'dev': [
-              'pytest<7.0.0',
+              'pytest<9.0.0',
               # docopt for sith doctests
               'docopt',
               # coloroma for colored debug output
               'colorama',
-              'Django<3.1',  # For now pin this.
+              'Django',
               'attrs',
-          ],
+              'typing_extensions',
-          'qa': [
+              # latest version on 2025-06-16
-              'flake8==3.8.3',
+              'flake8==7.1.2',
-              'mypy==0.782',
+              'zuban==0.7.0',
+              # Arbitrary pins, latest at the time of pinning
+              'types-setuptools==80.9.0.20250529',
           ],
           'docs': [
               # Just pin all of these.
-              'Jinja2==2.11.3',
+              'alabaster==1.0.0',
-              'MarkupSafe==1.1.1',
+              'babel==2.18.0',
-              'Pygments==2.8.1',
+              'certifi==2026.4.22',
-              'alabaster==0.7.12',
+              'charset-normalizer==3.4.7',
-              'babel==2.9.1',
+              'docutils==0.22.4',
-              'chardet==4.0.0',
+              'idna==3.13',
-              'commonmark==0.8.1',
+              'imagesize==2.0.0',
-              'docutils==0.17.1',
+              'iniconfig==2.3.0',
-              'future==0.18.2',
+              'Jinja2==3.1.6',
-              'idna==2.10',
+              'MarkupSafe==3.0.3',
-              'imagesize==1.2.0',
+              'packaging==26.2',
-              'mock==1.0.1',
+              'pluggy==1.6.0',
-              'packaging==20.9',
+              'Pygments==2.20.0',
-              'pyparsing==2.4.7',
+              'pytest==9.0.3',
-              'pytz==2021.1',
+              'requests==2.33.1',
-              'readthedocs-sphinx-ext==2.1.4',
+              'roman-numerals==4.1.0',
-              'recommonmark==0.5.0',
+              'snowballstemmer==3.0.1',
-              'requests==2.25.1',
+              'Sphinx==9.1.0',
-              'six==1.15.0',
+              'sphinx_rtd_theme==3.1.0',
-              'snowballstemmer==2.1.0',
+              'sphinxcontrib-applehelp==2.0.0',
-              'sphinx==1.8.5',
+              'sphinxcontrib-devhelp==2.0.0',
-              'sphinx-rtd-theme==0.4.3',
+              'sphinxcontrib-htmlhelp==2.1.0',
-              'sphinxcontrib-serializinghtml==1.1.4',
+              'sphinxcontrib-jquery==4.1',
-              'sphinxcontrib-websupport==1.2.4',
+              'sphinxcontrib-jsmath==1.0.1',
-              'urllib3==1.26.4',
+              'sphinxcontrib-qthelp==2.0.0',
+              'sphinxcontrib-serializinghtml==2.0.0',
+              'urllib3==2.6.3',
           ],
       },
       package_data={'jedi': ['*.pyi', 'third_party/typeshed/LICENSE',
@@ -86,11 +95,11 @@ setup(name='jedi',
           'License :: OSI Approved :: MIT License',
           'Operating System :: OS Independent',
           'Programming Language :: Python :: 3',
-          'Programming Language :: Python :: 3.6',
-          'Programming Language :: Python :: 3.7',
-          'Programming Language :: Python :: 3.8',
-          'Programming Language :: Python :: 3.9',
           'Programming Language :: Python :: 3.10',
+          'Programming Language :: Python :: 3.11',
+          'Programming Language :: Python :: 3.12',
+          'Programming Language :: Python :: 3.13',
+          'Programming Language :: Python :: 3.14',
           'Topic :: Software Development :: Libraries :: Python Modules',
           'Topic :: Text Editors :: Integrated Development Environments (IDE)',
           'Topic :: Utilities',

sith.py

@@ -35,7 +35,6 @@ Usage:
 Options:
   -h --help             Show this screen.
   --record=<file>       Exceptions are recorded in here [default: record.json].
-  -f, --fs-cache        By default, file system cache is off for reproducibility.
   -n, --maxtries=<nr>   Maximum of random tries [default: 100]
   -d, --debug           Jedi print debugging when an error is raised.
   -s                    Shows the path/line numbers of every completion before it starts.
@@ -44,7 +43,7 @@ Options:
   --pudb                Launch pudb when error is raised.
 """
 
-from docopt import docopt  # type: ignore[import]
+from docopt import docopt  # type: ignore[import, unused-ignore]
 
 import json
 import os
@@ -187,7 +186,6 @@ def main(arguments):
                'pudb' if arguments['--pudb'] else None
     record = arguments['--record']
 
-    jedi.settings.use_filesystem_cache = arguments['--fs-cache']
     if arguments['--debug']:
         jedi.set_debug_function()
 

test/completion/arrays.py

@@ -207,16 +207,16 @@ C().a
 (f, g) = (1,)
 #? int()
 f
-#? []
+#? int()
-g.
+g
 
 (f, g, h) = (1,'')
 #? int()
 f
 #? str()
 g
-#? []
+#? str()
-h.
+h
 
 (f1, g1) = 1
 #? []
@@ -311,9 +311,13 @@ for x in {1: 3.0, '': 1j}:
 dict().values().__iter__
 
 d = dict(a=3, b='')
-x, = d.values()
+x, y, z = d.values()
 #? int() str()
 x
+#? int() str()
+y
+#? int() str()
+z
 #? int()
 d['a']
 #? int() str() None
@@ -527,3 +531,11 @@ lc = [x for a, *x in [(1, '', 1.0)]]
 lc[0][0]
 #?
 lc[0][1]
+
+
+xy = (1,)
+x, y = *xy, None
+
+# whatever it is should not crash
+#?
+x

test/completion/basic.py

@@ -232,13 +232,14 @@ def a():
 #?
 # str literals in comment """ upper
 
+# python >= 3.11
 def completion_in_comment():
-    #? ['Exception']
+    #? ['Exception', 'ExceptionGroup']
     # might fail because the comment is not a leaf: Exception
     pass
 
 some_word
-#? ['Exception']
+#? ['Exception', 'ExceptionGroup']
 # Very simple comment completion: Exception
 # Commment after it
 
@@ -388,7 +389,8 @@ with open('') as f:
     #? ['closed']
     f.closed
     for line in f:
-        #? str() bytes()
+        # TODO this is wrong
+        #? bytes()
         line
 
 with open('') as f1, open('') as f2:
@@ -413,6 +415,10 @@ with Foo() as f3:
 with Foo() as f3:
     f3
 
+with open("a"), open("b") as bfile:
+    #? ['flush']
+   bfile.flush
+
 # -----------------
 # Avoiding multiple definitions
 # -----------------
@@ -420,3 +426,13 @@ with Foo() as f3:
 some_array = ['', '']
 #! ['def upper']
 some_array[some_not_defined_index].upper
+
+# -----------------
+# operator
+# -----------------
+
+#? bool()
+res = 'f' in 'foo'; res
+
+#? bool()
+res = not {}; res

test/completion/completion.py

@@ -31,14 +31,15 @@ if x:
 #? ['else']
 else
 
+# python >= 3.11
 try:
     pass
-#? ['except', 'Exception']
+#? ['except', 'Exception', 'ExceptionGroup']
 except
 
 try:
     pass
-#? 6 ['except', 'Exception']
+#? 6 ['except', 'Exception', 'ExceptionGroup']
 except AttributeError:
     pass
 #? ['finally']

test/completion/conftest.py

@@ -27,3 +27,9 @@ def capsysbinary(capsysbinary):
     #? ['close']
     capsysbinary.clos
     return capsysbinary
+
+
+# used when fixtures are defined in multiple files
+pytest_plugins = [
+    "completion.fixture_module",
+]

test/completion/context.py

@@ -21,11 +21,9 @@ class Y(X):
     #? []
     def __doc__
 
-    # This might or might not be what we wanted, currently properties are also
-    # used like this. IMO this is not wanted ~dave.
-    #? ['__class__']
-    def __class__
     #? []
+    def __class__
+    #? ['__class__']
     __class__
 
 

test/completion/fixture_module.py

@@ -0,0 +1,6 @@
+# Exists only for completion/pytest.py
+import pytest
+
+@pytest.fixture
+def my_module_fixture():
+    return 1.0

test/completion/fstring.py

@@ -1,3 +1,4 @@
+# python >= 3.11
 class Foo:
     bar = 1
 
@@ -13,7 +14,7 @@ Fr'{Foo.bar'
 Fr'{Foo.bar
 #? ['bar']
 Fr'{Foo.bar
-#? ['Exception']
+#? ['Exception', 'ExceptionGroup']
 F"{Excepti
 
 #? 8 Foo

test/completion/keywords.py

@@ -2,7 +2,8 @@
 #? ['raise']
 raise
 
-#? ['Exception']
+# python >= 3.11
+#? ['Exception', 'ExceptionGroup']
 except
 
 #? []

test/completion/named_expression.py

@@ -1,7 +1,6 @@
 # For assignment expressions / named expressions / walrus operators / whatever
 # they are called.
 
-# python >= 3.8
 b = (a:=1, a)
 
 #? int()

test/completion/named_param.py

@@ -108,33 +108,35 @@ def z(bam, bar=2, *, bas=1):
 #? 7 ['bar=', 'baz=']
 x(1, ba)
 
+# python >= 3.11
+
 #? 14 ['baz=']
 x(1, bar=2, ba)
 #? 7 ['bar=', 'baz=']
 x(1, ba, baz=3)
 #? 14 ['baz=']
 x(1, bar=2, baz=3)
-#? 7 ['BaseException']
+#? 7 ['BaseException', 'BaseExceptionGroup']
 x(basee)
 #? 22 ['bar=', 'baz=']
 x(1, 2, 3, 4, 5, 6, bar=2)
 
 #? 14 ['baz=']
 y(1, bar=2, ba)
-#? 7 ['bar=', 'BaseException', 'baz=']
+#? 7 ['bar=', 'BaseException', 'BaseExceptionGroup', 'baz=']
 y(1, ba, baz=3)
 #? 14 ['baz=']
 y(1, bar=2, baz=3)
-#? 7 ['BaseException']
+#? 7 ['BaseException', 'BaseExceptionGroup']
 y(basee)
-#? 22 ['bar=', 'BaseException', 'baz=']
+#? 22 ['bar=', 'BaseException', 'BaseExceptionGroup', 'baz=']
 y(1, 2, 3, 4, 5, 6, bar=2)
 
 #? 11 ['bar=', 'bas=']
 z(bam=1, bar=2, bas=3)
-#? 8 ['BaseException', 'bas=']
+#? 8 ['BaseException', 'BaseExceptionGroup', 'bas=']
 z(1, bas=2)
-#? 12 ['BaseException']
+#? 12 ['BaseException', 'BaseExceptionGroup']
 z(1, bas=bas)
 
 #? 19 ['dict']

test/completion/on_import.py

@@ -76,7 +76,7 @@ from import_tree.pkg.mod1 import not_existant,
 #? 22 ['mod1', 'base']
 from import_tree.pkg. import mod1
 #? 17 ['mod1', 'mod2', 'random', 'pkg', 'references', 'rename1', 'rename2', 'classes', 'globals', 'recurse_class1', 'recurse_class2', 'invisible_pkg', 'flow_import']
-from import_tree. import pkg
+from import_tree. import new_pkg
 
 #? 18 ['pkg']
 from import_tree.p import pkg

test/completion/pep0484_basic.py

@@ -180,6 +180,11 @@ def argskwargs(*args: int, **kwargs: float):
     #? float()
     kwargs['']
 
+class Test:
+    str: str = 'abc'
+
+#? ['upper']
+Test.str.upp
 
 class NotCalledClass:
     def __init__(self, x):
@@ -198,3 +203,38 @@ class NotCalledClass:
         self.w: float
         #? float()
         self.w
+
+def tuple_func() -> tuple[int, str]:
+    return 1, ""
+
+x = tuple_func()
+a, b = x
+#? int()
+a
+#? str()
+b
+#? int()
+x[0]
+#? str()
+x[1]
+
+def check_newstyle_unions(u1: int | str, u2: list[int] | list[str]):
+    #? int() str()
+    u1
+    #? list()
+    u2
+    #? int() str()
+    u2[1]
+
+def use_type_with_annotation() -> type[int]: ...
+
+#? int
+use_type_with_annotation()
+
+def union_with_forward_references(x: int | "str", y: "int" | str, z: "int | str"):
+    #? int() str()
+    x
+    #? int() str()
+    y
+    #? int() str()
+    z

test/completion/pep0484_generic_parameters.py

@@ -11,6 +11,7 @@ from typing import (
     TypeVar,
     Union,
     Sequence,
+    Self,
 )
 
 K = TypeVar('K')
@@ -387,3 +388,19 @@ first(custom_partial2_unbound_instance)
 
 #? str()
 values(custom_partial2_unbound_instance)[0]
+
+def generic_func1(arg: T) -> int | str | T: pass
+def generic_func2(arg: T) -> Union[int, str, T]: pass
+
+#? int() str() bytes()
+generic_func1(b"hello")
+#? int() str() bytes()
+generic_func2(b"hello")
+
+class CustomGeneric2(Generic[T_co]):
+    val: T_co
+    def __init__(cls, val: T_co) -> Self:
+        raise NotImplementedError
+
+#? int()
+CustomGeneric2(1).val

test/completion/pep0484_typing.py

@@ -3,7 +3,7 @@ Test the typing library, with docstrings and annotations
 """
 import typing
 from typing import Sequence, MutableSequence, List, Iterable, Iterator, \
-    AbstractSet, Tuple, Mapping, Dict, Union, Optional
+    AbstractSet, Tuple, Mapping, Dict, Union, Optional, Final, Self
 
 class B:
     pass
@@ -49,11 +49,7 @@ def iterators(ps: Iterable[int], qs: Iterator[str], rs:
     a, b = ps
     #? int()
     a
-    ##? int()  --- TODO fix support for tuple assignment
+    #? int()
-    # https://github.com/davidhalter/jedi/pull/663#issuecomment-172317854
-    # test below is just to make sure that in case it gets fixed by accident
-    # these tests will be fixed as well the way they should be
-    #?
     b
 
     for q in qs:
@@ -76,7 +72,7 @@ def sets(p: AbstractSet[int], q: typing.MutableSet[float]):
     #? ["add"]
     q.a
 
-def tuple(p: Tuple[int], q: Tuple[int, str, float], r: Tuple[B, ...]):
+def tupletest(p: Tuple[int], q: Tuple[int, str, float], r: Tuple[B, ...]):
     #? int()
     p[0]
     #? ['index']
@@ -476,8 +472,6 @@ dynamic_annotation('')
 # TypeDict
 # -------------------------
 
-# python >= 3.8
-
 class Foo(typing.TypedDict):
     foo: str
     bar: typing.List[float]
@@ -557,3 +551,57 @@ def typed_dict_test_foo(arg: Bar):
     arg['an_int']
     #? int()
     arg['another_variable']
+
+# -----------------
+# Self
+# -----------------
+
+import typing_extensions
+
+# From #2023, #2068
+class Builder:
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+
+    def add_x(self: Self, x: int) -> Self:
+        self.x = x
+        return self
+
+    def add_y(self: Self, y: int) -> Self:
+        self.y = y
+        return self
+
+    def add_not_implemented(self: Self, y: int) -> Self:
+        raise NotImplementedError
+
+    def add_not_implemented_typing_extensions(self: Self, y: int) -> typing_extensions.Self:
+        raise NotImplementedError
+
+b = Builder()
+#? Builder()
+b.add_x(2)
+#? Builder()
+b.add_x(2).add_y(5)
+# python >= 3.11
+#? Builder()
+b.add_x(2).add_not_implemented(5)
+#? Builder()
+b.add_x(2).add_not_implemented_typing_extensions(5)
+
+# -----------------
+# TypeAlias (see also #1969)
+# -----------------
+
+from typing import TypeAlias
+
+IntX: typing.TypeAlias = int
+IntY: TypeAlias = int
+
+#? int
+IntX
+def f(x: IntX, y: IntY):
+    #? int()
+    x
+    #? int()
+    y

test/completion/pep0526_variables.py

@@ -59,6 +59,7 @@ class VarClass:
     var_class1: typing.ClassVar[str] = 1
     var_class2: typing.ClassVar[bytes]
     var_class3 = None
+    var_class4: typing.ClassVar = ""
 
     def __init__(self):
         #? int()
@@ -71,7 +72,7 @@ class VarClass:
         d.var_class2
         #? []
         d.int
-        #? ['var_class1', 'var_class2', 'var_instance1', 'var_instance2', 'var_class3']
+        #? ['var_class1', 'var_class2', 'var_instance1', 'var_instance2', 'var_class3', 'var_class4']
         self.var_
 
 class VarClass2(VarClass):
@@ -81,7 +82,7 @@ class VarClass2(VarClass):
         #? int()
         self.var_class3
 
-#? ['var_class1', 'var_class2', 'var_instance1', 'var_class3', 'var_instance2']
+#? ['var_class1', 'var_class2', 'var_class4', 'var_instance1', 'var_class3', 'var_instance2']
 VarClass.var_
 #? int()
 VarClass.var_instance1
@@ -91,11 +92,13 @@ VarClass.var_instance2
 VarClass.var_class1
 #? bytes()
 VarClass.var_class2
+#? str()
+VarClass.var_class4
 #? []
 VarClass.int
 
 d = VarClass()
-#? ['var_class1', 'var_class2', 'var_class3', 'var_instance1', 'var_instance2']
+#? ['var_class1', 'var_class2', 'var_class3', 'var_class4', 'var_instance1', 'var_instance2']
 d.var_
 #? int()
 d.var_instance1
@@ -105,6 +108,8 @@ d.var_instance2
 d.var_class1
 #? bytes()
 d.var_class2
+#? str()
+d.var_class4
 #? []
 d.int
 
@@ -117,3 +122,39 @@ class DC:
 
 #? int()
 DC().name
+
+# -------------------------
+# Final
+# -------------------------
+
+# TODO this is wrong, but shouldn't matter that much
+#? 0 int()
+x: typing.Final[str] = 1
+#? 0 int()
+y: typing.Final = 1
+#? str()
+x
+#? int()
+y
+
+def f(x: typing.Final[str]):
+    #? str()
+    x
+
+class C:
+    x: typing.Final[bytes] = 1
+    #? 4 str()
+    y: typing.Final = ""
+    #? bytes()
+    x
+    #? str()
+    y
+
+#? bytes()
+C.x
+#? str()
+C.y
+#? bytes()
+C().x
+#? str()
+C().y

test/completion/pep0593_annotations.py

@@ -0,0 +1,24 @@
+from typing import Annotated
+
+# This is just a dummy and very meaningless thing to use with to the Annotated
+# type hint
+class Foo:
+    pass
+
+class A:
+    pass
+
+
+def annotated_function_params(
+    basic: Annotated[str, Foo()],
+    obj: A,
+    annotated_obj: Annotated[A, Foo()],
+):
+    #? str()
+    basic
+
+    #? A()
+    obj
+
+    #? A()
+    annotated_obj

test/completion/pep0695_type_parameter_syntax.py

@@ -0,0 +1,14 @@
+# python >= 3.12
+
+# -----------------
+# new generic syntax should not fail
+# -----------------
+
+class C[T]:
+    def c(self) -> str: ...
+def f[T](x: T, y: T) -> int: ...
+
+#? int()
+f()
+#? str()
+C().c()

test/completion/positional_only_params.py

@@ -1,5 +1,3 @@
-# python >= 3.8
-
 def positional_only_call(a, /, b):
     #? str()
     a

test/completion/precedence.py

@@ -54,7 +54,7 @@ a
 
 #? int()
 (3 ** 3)
-#? int()
+#? int() float()
 (3 ** 'a')
 #? int()
 (3 + 'a')
@@ -167,7 +167,7 @@ from datetime import datetime, timedelta
 (datetime - timedelta)
 #? datetime()
 (datetime() - timedelta())
-#? timedelta()
+#? timedelta() datetime()
 (datetime() - datetime())
 #? timedelta()
 (timedelta() - datetime())

test/completion/pytest.py

@@ -96,6 +96,9 @@ def test_x(my_con
 #? 18 ['my_conftest_fixture']
 def test_x(my_conftest_fixture):
     return
+#? ['my_module_fixture']
+def test_x(my_modu
+    return
 
 #? []
 def lala(my_con