Merge 8f3292a4d6 into e53359ad88

* Sort completions by input resemblance.

Fixes #2017

* Clean code

.coveragerc

@@ -1,13 +1,13 @@
 [run]
 omit =
     jedi/_compatibility.py
-    jedi/evaluate/compiled/subprocess/__main__.py
+    jedi/inference/compiled/subprocess/__main__.py
     jedi/__main__.py
     # For now this is not being used.
-    jedi/refactoring.py
 
 [report]
 # Regexes for lines to exclude from consideration
 exclude_lines =
     # Don't complain about missing debug-only code:
     def __repr__
+    debug.warning

.editorconfig

@@ -0,0 +1,14 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.py]
+indent_size = 4
+
+[*.md]
+indent_size = 2

.gitattributes

@@ -0,0 +1,10 @@
+# all end-of-lines are normalized to LF when written to the repository
+# https://git-scm.com/docs/gitattributes#_text
+* text=auto
+
+# force all text files on the working dir to have LF line endings
+# https://git-scm.com/docs/gitattributes#_eol
+* text eol=lf
+
+# PNGs are not text and should not be normalized
+*.png -text

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [davidhalter]

.github/workflows/ci.yml

@@ -0,0 +1,75 @@
+name: ci
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  tests:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-20.04, windows-2019]
+        python-version: ["3.13", "3.12", "3.11", "3.10", "3.9", "3.8", "3.7", "3.6"]
+        environment: ['3.8', '3.13', '3.12', '3.11', '3.10', '3.9', '3.7', '3.6', 'interpreter']
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - uses: actions/setup-python@v5
+        if: ${{ matrix.environment != 'interpreter' }}
+        with:
+          python-version: ${{ matrix.environment }}
+          allow-prereleases: true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+
+      - name: Install dependencies
+        run: 'pip install .[testing]'
+
+      - name: Run tests
+        run: python -m pytest
+        env:
+          JEDI_TEST_ENVIRONMENT: ${{ matrix.environment }}
+
+  code-quality:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install dependencies
+        run: 'pip install .[qa]'
+
+      - name: Run tests
+        run: |
+          python -m flake8 jedi test setup.py
+          python -m mypy jedi sith.py setup.py
+
+  coverage:
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install dependencies
+        run: 'pip install .[testing] coverage'
+
+      - name: Run tests
+        run: |
+          python -m coverage run --source jedi -m pytest
+          python -m coverage report
+
+      - name: Upload coverage data
+        run: |
+          pip install --quiet codecov coveralls
+          python -m coverage xml
+          python -m coverage report -m
+          bash <(curl -s https://codecov.io/bash) -X gcov -X coveragepy -X search -X fix -X xcode -f coverage.xml

.gitignore

@@ -2,7 +2,6 @@
 *.sw?
 *.pyc
 .ropeproject
-.tox
 .coveralls.yml
 .coverage
 .idea
@@ -13,3 +12,6 @@ jedi.egg-info/
 record.json
 /.cache/
 /.pytest_cache
+/.mypy_cache
+/venv/
+.nvimrc

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "jedi/third_party/typeshed"]
 	path = jedi/third_party/typeshed
 	url = https://github.com/davidhalter/typeshed.git
+[submodule "jedi/third_party/django-stubs"]
+	path = jedi/third_party/django-stubs
+	url = https://github.com/davidhalter/django-stubs

.readthedocs.yml

@@ -0,0 +1,16 @@
+version: 2
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs
+
+submodules:
+  include: all
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"

.travis.yml

@@ -1,68 +0,0 @@
-dist: xenial
-language: python
-python:
-  - 2.7
-  - 3.4
-  - 3.5
-  - 3.6
-  - 3.7
-
-env:
-  - JEDI_TEST_ENVIRONMENT=27
-  - JEDI_TEST_ENVIRONMENT=34
-  - JEDI_TEST_ENVIRONMENT=35
-  - JEDI_TEST_ENVIRONMENT=36
-  - JEDI_TEST_ENVIRONMENT=37
-
-matrix:
-  include:
-    - python: 3.6
-      env:
-        - TOXENV=cov
-        - JEDI_TEST_ENVIRONMENT=36
-    # For now ignore pypy, there are so many issues that we don't really need
-    # to run it.
-    #- python: pypy
-    - python: 3.8-dev
-      env:
-        - JEDI_TEST_ENVIRONMENT=38
-install:
-    - pip install --quiet tox-travis
-script:
-    - |
-      # Setup/install Python for $JEDI_TEST_ENVIRONMENT.
-      set -ex
-      test_env_version=${JEDI_TEST_ENVIRONMENT:0:1}.${JEDI_TEST_ENVIRONMENT:1:1}
-      if [ "$TRAVIS_PYTHON_VERSION" != "$test_env_version" ]; then
-        python_bin=python$test_env_version
-        python_path="$(which $python_bin || true)"
-        if [ -z "$python_path" ]; then
-          # Only required for JEDI_TEST_ENVIRONMENT=34.
-          download_name=python-$test_env_version
-          wget https://s3.amazonaws.com/travis-python-archives/binaries/ubuntu/16.04/x86_64/$download_name.tar.bz2
-          sudo tar xjf $download_name.tar.bz2 --directory / opt/python
-          ln -s "/opt/python/${test_env_version}/bin/python" /home/travis/bin/$python_bin
-        elif [ "${python_path#/opt/pyenv/shims}" != "$python_path" ]; then
-          # Activate pyenv version (required with JEDI_TEST_ENVIRONMENT=36).
-          pyenv_bin="$(pyenv whence --path "$python_bin" | head -n1)"
-          ln -s "$pyenv_bin" /home/travis/bin/$python_bin
-        fi
-        $python_bin --version
-        python_ver=$($python_bin -c 'import sys; print("%d%d" % sys.version_info[0:2])')
-        if [ "$JEDI_TEST_ENVIRONMENT" != "$python_ver" ]; then
-          echo "Unexpected Python version for $JEDI_TEST_ENVIRONMENT: $python_ver"
-          set +ex
-          exit 2
-        fi
-      fi
-      set +ex
-    - tox
-after_script:
-    - |
-      if [ $TOXENV == "cov" ]; then
-        pip install --quiet codecov coveralls
-        coverage xml
-        coverage report -m
-        coveralls
-        bash <(curl -s https://codecov.io/bash) -X gcov -X coveragepy -X search -X fix -X xcode -f coverage.xml
-      fi

AUTHORS.txt

@@ -1,57 +1,72 @@
-Main Authors
-============
+Main Authors
+------------
 
-David Halter (@davidhalter) <davidhalter88@gmail.com>
-Takafumi Arakaki (@tkf) <aka.tkf@gmail.com>
+- David Halter (@davidhalter) <davidhalter88@gmail.com>
+- Takafumi Arakaki (@tkf) <aka.tkf@gmail.com>
 
 Code Contributors
-=================
+-----------------
 
-Danilo Bargen (@dbrgn) <mail@dbrgn.ch>
-Laurens Van Houtven (@lvh) <_@lvh.cc>
-Aldo Stracquadanio (@Astrac) <aldo.strac@gmail.com>
-Jean-Louis Fuchs (@ganwell) <ganwell@fangorn.ch>
-tek (@tek)
-Yasha Borevich (@jjay) <j.borevich@gmail.com>
-Aaron Griffin <aaronmgriffin@gmail.com>
-andviro (@andviro)
-Mike Gilbert (@floppym) <floppym@gentoo.org>
-Aaron Meurer (@asmeurer) <asmeurer@gmail.com>
-Lubos Trilety <ltrilety@redhat.com>
-Akinori Hattori (@hattya) <hattya@gmail.com>
-srusskih (@srusskih)
-Steven Silvester (@blink1073)
-Colin Duquesnoy (@ColinDuquesnoy) <colin.duquesnoy@gmail.com>
-Jorgen Schaefer (@jorgenschaefer) <contact@jorgenschaefer.de>
-Fredrik Bergroth (@fbergroth)
-Mathias Fußenegger (@mfussenegger)
-Syohei Yoshida (@syohex) <syohex@gmail.com>
-ppalucky (@ppalucky)
-immerrr (@immerrr) immerrr@gmail.com
-Albertas Agejevas (@alga)
-Savor d'Isavano (@KenetJervet) <newelevenken@163.com>
-Phillip Berndt (@phillipberndt) <phillip.berndt@gmail.com>
-Ian Lee (@IanLee1521) <IanLee1521@gmail.com>
-Farkhad Khatamov (@hatamov) <comsgn@gmail.com>
-Kevin Kelley (@kelleyk) <kelleyk@kelleyk.net>
-Sid Shanker (@squidarth) <sid.p.shanker@gmail.com>
-Reinoud Elhorst (@reinhrst)
-Guido van Rossum (@gvanrossum) <guido@python.org>
-Dmytro Sadovnychyi (@sadovnychyi) <jedi@dmit.ro>
-Cristi Burcă (@scribu)
-bstaint (@bstaint)
-Mathias Rav (@Mortal) <rav@cs.au.dk>
-Daniel Fiterman (@dfit99) <fitermandaniel2@gmail.com>
-Simon Ruggier (@sruggier)
-Élie Gouzien (@ElieGouzien)
-Robin Roth (@robinro)
-Malte Plath (@langsamer)
-Anton Zub (@zabulazza)
-Maksim Novikov (@m-novikov) <mnovikov.work@gmail.com>
-Tobias Rzepka (@TobiasRzepka)
-micbou (@micbou)
-Dima Gerasimov (@karlicoss) <karlicoss@gmail.com>
-Max Woerner Chase (@mwchase) <max.chase@gmail.com>
-Johannes Maria Frank (@jmfrank63) <jmfrank63@gmail.com>
+- Danilo Bargen (@dbrgn) <mail@dbrgn.ch>
+- Laurens Van Houtven (@lvh) <_@lvh.cc>
+- Aldo Stracquadanio (@Astrac) <aldo.strac@gmail.com>
+- Jean-Louis Fuchs (@ganwell) <ganwell@fangorn.ch>
+- tek (@tek)
+- Yasha Borevich (@jjay) <j.borevich@gmail.com>
+- Aaron Griffin <aaronmgriffin@gmail.com>
+- andviro (@andviro)
+- Mike Gilbert (@floppym) <floppym@gentoo.org>
+- Aaron Meurer (@asmeurer) <asmeurer@gmail.com>
+- Lubos Trilety <ltrilety@redhat.com>
+- Akinori Hattori (@hattya) <hattya@gmail.com>
+- srusskih (@srusskih)
+- Steven Silvester (@blink1073)
+- Colin Duquesnoy (@ColinDuquesnoy) <colin.duquesnoy@gmail.com>
+- Jorgen Schaefer (@jorgenschaefer) <contact@jorgenschaefer.de>
+- Fredrik Bergroth (@fbergroth)
+- Mathias Fußenegger (@mfussenegger)
+- Syohei Yoshida (@syohex) <syohex@gmail.com>
+- ppalucky (@ppalucky)
+- immerrr (@immerrr) immerrr@gmail.com
+- Albertas Agejevas (@alga)
+- Savor d'Isavano (@KenetJervet) <newelevenken@163.com>
+- Phillip Berndt (@phillipberndt) <phillip.berndt@gmail.com>
+- Ian Lee (@IanLee1521) <IanLee1521@gmail.com>
+- Farkhad Khatamov (@hatamov) <comsgn@gmail.com>
+- Kevin Kelley (@kelleyk) <kelleyk@kelleyk.net>
+- Sid Shanker (@squidarth) <sid.p.shanker@gmail.com>
+- Reinoud Elhorst (@reinhrst)
+- Guido van Rossum (@gvanrossum) <guido@python.org>
+- Dmytro Sadovnychyi (@sadovnychyi) <jedi@dmit.ro>
+- Cristi Burcă (@scribu)
+- bstaint (@bstaint)
+- Mathias Rav (@Mortal) <rav@cs.au.dk>
+- Daniel Fiterman (@dfit99) <fitermandaniel2@gmail.com>
+- Simon Ruggier (@sruggier)
+- Élie Gouzien (@ElieGouzien)
+- Robin Roth (@robinro)
+- Malte Plath (@langsamer)
+- Anton Zub (@zabulazza)
+- Maksim Novikov (@m-novikov) <mnovikov.work@gmail.com>
+- Tobias Rzepka (@TobiasRzepka)
+- micbou (@micbou)
+- Dima Gerasimov (@karlicoss) <karlicoss@gmail.com>
+- Max Woerner Chase (@mwchase) <max.chase@gmail.com>
+- Johannes Maria Frank (@jmfrank63) <jmfrank63@gmail.com>
+- Shane Steinert-Threlkeld (@shanest) <ssshanest@gmail.com>
+- Tim Gates (@timgates42) <tim.gates@iress.com>
+- Lior Goldberg (@goldberglior)
+- Ryan Clary (@mrclary)
+- Max Mäusezahl (@mmaeusezahl) <maxmaeusezahl@googlemail.com>
+- Vladislav Serebrennikov (@endilll)
+- Andrii Kolomoiets (@muffinmad)
+- 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.
 
 Note: (@user) means a github user name.

CHANGELOG.rst

@@ -3,6 +3,154 @@
 Changelog
 ---------
 
+Unreleased
+++++++++++
+
+- 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)
++++++++++++++++++++
+
+- Added dataclass-equivalent for attrs.define
+- Find fixtures from Pytest entrypoints; Examples of pytest plugins installed
+  like this are pytest-django, pytest-sugar and Faker.
+- Fixed Project.search, when a venv was involved, which is why for example
+  `:Pyimport django.db` did not work in some cases in jedi-vim.
+- And many smaller bugfixes
+
+0.18.1 (2021-11-17)
++++++++++++++++++++
+
+- Implict namespaces are now a separate types in ``Name().type``
+- Python 3.10 support
+- Mostly bugfixes
+
+0.18.0 (2020-12-25)
++++++++++++++++++++
+
+- Dropped Python 2 and Python 3.5
+- Using ``pathlib.Path()`` as an output instead of ``str`` in most places:
+  - ``Project.path``
+  - ``Script.path``
+  - ``Definition.module_path``
+  - ``Refactoring.get_renames``
+  - ``Refactoring.get_changed_files``
+- Functions with ``@property`` now return ``property`` instead of ``function``
+  in ``Name().type``
+- Started using annotations
+- Better support for the walrus operator
+- Project attributes are now read accessible
+- Removed all deprecations
+
+This is likely going to be the last minor release before 1.0.
+
+0.17.2 (2020-07-17)
++++++++++++++++++++
+
+- Added an option to pass environment variables to ``Environment``
+- ``Project(...).path`` exists now
+- Support for Python 3.9
+- A few bugfixes
+
+This will be the last release that supports Python 2 and Python 3.5.
+``0.18.0`` will be Python 3.6+.
+
+0.17.1 (2020-06-20)
++++++++++++++++++++
+
+- Django ``Model`` meta class support
+- Django Manager support (completion on Managers/QuerySets)
+- Added Django Stubs to Jedi, thanks to all contributors of the
+  `Django Stubs <https://github.com/typeddjango/django-stubs>`_ project
+- Added ``SyntaxError.get_message``
+- Python 3.9 support
+- Bugfixes (mostly towards Generics)
+
+0.17.0 (2020-04-14)
++++++++++++++++++++
+
+- Added ``Project`` support. This allows a user to specify which folders Jedi
+  should work with.
+- Added support for Refactoring. The following refactorings have been
+  implemented: ``Script.rename``, ``Script.inline``,
+  ``Script.extract_variable`` and ``Script.extract_function``.
+- Added ``Script.get_syntax_errors`` to display syntax errors in the current
+  script.
+- Added code search capabilities both for individual files and projects. The
+  new functions are ``Project.search``, ``Project.complete_search``,
+  ``Script.search`` and ``Script.complete_search``.
+- Added ``Script.help`` to make it easier to display a help window to people.
+  Now returns pydoc information as well for Python keywords/operators.  This
+  means that on the class keyword it will now return the docstring of Python's
+  builtin function ``help('class')``.
+- The API documentation is now way more readable and complete. Check it out
+  under https://jedi.readthedocs.io. A lot of it has been rewritten.
+- Removed Python 3.4 support
+- Many bugfixes
+
+This is likely going to be the last minor version that supports Python 2 and
+Python3.5. Bugfixes will be provided in 0.17.1+. The next minor/major version
+will probably be Jedi 1.0.0.
+
+0.16.0 (2020-01-26)
++++++++++++++++++++
+
+- **Added** ``Script.get_context`` to get information where you currently are.
+- Completions/type inference of **Pytest fixtures**.
+- Tensorflow, Numpy and Pandas completions should now be about **4-10x faster**
+  after the first time they are used.
+- Dict key completions are working now. e.g. ``d = {1000: 3}; d[10`` will
+  expand to ``1000``.
+- Completion for "proxies" works now. These are classes that have a
+  ``__getattr__(self, name)`` method that does a ``return getattr(x, name)``.
+  after loading them initially.
+- Goto on a function/attribute in a class now goes to the definition in its
+  super class.
+- Big **Script API Changes**:
+    - The line and column parameters of ``jedi.Script`` are now deprecated
+    - ``completions`` deprecated, use ``complete`` instead
+    - ``goto_assignments`` deprecated, use ``goto`` instead
+    - ``goto_definitions`` deprecated, use ``infer`` instead
+    - ``call_signatures`` deprecated, use ``get_signatures`` instead
+    - ``usages`` deprecated, use ``get_references`` instead
+    - ``jedi.names`` deprecated, use ``jedi.Script(...).get_names()``
+- ``BaseName.goto_assignments`` renamed to ``BaseName.goto``
+- Add follow_imports to ``Name.goto``. Now its signature matches
+  ``Script.goto``.
+- **Python 2 support deprecated**. For this release it is best effort. Python 2
+  has reached the end of its life and now it's just about a smooth transition.
+  Bugs for Python 2 will not be fixed anymore and a third of the tests are
+  already skipped.
+- Removed ``settings.no_completion_duplicates``. It wasn't tested and nobody
+  was probably using it anyway.
+- Removed ``settings.use_filesystem_cache`` and
+  ``settings.additional_dynamic_modules``, they have no usage anymore. Pretty
+  much nobody was probably using them.
+
+0.15.2 (2019-12-20)
++++++++++++++++++++
+
+- Signatures are now detected a lot better
+- Add fuzzy completions with ``Script(...).completions(fuzzy=True)``
+- Files bigger than one MB (about 20kLOC) get cropped to avoid getting
+  stuck completely.
+- Many small Bugfixes
+- A big refactoring around contexts/values
+
 0.15.1 (2019-08-13)
 +++++++++++++++++++
 
@@ -11,8 +159,8 @@ Changelog
 0.15.0 (2019-08-11)
 +++++++++++++++++++
 
-- Added file path completions, there's a **new ``Completion.type``** ``path``,
-  now. Example: ``'/ho`` -> ``'/home/``
+- Added file path completions, there's a **new** ``Completion.type`` now:
+  ``path``. Example: ``'/ho`` -> ``'/home/``
 - ``*args``/``**kwargs`` resolving. If possible Jedi replaces the parameters
   with the actual alternatives.
 - Better support for enums/dataclasses
@@ -21,14 +169,14 @@ Changelog
 
 New APIs:
 
-- ``Definition.get_signatures() -> List[Signature]``. Signatures are similar to
-  ``CallSignature``. ``Definition.params`` is therefore deprecated.
-- ``Signature.to_string()`` to format call signatures.
-- ``Signature.params -> List[ParamDefinition]``, ParamDefinition has the
+- ``Name.get_signatures() -> List[Signature]``. Signatures are similar to
+  ``CallSignature``. ``Name.params`` is therefore deprecated.
+- ``Signature.to_string()`` to format signatures.
+- ``Signature.params -> List[ParamName]``, ParamName has the
   following additional attributes ``infer_default()``, ``infer_annotation()``,
   ``to_string()``, and ``kind``.
-- ``Definition.execute() -> List[Definition]``, makes it possible to infer
-    return values of functions.
+- ``Name.execute() -> List[Name]``, makes it possible to infer
+  return values of functions.
 
 
 0.14.1 (2019-07-13)
@@ -43,7 +191,7 @@ New APIs:
 - Added ``goto_*(prefer_stubs=True)`` as well as ``goto_*(prefer_stubs=True)``
 - Stubs are used now for type inference
 - Typeshed is used for better type inference
-- Reworked Definition.full_name, should have more correct return values
+- Reworked Name.full_name, should have more correct return values
 
 0.13.3 (2019-02-24)
 +++++++++++++++++++
@@ -123,7 +271,7 @@ New APIs:
 - Actual semantic completions for the complete Python syntax.
 - Basic type inference for ``yield from`` PEP 380.
 - PEP 484 support (most of the important features of it). Thanks Claude! (@reinhrst)
-- Added ``get_line_code`` to ``Definition`` and ``Completion`` objects.
+- Added ``get_line_code`` to ``Name`` and ``Completion`` objects.
 - Completely rewritten the type inference engine.
 - A new and better parser for (fast) parsing diffs of Python code.
 
@@ -131,12 +279,12 @@ New APIs:
 ++++++++++++++++++
 
 - The import logic has been rewritten to look more like Python's. There is now
-  an ``Evaluator.modules`` import cache, which resembles ``sys.modules``.
+  an ``InferState.modules`` import cache, which resembles ``sys.modules``.
 - Integrated the parser of 2to3. This will make refactoring possible. It will
   also be possible to check for error messages (like compiling an AST would give)
   in the future.
-- With the new parser, the evaluation also completely changed. It's now simpler
-  and more readable.
+- With the new parser, the type inference also completely changed. It's now
+  simpler and more readable.
 - Completely rewritten REPL completion.
 - Added ``jedi.names``, a command to do static analysis. Thanks to that
   sourcegraph guys for sponsoring this!

MANIFEST.in

@@ -6,11 +6,9 @@ include .coveragerc
 include sith.py
 include conftest.py
 include pytest.ini
-include tox.ini
-include requirements.txt
-include jedi/parser/python/grammar*.txt
 recursive-include jedi/third_party *.pyi
 include jedi/third_party/typeshed/LICENSE
+include jedi/third_party/django-stubs/LICENSE.txt
 include jedi/third_party/typeshed/README
 recursive-include test *
 recursive-include docs *

README.rst

@@ -1,117 +1,107 @@
-###################################################################
-Jedi - an awesome autocompletion/static analysis library for Python
-###################################################################
+####################################################################################
+Jedi - an awesome autocompletion, static analysis and refactoring library for Python
+####################################################################################
 
-.. image:: https://img.shields.io/pypi/v/jedi.svg?style=flat
-    :target: https://pypi.python.org/pypi/jedi
-    :alt: PyPI version
+.. 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
 
-.. image:: https://img.shields.io/pypi/pyversions/jedi.svg
-    :target: https://pypi.python.org/pypi/jedi
-    :alt: Supported Python versions
+.. image:: http://isitmaintained.com/badge/resolution/davidhalter/jedi.svg
+    :target: https://github.com/davidhalter/jedi/issues
+    :alt: The resolution time is the median time an issue or pull request stays open.
 
-.. image:: https://travis-ci.org/davidhalter/jedi.svg?branch=master
-    :target: https://travis-ci.org/davidhalter/jedi
-    :alt: Linux Tests
+.. image:: https://github.com/davidhalter/jedi/workflows/ci/badge.svg?branch=master
+    :target: https://github.com/davidhalter/jedi/actions
+    :alt: Tests
 
-.. image:: https://ci.appveyor.com/api/projects/status/mgva3bbawyma1new/branch/master?svg=true
-    :target: https://ci.appveyor.com/project/davidhalter/jedi/branch/master
-    :alt: Windows Tests
-
-.. image:: https://coveralls.io/repos/davidhalter/jedi/badge.svg?branch=master
-    :target: https://coveralls.io/r/davidhalter/jedi
-    :alt: Coverage status
+.. image:: https://pepy.tech/badge/jedi
+    :target: https://pepy.tech/project/jedi
+    :alt: PyPI Downloads
 
 
-*If you have specific questions, please add an issue or ask on* `Stack Overflow
-<https://stackoverflow.com/questions/tagged/python-jedi>`_ *with the label* ``python-jedi``.
+Jedi is a static analysis tool for Python that is typically used in
+IDEs/editors plugins. Jedi has a focus on autocompletion and goto
+functionality. Other features include refactoring, code search and finding
+references.
 
-
-Jedi is a static analysis tool for Python that can be used in IDEs/editors.
-Jedi has a focus on autocompletion and goto functionality. Jedi is fast and is
-very well tested. It understands Python and stubs on a deep level.
-
-Jedi has support for different goto functions. It's possible to search for
-usages and list names in a Python file to get information about them.
-
-Jedi uses a very simple API to connect with IDE's. There's a reference
-implementation as a `VIM-Plugin <https://github.com/davidhalter/jedi-vim>`_,
-which uses Jedi's autocompletion.  We encourage you to use Jedi in your IDEs.
-Autocompletion in your REPL is also possible, IPython uses it natively and for
-the CPython REPL you have to install it.
+Jedi has a simple API to work with. There is a reference implementation as a
+`VIM-Plugin <https://github.com/davidhalter/jedi-vim>`_. Autocompletion in your
+REPL is also possible, IPython uses it natively and for the CPython REPL you
+can install it. Jedi is well tested and bugs should be rare.
 
 Jedi can currently be used with the following editors/projects:
 
 - Vim (jedi-vim_, YouCompleteMe_, deoplete-jedi_, completor.vim_)
+- `Visual Studio Code`_ (via `Python Extension <https://marketplace.visualstudio.com/items?itemName=ms-python.python>`_)
 - Emacs (Jedi.el_, company-mode_, elpy_, anaconda-mode_, ycmd_)
 - Sublime Text (SublimeJEDI_ [ST2 + ST3], anaconda_ [only ST3])
 - TextMate_ (Not sure if it's actually working)
-- Kate_ version 4.13+ supports it natively, you have to enable it, though. [`proof
+- Kate_ version 4.13+ supports it natively, you have to enable it, though.  [`see
   <https://projects.kde.org/projects/kde/applications/kate/repository/show?rev=KDE%2F4.13>`_]
 - Atom_ (autocomplete-python-jedi_)
 - `GNOME Builder`_ (with support for GObject Introspection)
-- `Visual Studio Code`_ (via `Python Extension <https://marketplace.visualstudio.com/items?itemName=ms-python.python>`_)
 - 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>`_
 
 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>`_ (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_:
 
 .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_complete.png
 
-Completion for almost anything (Ctrl+Space).
+Completion for almost anything:
 
 .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_function.png
 
-Display of function/class bodies, docstrings.
+Documentation:
 
 .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_pydoc.png
 
-Pydoc support (Shift+k).
-
-There is also support for goto and renaming.
 
 Get the latest version from `github <https://github.com/davidhalter/jedi>`_
 (master branch should always be kind of stable/working).
 
 Docs are available at `https://jedi.readthedocs.org/en/latest/
-<https://jedi.readthedocs.org/en/latest/>`_. Pull requests with documentation
-enhancements and/or fixes are awesome and most welcome. Jedi uses `semantic
-versioning <https://semver.org/>`_.
+<https://jedi.readthedocs.org/en/latest/>`_. Pull requests with enhancements
+and/or fixes are awesome and most welcome. Jedi uses `semantic versioning
+<https://semver.org/>`_.
 
-If you want to stay up-to-date (News / RFCs), please subscribe to this `github
-thread <https://github.com/davidhalter/jedi/issues/1063>`_.:
+If you want to stay **up-to-date** with releases, please **subscribe** to this
+mailing list: https://groups.google.com/g/jedi-announce. To subscribe you can
+simply send an empty email to ``jedi-announce+subscribe@googlegroups.com``.
 
+Issues & Questions
+==================
 
+You can file issues and questions in the `issue tracker
+<https://github.com/davidhalter/jedi/>`. Alternatively you can also ask on
+`Stack Overflow <https://stackoverflow.com/questions/tagged/python-jedi>`_ with
+the label ``python-jedi``.
 
 Installation
 ============
 
-    pip install jedi
+`Check out the docs <https://jedi.readthedocs.org/en/latest/docs/installation.html>`_.
 
-Note: This just installs the Jedi library, not the editor plugins. For
-information about how to make it work with your editor, refer to the
-corresponding documentation.
+Features and Limitations
+========================
 
-You don't want to use ``pip``? Please refer to the `manual
-<https://jedi.readthedocs.org/en/latest/docs/installation.html>`_.
+Jedi's features are listed here:
+`Features <https://jedi.readthedocs.org/en/latest/docs/features.html>`_.
 
-
-Feature Support and Caveats
-===========================
-
-Jedi really understands your Python code. For a comprehensive list what Jedi
-understands, see: `Features
-<https://jedi.readthedocs.org/en/latest/docs/features.html>`_. A list of
-caveats can be found on the same page.
-
-You can run Jedi on CPython 2.7 or 3.4+ but it should also
-understand/parse code older than those versions. Additionally you should be able
-to use `Virtualenvs <https://jedi.readthedocs.org/en/latest/docs/api.html#environments>`_
+You can run Jedi on Python 3.6+ 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.
 
 Tips on how to use Jedi efficiently can be found `here
@@ -120,46 +110,62 @@ Tips on how to use Jedi efficiently can be found `here
 API
 ---
 
-You can find the documentation for the `API here <https://jedi.readthedocs.org/en/latest/docs/api.html>`_.
+You can find a comprehensive documentation for the
+`API here <https://jedi.readthedocs.org/en/latest/docs/api.html>`_.
 
+Autocompletion / Goto / Documentation
+-------------------------------------
 
-Autocompletion / Goto / Pydoc
------------------------------
+There are the following commands:
 
-Please check the API for a good explanation. There are the following commands:
-
-- ``jedi.Script.goto_assignments``
-- ``jedi.Script.completions``
-- ``jedi.Script.usages``
-
-The returned objects are very powerful and really all you might need.
+- ``jedi.Script.goto``
+- ``jedi.Script.infer``
+- ``jedi.Script.help``
+- ``jedi.Script.complete``
+- ``jedi.Script.get_references``
+- ``jedi.Script.get_signatures``
+- ``jedi.Script.get_context``
 
+The returned objects are very powerful and are really all you might need.
 
 Autocompletion in your REPL (IPython, etc.)
 -------------------------------------------
 
-Starting with IPython `6.0.0` Jedi is a dependency of IPython. Autocompletion
-in IPython is therefore possible without additional configuration.
+Jedi is a dependency of IPython. Autocompletion in IPython with Jedi is
+therefore possible without additional configuration.
 
-It's possible to have Jedi autocompletion in REPL modes - `example video <https://vimeo.com/122332037>`_.
-This means that in Python you can enable tab completion in a `REPL
+Here is an `example video <https://vimeo.com/122332037>`_ how REPL completion
+can look like.
+For the ``python`` shell you can enable tab completion in a `REPL
 <https://jedi.readthedocs.org/en/latest/docs/usage.html#tab-completion-in-the-python-shell>`_.
 
-
 Static Analysis
-------------------------
+---------------
 
-To do all forms of static analysis, please try to use ``jedi.names``. It will
-return a list of names that you can use to infer types and so on.
+For a lot of forms of static analysis, you can try to use
+``jedi.Script(...).get_names``. It will return a list of names that you can
+then filter and work with. There is also a way to list the syntax errors in a
+file: ``jedi.Script.get_syntax_errors``.
 
 
 Refactoring
 -----------
 
-Jedi's parser would support refactoring, but there's no API to use it right
-now.  If you're interested in helping out here, let me know. With the latest
-parser changes, it should be very easy to actually make it work.
+Jedi supports the following refactorings:
 
+- ``jedi.Script.inline``
+- ``jedi.Script.rename``
+- ``jedi.Script.extract_function``
+- ``jedi.Script.extract_variable``
+
+Code Search
+-----------
+
+There is support for module search with ``jedi.Script.search``, and project
+search for ``jedi.Project.search``. The way to search is either by providing a
+name like ``foo`` or by using dotted syntax like ``foo.bar``. Additionally you
+can provide the API type like ``class foo.bar.Bar``. There are also the
+functions ``jedi.Script.complete_search`` and ``jedi.Project.complete_search``.
 
 Development
 ===========
@@ -167,39 +173,26 @@ Development
 There's a pretty good and extensive `development documentation
 <https://jedi.readthedocs.org/en/latest/docs/development.html>`_.
 
-
 Testing
 =======
 
-The test suite depends on ``tox`` and ``pytest``::
+The test suite uses ``pytest``::
 
-    pip install tox pytest
+    pip install pytest
 
-To run the tests for all supported Python versions::
+If you want to test only a specific Python version (e.g. Python 3.8), it is as
+easy as::
 
-    tox
-
-If you want to test only a specific Python version (e.g. Python 2.7), it's as
-easy as ::
-
-    tox -e py27
-
-Tests are also run automatically on `Travis CI
-<https://travis-ci.org/davidhalter/jedi/>`_.
+    python3.8 -m pytest
 
 For more detailed information visit the `testing documentation
 <https://jedi.readthedocs.org/en/latest/docs/testing.html>`_.
 
-
 Acknowledgements
 ================
 
-- Takafumi Arakaki (@tkf) for creating a solid test environment and a lot of
-  other things.
-- Danilo Bargen (@dbrgn) for general housekeeping and being a good friend :).
-- Guido van Rossum (@gvanrossum) for creating the parser generator pgen2
-  (originally used in lib2to3).
-
+Thanks a lot to all the
+`contributors <https://jedi.readthedocs.org/en/latest/docs/acknowledgements.html>`_!
 
 
 .. _jedi-vim: https://github.com/davidhalter/jedi-vim

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.

appveyor.yml

@@ -1,87 +0,0 @@
-environment:
-  matrix:
-  - TOXENV: py27
-    PYTHON_PATH: C:\Python27
-    JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py27
-    PYTHON_PATH: C:\Python27
-    JEDI_TEST_ENVIRONMENT: 34
-  - TOXENV: py27
-    PYTHON_PATH: C:\Python27
-    JEDI_TEST_ENVIRONMENT: 35
-  - TOXENV: py27
-    PYTHON_PATH: C:\Python27
-    JEDI_TEST_ENVIRONMENT: 36
-  - TOXENV: py27
-    PYTHON_PATH: C:\Python27
-    JEDI_TEST_ENVIRONMENT: 37
-
-  - TOXENV: py34
-    PYTHON_PATH: C:\Python34
-    JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py34
-    PYTHON_PATH: C:\Python34
-    JEDI_TEST_ENVIRONMENT: 34
-  - TOXENV: py34
-    PYTHON_PATH: C:\Python34
-    JEDI_TEST_ENVIRONMENT: 35
-  - TOXENV: py34
-    PYTHON_PATH: C:\Python34
-    JEDI_TEST_ENVIRONMENT: 36
-  - TOXENV: py34
-    PYTHON_PATH: C:\Python34
-    JEDI_TEST_ENVIRONMENT: 37
-
-  - TOXENV: py35
-    PYTHON_PATH: C:\Python35
-    JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py35
-    PYTHON_PATH: C:\Python35
-    JEDI_TEST_ENVIRONMENT: 34
-  - TOXENV: py35
-    PYTHON_PATH: C:\Python35
-    JEDI_TEST_ENVIRONMENT: 35
-  - TOXENV: py35
-    PYTHON_PATH: C:\Python35
-    JEDI_TEST_ENVIRONMENT: 36
-  - TOXENV: py35
-    PYTHON_PATH: C:\Python35
-    JEDI_TEST_ENVIRONMENT: 37
-
-  - TOXENV: py36
-    PYTHON_PATH: C:\Python36
-    JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py36
-    PYTHON_PATH: C:\Python36
-    JEDI_TEST_ENVIRONMENT: 34
-  - TOXENV: py36
-    PYTHON_PATH: C:\Python36
-    JEDI_TEST_ENVIRONMENT: 35
-  - TOXENV: py36
-    PYTHON_PATH: C:\Python36
-    JEDI_TEST_ENVIRONMENT: 36
-  - TOXENV: py36
-    PYTHON_PATH: C:\Python36
-    JEDI_TEST_ENVIRONMENT: 37
-
-  - TOXENV: py37
-    PYTHON_PATH: C:\Python37
-    JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py37
-    PYTHON_PATH: C:\Python37
-    JEDI_TEST_ENVIRONMENT: 34
-  - TOXENV: py37
-    PYTHON_PATH: C:\Python37
-    JEDI_TEST_ENVIRONMENT: 35
-  - TOXENV: py37
-    PYTHON_PATH: C:\Python37
-    JEDI_TEST_ENVIRONMENT: 36
-  - TOXENV: py37
-    PYTHON_PATH: C:\Python37
-    JEDI_TEST_ENVIRONMENT: 37
-install:
-  - git submodule update --init --recursive
-  - set PATH=%PYTHON_PATH%;%PYTHON_PATH%\Scripts;%PATH%
-  - pip install tox
-build_script:
-  - tox

conftest.py

@@ -1,20 +1,22 @@
 import tempfile
 import shutil
 import os
+import sys
 from functools import partial
 
 import pytest
 
 import jedi
 from jedi.api.environment import get_system_environment, InterpreterEnvironment
-from jedi._compatibility import py_version
+from test.helpers import test_dir
 
 collect_ignore = [
     'setup.py',
-    '__main__.py',
-    'jedi/evaluate/compiled/subprocess/__main__.py',
+    'jedi/__main__.py',
+    'jedi/inference/compiled/subprocess/__main__.py',
     'build/',
     'test/examples',
+    'sith.py',
 ]
 
 
@@ -40,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. 35 for python3.5).")
+                     help="Execute the tests in that environment (e.g. 39 for python3.9).")
     parser.addoption("--interpreter-env", "-I", action='store_true',
                      help="Don't use subprocesses to guarantee having safe "
                           "code execution. Useful for debugging.")
@@ -90,14 +92,17 @@ def clean_jedi_cache(request):
 
 @pytest.fixture(scope='session')
 def environment(request):
-    if request.config.option.interpreter_env:
-        return InterpreterEnvironment()
-
     version = request.config.option.env
     if version is None:
-        version = os.environ.get('JEDI_TEST_ENVIRONMENT', str(py_version))
+        v = str(sys.version_info[0]) + str(sys.version_info[1])
+        version = os.environ.get('JEDI_TEST_ENVIRONMENT', v)
 
-    return get_system_environment(version[0] + '.' + version[1:])
+    if request.config.option.interpreter_env or version == 'interpreter':
+        return InterpreterEnvironment()
+
+    if '.' not in version:
+        version = version[0] + '.' + version[1:]
+    return get_system_environment(version)
 
 
 @pytest.fixture(scope='session')
@@ -106,19 +111,44 @@ def Script(environment):
 
 
 @pytest.fixture(scope='session')
-def names(environment):
-    return partial(jedi.names, environment=environment)
+def ScriptWithProject(Script):
+    project = jedi.Project(test_dir)
+    return partial(jedi.Script, project=project)
 
 
 @pytest.fixture(scope='session')
-def has_typing(environment):
-    if environment.version_info >= (3, 5, 0):
-        # This if is just needed to avoid that tests ever skip way more than
-        # they should for all Python versions.
-        return True
+def get_names(Script):
+    return lambda code, **kwargs: Script(code).get_names(**kwargs)
 
-    script = jedi.Script('import typing', environment=environment)
-    return bool(script.goto_definitions())
+
+@pytest.fixture(scope='session', params=['goto', 'infer'])
+def goto_or_infer(request, Script):
+    return lambda code, *args, **kwargs: getattr(Script(code), request.param)(*args, **kwargs)
+
+
+@pytest.fixture(scope='session', params=['goto', 'help'])
+def goto_or_help(request, Script):
+    return lambda code, *args, **kwargs: getattr(Script(code), request.param)(*args, **kwargs)
+
+
+@pytest.fixture(scope='session', params=['goto', 'help', 'infer'])
+def goto_or_help_or_infer(request, Script):
+    def do(code, *args, **kwargs):
+        return getattr(Script(code), request.param)(*args, **kwargs)
+
+    do.type = request.param
+    return do
+
+
+@pytest.fixture(scope='session', params=['goto', 'complete', 'help'])
+def goto_or_complete(request, Script):
+    return lambda code, *args, **kwargs: getattr(Script(code), request.param)(*args, **kwargs)
+
+
+@pytest.fixture(scope='session')
+def has_django(environment):
+    script = jedi.Script('import django', environment=environment)
+    return bool(script.infer())
 
 
 @pytest.fixture(scope='session')
@@ -126,14 +156,6 @@ def jedi_path():
     return os.path.dirname(__file__)
 
 
-@pytest.fixture()
-def skip_python2(environment):
-    if environment.version_info.major == 2:
-        # 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_python38(environment):
     if environment.version_info < (3, 8):
@@ -148,11 +170,3 @@ def skip_pre_python37(environment):
         # 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_python35(environment):
-    if environment.version_info < (3, 5):
-        # This if is just needed to avoid that tests ever skip way more than
-        # they should for all Python versions.
-        pytest.skip()

deploy-master.sh

@@ -24,10 +24,10 @@ git checkout $BRANCH
 git submodule update --init
 
 # Test first.
-tox
+pytest
 
 # Create tag
-tag=v$(python -c "import $PROJECT_NAME; print($PROJECT_NAME.__version__)")
+tag=v$(python3 -c "import $PROJECT_NAME; print($PROJECT_NAME.__version__)")
 
 master_ref=$(git show-ref -s heads/$BRANCH)
 tag_ref=$(git show-ref -s $tag || true)
@@ -44,7 +44,7 @@ fi
 # Package and upload to PyPI
 #rm -rf dist/ - Not needed anymore, because the folder is never reused.
 echo `pwd`
-python setup.py sdist bdist_wheel
+python3 setup.py sdist bdist_wheel
 # Maybe do a pip install twine before.
 twine upload dist/*
 

docs/_static/custom_style.css

@@ -0,0 +1,9 @@
+div.version {
+    color: black !important;
+    margin-top: -1.2em !important;
+    margin-bottom: .6em !important;
+}
+
+div.wy-side-nav-search {
+    padding-top: 0 !important;
+}

docs/_themes/flask/LICENSE

@@ -1,37 +0,0 @@
-Copyright (c) 2010 by Armin Ronacher.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms of the theme, with or
-without modification, are permitted provided that the following conditions
-are met:
-
-* Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the following
-  disclaimer in the documentation and/or other materials provided
-  with the distribution.
-
-* The names of the contributors may not be used to endorse or
-  promote products derived from this software without specific
-  prior written permission.
-
-We kindly ask you to only use these themes in an unmodified manner just
-for Flask and Flask-related products, not for unrelated projects.  If you
-like the visual style and want to use it for your own projects, please
-consider making some larger changes to the themes (such as changing
-font faces, sizes, colors or margins).
-
-THIS THEME IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS THEME, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.

docs/_themes/flask/layout.html

@@ -1,27 +0,0 @@
-{%- extends "basic/layout.html" %}
-{%- block extrahead %}
-  {{ super() }}
-  {% if theme_touch_icon %}
-  <link rel="apple-touch-icon" href="{{ pathto('_static/' ~ theme_touch_icon, 1) }}" />
-  {% endif %}
-  <link media="only screen and (max-device-width: 480px)" href="{{
-    pathto('_static/small_flask.css', 1) }}" type= "text/css" rel="stylesheet" />
-  <a href="https://github.com/davidhalter/jedi">
-    <img style="position: absolute; top: 0; right: 0; border: 0;" src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png" alt="Fork me on GitHub">
-  </a>
-{% endblock %}
-{%- block relbar2 %}{% endblock %}
-{% block header %}
-  {{ super() }}
-  {% if pagename == 'index' %}
-  <div class=indexwrapper>
-  {% endif %}
-{% endblock %}
-{%- block footer %}
-  <div class="footer">
-    Created using <a href="http://sphinx.pocoo.org/">Sphinx</a>.
-  </div>
-  {% if pagename == 'index' %}
-  </div>
-  {% endif %}
-{%- endblock %}

docs/_themes/flask/relations.html

@@ -1,19 +0,0 @@
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="{{ pathto(master_doc) }}">Documentation overview</a><ul>
-  {%- for parent in parents %}
-  <li><a href="{{ parent.link|e }}">{{ parent.title }}</a><ul>
-  {%- endfor %}
-    {%- if prev %}
-      <li>Previous: <a href="{{ prev.link|e }}" title="{{ _('previous chapter')
-        }}">{{ prev.title }}</a></li>
-    {%- endif %}
-    {%- if next %}
-      <li>Next: <a href="{{ next.link|e }}" title="{{ _('next chapter')
-        }}">{{ next.title }}</a></li>
-    {%- endif %}
-  {%- for parent in parents %}
-  </ul></li>
-  {%- endfor %}
-  </ul></li>
-</ul>

docs/_themes/flask/static/flasky.css_t

@@ -1,394 +0,0 @@
-/*
- * flasky.css_t
- * ~~~~~~~~~~~~
- *
- * :copyright: Copyright 2010 by Armin Ronacher.
- * :license: Flask Design License, see LICENSE for details.
- */
-
-{% set page_width = '940px' %}
-{% set sidebar_width = '220px' %}
- 
-@import url("basic.css");
- 
-/* -- page layout ----------------------------------------------------------- */
- 
-body {
-    font-family: 'Georgia', serif;
-    font-size: 17px;
-    background-color: white;
-    color: #000;
-    margin: 0;
-    padding: 0;
-}
-
-div.document {
-    width: {{ page_width }};
-    margin: 30px auto 0 auto;
-}
-
-div.documentwrapper {
-    float: left;
-    width: 100%;
-}
-
-div.bodywrapper {
-    margin: 0 0 0 {{ sidebar_width }};
-}
-
-div.sphinxsidebar {
-    width: {{ sidebar_width }};
-}
-
-hr {
-    border: 1px solid #B1B4B6;
-}
- 
-div.body {
-    background-color: #ffffff;
-    color: #3E4349;
-    padding: 0 30px 0 30px;
-}
-
-img.floatingflask {
-    padding: 0 0 10px 10px;
-    float: right;
-}
- 
-div.footer {
-    width: {{ page_width }};
-    margin: 20px auto 30px auto;
-    font-size: 14px;
-    color: #888;
-    text-align: right;
-}
-
-div.footer a {
-    color: #888;
-}
-
-div.related {
-    display: none;
-}
- 
-div.sphinxsidebar a {
-    color: #444;
-    text-decoration: none;
-    border-bottom: 1px dotted #999;
-}
-
-div.sphinxsidebar a:hover {
-    border-bottom: 1px solid #999;
-}
- 
-div.sphinxsidebar {
-    font-size: 14px;
-    line-height: 1.5;
-}
-
-div.sphinxsidebarwrapper {
-    padding: 18px 10px;
-}
-
-div.sphinxsidebarwrapper p.logo {
-    padding: 0 0 20px 0;
-    margin: 0;
-    text-align: center;
-}
- 
-div.sphinxsidebar h3,
-div.sphinxsidebar h4 {
-    font-family: 'Garamond', 'Georgia', serif;
-    color: #444;
-    font-size: 24px;
-    font-weight: normal;
-    margin: 0 0 5px 0;
-    padding: 0;
-}
-
-div.sphinxsidebar h4 {
-    font-size: 20px;
-}
- 
-div.sphinxsidebar h3 a {
-    color: #444;
-}
-
-div.sphinxsidebar p.logo a,
-div.sphinxsidebar h3 a,
-div.sphinxsidebar p.logo a:hover,
-div.sphinxsidebar h3 a:hover {
-    border: none;
-}
- 
-div.sphinxsidebar p {
-    color: #555;
-    margin: 10px 0;
-}
-
-div.sphinxsidebar ul {
-    margin: 10px 0;
-    padding: 0;
-    color: #000;
-}
- 
-div.sphinxsidebar input {
-    border: 1px solid #ccc;
-    font-family: 'Georgia', serif;
-    font-size: 1em;
-}
- 
-/* -- body styles ----------------------------------------------------------- */
- 
-a {
-    color: #004B6B;
-    text-decoration: underline;
-}
- 
-a:hover {
-    color: #6D4100;
-    text-decoration: underline;
-}
- 
-div.body h1,
-div.body h2,
-div.body h3,
-div.body h4,
-div.body h5,
-div.body h6 {
-    font-family: 'Garamond', 'Georgia', serif;
-    font-weight: normal;
-    margin: 30px 0px 10px 0px;
-    padding: 0;
-}
-
-{% if theme_index_logo %}
-div.indexwrapper h1 {
-    text-indent: -999999px;
-    background: url({{ theme_index_logo }}) no-repeat center center;
-    height: {{ theme_index_logo_height }};
-}
-{% endif %}
- 
-div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; }
-div.body h2 { font-size: 180%; }
-div.body h3 { font-size: 150%; }
-div.body h4 { font-size: 130%; }
-div.body h5 { font-size: 100%; }
-div.body h6 { font-size: 100%; }
- 
-a.headerlink {
-    color: #ddd;
-    padding: 0 4px;
-    text-decoration: none;
-}
- 
-a.headerlink:hover {
-    color: #444;
-}
- 
-div.body p, div.body dd, div.body li {
-    line-height: 1.4em;
-}
-
-div.admonition {
-    background: #fafafa;
-    margin: 20px -30px;
-    padding: 10px 30px;
-    border-top: 1px solid #ccc;
-    border-bottom: 1px solid #ccc;
-}
-
-div.admonition tt.xref, div.admonition a tt {
-    border-bottom: 1px solid #fafafa;
-}
-
-dd div.admonition {
-    margin-left: -60px;
-    padding-left: 60px;
-}
-
-div.admonition p.admonition-title {
-    font-family: 'Garamond', 'Georgia', serif;
-    font-weight: normal;
-    font-size: 24px;
-    margin: 0 0 10px 0;
-    padding: 0;
-    line-height: 1;
-}
-
-div.admonition p.last {
-    margin-bottom: 0;
-}
-
-div.highlight {
-    background-color: white;
-}
-
-dt:target, .highlight {
-    background: #FAF3E8;
-}
-
-div.note {
-    background-color: #eee;
-    border: 1px solid #ccc;
-}
- 
-div.seealso {
-    background-color: #ffc;
-    border: 1px solid #ff6;
-}
- 
-div.topic {
-    background-color: #eee;
-}
- 
-p.admonition-title {
-    display: inline;
-}
- 
-p.admonition-title:after {
-    content: ":";
-}
-
-pre, tt {
-    font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
-    font-size: 0.9em;
-}
-
-img.screenshot {
-}
-
-tt.descname, tt.descclassname {
-    font-size: 0.95em;
-}
-
-tt.descname {
-    padding-right: 0.08em;
-}
-
-img.screenshot {
-    -moz-box-shadow: 2px 2px 4px #eee;
-    -webkit-box-shadow: 2px 2px 4px #eee;
-    box-shadow: 2px 2px 4px #eee;
-}
-
-table.docutils {
-    border: 1px solid #888;
-    -moz-box-shadow: 2px 2px 4px #eee;
-    -webkit-box-shadow: 2px 2px 4px #eee;
-    box-shadow: 2px 2px 4px #eee;
-}
-
-table.docutils td, table.docutils th {
-    border: 1px solid #888;
-    padding: 0.25em 0.7em;
-}
-
-table.field-list, table.footnote {
-    border: none;
-    -moz-box-shadow: none;
-    -webkit-box-shadow: none;
-    box-shadow: none;
-}
-
-table.footnote {
-    margin: 15px 0;
-    width: 100%;
-    border: 1px solid #eee;
-    background: #fdfdfd;
-    font-size: 0.9em;
-}
-
-table.footnote + table.footnote {
-    margin-top: -15px;
-    border-top: none;
-}
-
-table.field-list th {
-    padding: 0 0.8em 0 0;
-}
-
-table.field-list td {
-    padding: 0;
-}
-
-table.footnote td.label {
-    width: 0px;
-    padding: 0.3em 0 0.3em 0.5em;
-}
-
-table.footnote td {
-    padding: 0.3em 0.5em;
-}
-
-dl {
-    margin: 0;
-    padding: 0;
-}
-
-dl dd {
-    margin-left: 30px;
-}
-
-blockquote {
-    margin: 0 0 0 30px;
-    padding: 0;
-}
-
-ul, ol {
-    margin: 10px 0 10px 30px;
-    padding: 0;
-}
- 
-pre {
-    background: #eee;
-    padding: 7px 30px;
-    margin: 15px -30px;
-    line-height: 1.3em;
-}
-
-dl pre, blockquote pre, li pre {
-    margin-left: -60px;
-    padding-left: 60px;
-}
-
-dl dl pre {
-    margin-left: -90px;
-    padding-left: 90px;
-}
- 
-tt {
-    background-color: #ecf0f3;
-    color: #222;
-    /* padding: 1px 2px; */
-}
-
-tt.xref, a tt {
-    background-color: #FBFBFB;
-    border-bottom: 1px solid white;
-}
-
-a.reference {
-    text-decoration: none;
-    border-bottom: 1px dotted #004B6B;
-}
-
-a.reference:hover {
-    border-bottom: 1px solid #6D4100;
-}
-
-a.footnote-reference {
-    text-decoration: none;
-    font-size: 0.7em;
-    vertical-align: top;
-    border-bottom: 1px dotted #004B6B;
-}
-
-a.footnote-reference:hover {
-    border-bottom: 1px solid #6D4100;
-}
-
-a:hover tt {
-    background: #EEE;
-}

docs/_themes/flask/static/small_flask.css

@@ -1,70 +0,0 @@
-/*
- * small_flask.css_t
- * ~~~~~~~~~~~~~~~~~
- *
- * :copyright: Copyright 2010 by Armin Ronacher.
- * :license: Flask Design License, see LICENSE for details.
- */
-
-body {
-    margin: 0;
-    padding: 20px 30px;
-}
-
-div.documentwrapper {
-    float: none;
-    background: white;
-}
-
-div.sphinxsidebar {
-    display: block;
-    float: none;
-    width: 102.5%;
-    margin: 50px -30px -20px -30px;
-    padding: 10px 20px;
-    background: #333;
-    color: white;
-}
-
-div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p,
-div.sphinxsidebar h3 a {
-    color: white;
-}
-
-div.sphinxsidebar a {
-    color: #aaa;
-}
-
-div.sphinxsidebar p.logo {
-    display: none;
-}
-
-div.document {
-    width: 100%;
-    margin: 0;
-}
-
-div.related {
-    display: block;
-    margin: 0;
-    padding: 10px 0 20px 0;
-}
-
-div.related ul,
-div.related ul li {
-    margin: 0;
-    padding: 0;
-}
-
-div.footer {
-    display: none;
-}
-
-div.bodywrapper {
-    margin: 0;
-}
-
-div.body {
-    min-height: 0;
-    padding: 0;
-}

docs/_themes/flask/theme.conf

@@ -1,9 +0,0 @@
-[theme]
-inherit = basic
-stylesheet = flasky.css
-pygments_style = flask_theme_support.FlaskyStyle
-
-[options]
-index_logo = 
-index_logo_height = 120px
-touch_icon = 

docs/_themes/flask_theme_support.py

@@ -1,125 +0,0 @@
-"""
-Copyright (c) 2010 by Armin Ronacher.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms of the theme, with or
-without modification, are permitted provided that the following conditions
-are met:
-
-* Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the following
-  disclaimer in the documentation and/or other materials provided
-  with the distribution.
-
-* The names of the contributors may not be used to endorse or
-  promote products derived from this software without specific
-  prior written permission.
-
-We kindly ask you to only use these themes in an unmodified manner just
-for Flask and Flask-related products, not for unrelated projects.  If you
-like the visual style and want to use it for your own projects, please
-consider making some larger changes to the themes (such as changing
-font faces, sizes, colors or margins).
-
-THIS THEME IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS THEME, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-"""
-# flasky extensions.  flasky pygments style based on tango style
-from pygments.style import Style
-from pygments.token import Keyword, Name, Comment, String, Error, \
-     Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
-
-
-class FlaskyStyle(Style):
-    background_color = "#f8f8f8"
-    default_style = ""
-
-    styles = {
-        # No corresponding class for the following:
-        #Text:                     "", # class:  ''
-        Whitespace:                "underline #f8f8f8",      # class: 'w'
-        Error:                     "#a40000 border:#ef2929", # class: 'err'
-        Other:                     "#000000",                # class 'x'
-
-        Comment:                   "italic #8f5902", # class: 'c'
-        Comment.Preproc:           "noitalic",       # class: 'cp'
-
-        Keyword:                   "bold #004461",   # class: 'k'
-        Keyword.Constant:          "bold #004461",   # class: 'kc'
-        Keyword.Declaration:       "bold #004461",   # class: 'kd'
-        Keyword.Namespace:         "bold #004461",   # class: 'kn'
-        Keyword.Pseudo:            "bold #004461",   # class: 'kp'
-        Keyword.Reserved:          "bold #004461",   # class: 'kr'
-        Keyword.Type:              "bold #004461",   # class: 'kt'
-
-        Operator:                  "#582800",   # class: 'o'
-        Operator.Word:             "bold #004461",   # class: 'ow' - like keywords
-
-        Punctuation:               "bold #000000",   # class: 'p'
-
-        # because special names such as Name.Class, Name.Function, etc.
-        # are not recognized as such later in the parsing, we choose them
-        # to look the same as ordinary variables.
-        Name:                      "#000000",        # class: 'n'
-        Name.Attribute:            "#c4a000",        # class: 'na' - to be revised
-        Name.Builtin:              "#004461",        # class: 'nb'
-        Name.Builtin.Pseudo:       "#3465a4",        # class: 'bp'
-        Name.Class:                "#000000",        # class: 'nc' - to be revised
-        Name.Constant:             "#000000",        # class: 'no' - to be revised
-        Name.Decorator:            "#888",           # class: 'nd' - to be revised
-        Name.Entity:               "#ce5c00",        # class: 'ni'
-        Name.Exception:            "bold #cc0000",   # class: 'ne'
-        Name.Function:             "#000000",        # class: 'nf'
-        Name.Property:             "#000000",        # class: 'py'
-        Name.Label:                "#f57900",        # class: 'nl'
-        Name.Namespace:            "#000000",        # class: 'nn' - to be revised
-        Name.Other:                "#000000",        # class: 'nx'
-        Name.Tag:                  "bold #004461",   # class: 'nt' - like a keyword
-        Name.Variable:             "#000000",        # class: 'nv' - to be revised
-        Name.Variable.Class:       "#000000",        # class: 'vc' - to be revised
-        Name.Variable.Global:      "#000000",        # class: 'vg' - to be revised
-        Name.Variable.Instance:    "#000000",        # class: 'vi' - to be revised
-
-        Number:                    "#990000",        # class: 'm'
-
-        Literal:                   "#000000",        # class: 'l'
-        Literal.Date:              "#000000",        # class: 'ld'
-
-        String:                    "#4e9a06",        # class: 's'
-        String.Backtick:           "#4e9a06",        # class: 'sb'
-        String.Char:               "#4e9a06",        # class: 'sc'
-        String.Doc:                "italic #8f5902", # class: 'sd' - like a comment
-        String.Double:             "#4e9a06",        # class: 's2'
-        String.Escape:             "#4e9a06",        # class: 'se'
-        String.Heredoc:            "#4e9a06",        # class: 'sh'
-        String.Interpol:           "#4e9a06",        # class: 'si'
-        String.Other:              "#4e9a06",        # class: 'sx'
-        String.Regex:              "#4e9a06",        # class: 'sr'
-        String.Single:             "#4e9a06",        # class: 's1'
-        String.Symbol:             "#4e9a06",        # class: 'ss'
-
-        Generic:                   "#000000",        # class: 'g'
-        Generic.Deleted:           "#a40000",        # class: 'gd'
-        Generic.Emph:              "italic #000000", # class: 'ge'
-        Generic.Error:             "#ef2929",        # class: 'gr'
-        Generic.Heading:           "bold #000080",   # class: 'gh'
-        Generic.Inserted:          "#00A000",        # class: 'gi'
-        Generic.Output:            "#888",           # class: 'go'
-        Generic.Prompt:            "#745334",        # class: 'gp'
-        Generic.Strong:            "bold #000000",   # class: 'gs'
-        Generic.Subheading:        "bold #800080",   # class: 'gu'
-        Generic.Traceback:         "bold #a40000",   # class: 'gt'
-    }

docs/conf.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-#
 # Jedi documentation build configuration file, created by
 # sphinx-quickstart on Wed Dec 26 00:11:34 2012.
 #
@@ -13,13 +11,11 @@
 
 import sys
 import os
-import datetime
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 sys.path.insert(0, os.path.abspath('..'))
-sys.path.append(os.path.abspath('_themes'))
 
 # -- General configuration -----------------------------------------------------
 
@@ -29,7 +25,8 @@ sys.path.append(os.path.abspath('_themes'))
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'sphinx.ext.todo',
-              'sphinx.ext.intersphinx', 'sphinx.ext.inheritance_diagram']
+              'sphinx.ext.intersphinx', 'sphinx.ext.inheritance_diagram',
+              'sphinx_rtd_theme', 'sphinx.ext.autosummary']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -44,8 +41,8 @@ source_encoding = 'utf-8'
 master_doc = 'index'
 
 # General information about the project.
-project = u'Jedi'
-copyright = u'jedi contributors'
+project = 'Jedi'
+copyright = 'jedi contributors'
 
 import jedi
 from jedi.utils import version_info
@@ -54,8 +51,8 @@ from jedi.utils import version_info
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
-# The short X.Y version.
-version = '.'.join(str(x) for x in version_info()[:2])
+# The short X.Y.Z version.
+version = '.'.join(str(x) for x in version_info()[:3])
 # The full version, including alpha/beta/rc tags.
 release = jedi.__version__
 
@@ -98,12 +95,15 @@ pygments_style = 'sphinx'
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
-html_theme = 'flask'
+html_theme = 'sphinx_rtd_theme'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-#html_theme_options = {}
+html_theme_options = {
+    'logo_only': True,
+    'style_nav_header_background': 'white',
+}
 
 # Add any paths that contain custom themes here, relative to this directory.
 html_theme_path = ['_themes']
@@ -117,7 +117,7 @@ html_theme_path = ['_themes']
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-#html_logo = None
+html_logo = '_static/logo.png'
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
@@ -129,6 +129,8 @@ html_theme_path = ['_themes']
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']
 
+html_css_files = ['custom_style.css']
+
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
 #html_last_updated_fmt = '%b %d, %Y'
@@ -145,7 +147,7 @@ html_sidebars = {
         #'relations.html',
         'ghbuttons.html',
         #'sourcelink.html',
-        #'searchbox.html'
+        'searchbox.html'
     ]
 }
 
@@ -163,13 +165,13 @@ html_sidebars = {
 #html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
+html_show_sourcelink = False
 
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
+html_show_sphinx = False
 
 # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#html_show_copyright = True
+html_show_copyright = False
 
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
@@ -201,8 +203,8 @@ latex_elements = {
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-    ('index', 'Jedi.tex', u'Jedi Documentation',
-     u'Jedi contributors', 'manual'),
+    ('index', 'Jedi.tex', 'Jedi Documentation',
+     'Jedi contributors', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -231,8 +233,8 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'jedi', u'Jedi Documentation',
-     [u'Jedi contributors'], 1)
+    ('index', 'jedi', 'Jedi Documentation',
+     ['Jedi contributors'], 1)
 ]
 
 # If true, show URL addresses after external links.
@@ -245,8 +247,8 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    ('index', 'Jedi', u'Jedi Documentation',
-     u'Jedi contributors', 'Jedi', 'Awesome Python autocompletion library.',
+    ('index', 'Jedi', 'Jedi Documentation',
+     'Jedi contributors', 'Jedi', 'Awesome Python autocompletion library.',
      'Miscellaneous'),
 ]
 
@@ -274,7 +276,8 @@ autodoc_default_flags = []
 # -- Options for intersphinx module --------------------------------------------
 
 intersphinx_mapping = {
-    'https://docs.python.org/': None,
+    'python': ('https://docs.python.org/', None),
+    'parso': ('https://parso.readthedocs.io/en/latest/', None),
 }
 
 

docs/docs/acknowledgements.rst

@@ -0,0 +1,66 @@
+.. include global.rst
+
+History & Acknowledgements
+==========================
+
+Acknowledgements
+----------------
+
+- Dave Halter for creating and maintaining Jedi & Parso.
+- Takafumi Arakaki (@tkf) for creating a solid test environment and a lot of
+  other things.
+- Danilo Bargen (@dbrgn) for general housekeeping and being a good friend :).
+- Guido van Rossum (@gvanrossum) for creating the parser generator pgen2
+  (originally used in lib2to3).
+- Thanks to all the :ref:`contributors <contributors>`.
+
+A Little Bit of History
+-----------------------
+
+Written by Dave.
+
+The Star Wars Jedi are awesome. My Jedi software tries to imitate a little bit
+of the precognition the Jedi have. There's even an awesome `scene
+<https://youtu.be/yHRJLIf7wMU>`_ of Monty Python Jedis :-).
+
+But actually the name has not much to do with Star Wars. It's part of my
+second name Jedidjah.
+
+I actually started Jedi back in 2012, because there were no good solutions
+available for VIM. Most auto-completion solutions just did not work well. The
+only good solution was PyCharm. But I liked my good old VIM very much. There
+was also a solution called Rope that did not work at all for me. So I decided
+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 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.
+
+Because of my lack of knowledge, everything after 2012 and before 2020 was
+basically refactoring. I rewrote the core parts of Jedi probably like 5-10
+times. The last big rewrite (that I did twice) was the inclusion of
+gradual typing and stubs.
+
+I learned during that time that it is crucial to have a good understanding of
+your problem. Otherwise you just end up doing it again. I only wrote features
+in the beginning and in the end. Everything else was bugfixing and refactoring.
+However now I am really happy with the result. It works well, bugfixes can be
+quick and is pretty much feature complete.
+
+--------
+
+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:
+
+    *"Oh, that worries me..."*
+
+Now that it is finished, I hope he likes it :-).
+
+.. _contributors:
+
+.. include:: ../../AUTHORS.txt

docs/docs/api-classes.rst

@@ -5,6 +5,49 @@
 API Return Classes
 ------------------
 
-.. automodule:: jedi.api.classes
+Abstract Base Class
+~~~~~~~~~~~~~~~~~~~
+.. autoclass:: jedi.api.classes.BaseName
     :members:
-    :undoc-members:
+    :show-inheritance:
+
+Name
+~~~~
+.. autoclass:: jedi.api.classes.Name
+    :members:
+    :show-inheritance:
+
+Completion
+~~~~~~~~~~
+.. autoclass:: jedi.api.classes.Completion
+    :members:
+    :show-inheritance:
+
+BaseSignature
+~~~~~~~~~~~~~
+.. autoclass:: jedi.api.classes.BaseSignature
+    :members:
+    :show-inheritance:
+
+Signature
+~~~~~~~~~
+.. autoclass:: jedi.api.classes.Signature
+    :members:
+    :show-inheritance:
+
+ParamName
+~~~~~~~~~
+.. autoclass:: jedi.api.classes.ParamName
+    :members:
+    :show-inheritance:
+
+Refactoring
+~~~~~~~~~~~
+
+.. autoclass:: jedi.api.refactoring.Refactoring
+    :members:
+    :show-inheritance:
+
+.. autoclass:: jedi.api.errors.SyntaxError
+    :members:
+    :show-inheritance:

docs/docs/api.rst

@@ -3,58 +3,74 @@
 API Overview
 ============
 
-.. currentmodule:: jedi
-
-Note: This documentation is for Plugin developers, who want to improve their
-editors/IDE autocompletion 
-
-If you want to use |jedi|, you first need to ``import jedi``.  You then have
-direct access to the :class:`.Script`. You can then call the functions
-documented here. These functions return :ref:`API classes
-<api-classes>`.
-
-
-Deprecations
-------------
-
-The deprecation process is as follows:
-
-1. A deprecation is announced in the next major/minor release.
-2. We wait either at least a year & at least two minor releases until we remove
-   the deprecated functionality.
-
-
-API Documentation
------------------
-
-The API consists of a few different parts:
-
-- The main starting points for completions/goto: :class:`.Script` and :class:`.Interpreter`
-- Helpful functions: :func:`.names`, :func:`.preload_module` and
-  :func:`.set_debug_function`
-- :ref:`API Result Classes <api-classes>`
-- :ref:`Python Versions/Virtualenv Support <environments>` with functions like
-  :func:`.find_system_environments` and :func:`.find_virtualenvs`
+.. note:: This documentation is mostly for Plugin developers, who want to
+   improve their editors/IDE with Jedi.
 
 .. _api:
 
-Static Analysis Interface
-~~~~~~~~~~~~~~~~~~~~~~~~~
+The API consists of a few different parts:
 
-.. automodule:: jedi
+- The main starting points for complete/goto: :class:`.Script` and
+  :class:`.Interpreter`. If you work with Jedi you want to understand these
+  classes first.
+- :ref:`API Result Classes <api-classes>`
+- :ref:`Python Versions/Virtualenv Support <environments>` with functions like
+  :func:`.find_system_environments` and :func:`.find_virtualenvs`
+- A way to work with different :ref:`Folders / Projects <projects>`
+- Helpful functions: :func:`.preload_module` and :func:`.set_debug_function`
+
+The methods that you are most likely going to use to work with Jedi are the
+following ones:
+
+.. currentmodule:: jedi
+
+.. autosummary::
+   :nosignatures:
+
+    Script.complete
+    Script.goto
+    Script.infer
+    Script.help
+    Script.get_signatures
+    Script.get_references
+    Script.get_context
+    Script.get_names
+    Script.get_syntax_errors
+    Script.rename
+    Script.inline
+    Script.extract_variable
+    Script.extract_function
+    Script.search
+    Script.complete_search
+    Project.search
+    Project.complete_search
+
+Script
+------
 
 .. autoclass:: jedi.Script
     :members:
+
+Interpreter
+-----------
 .. autoclass:: jedi.Interpreter
     :members:
-.. autofunction:: jedi.names
-.. autofunction:: jedi.preload_module
-.. autofunction:: jedi.set_debug_function
+
+.. _projects:
+
+Projects
+--------
+
+.. automodule:: jedi.api.project
+
+.. autofunction:: jedi.get_default_project
+.. autoclass:: jedi.Project
+    :members:
 
 .. _environments:
 
 Environments
-~~~~~~~~~~~~
+------------
 
 .. automodule:: jedi.api.environment
 
@@ -67,19 +83,32 @@ Environments
 .. autoclass:: jedi.api.environment.Environment
     :members:
 
+Helper Functions
+----------------
+
+.. autofunction:: jedi.preload_module
+.. autofunction:: jedi.set_debug_function
+
+Errors
+------
+
+.. autoexception:: jedi.InternalError
+.. autoexception:: jedi.RefactoringError
+
 Examples
 --------
 
-Completions:
+Completions
+~~~~~~~~~~~
 
 .. sourcecode:: python
 
    >>> import jedi
-   >>> source = '''import json; json.l'''
-   >>> script = jedi.Script(source, 1, 19, '')
+   >>> code = '''import json; json.l'''
+   >>> script = jedi.Script(code, path='example.py')
    >>> script
-   <jedi.api.Script object at 0x2121b10>
-   >>> completions = script.completions()
+   <Script: 'example.py' <SameEnvironment: 3.9.0 in /usr>>
+   >>> completions = script.complete(1, 19)
    >>> completions
    [<Completion: load>, <Completion: loads>]
    >>> completions[1]
@@ -89,12 +118,14 @@ Completions:
    >>> completions[1].name
    'loads'
 
-Definitions / Goto:
+Type Inference / Goto
+~~~~~~~~~~~~~~~~~~~~~
 
 .. sourcecode:: python
 
     >>> import jedi
-    >>> source = '''def my_func():
+    >>> code = '''\
+    ... def my_func():
     ...     print 'called'
     ... 
     ... alias = my_func
@@ -102,31 +133,41 @@ Definitions / Goto:
     ... inception = my_list[2]
     ... 
     ... inception()'''
-    >>> script = jedi.Script(source, 8, 1, '')
+    >>> script = jedi.Script(code)
     >>>
-    >>> script.goto_assignments()
-    [<Definition inception=my_list[2]>]
+    >>> script.goto(8, 1)
+    [<Name full_name='__main__.inception', description='inception = my_list[2]'>]
     >>>
-    >>> script.goto_definitions()
-    [<Definition def my_func>]
+    >>> script.infer(8, 1)
+    [<Name full_name='__main__.my_func', description='def my_func'>]
 
-Related names:
+References
+~~~~~~~~~~
 
 .. sourcecode:: python
 
     >>> import jedi
-    >>> source = '''x = 3
+    >>> code = '''\
+    ... x = 3
     ... if 1 == 2:
     ...     x = 4
     ... else:
     ...     del x'''
-    >>> script = jedi.Script(source, 5, 8, '')
-    >>> rns = script.related_names()
+    >>> script = jedi.Script(code)
+    >>> rns = script.get_references(5, 8)
     >>> rns
-    [<RelatedName x@3,4>, <RelatedName x@1,0>]
-    >>> rns[0].start_pos
-    (3, 4)
-    >>> rns[0].is_keyword
-    False
-    >>> rns[0].text
-    'x'
+    [<Name full_name='__main__.x', description='x = 3'>,
+     <Name full_name='__main__.x', description='x = 4'>,
+     <Name full_name='__main__.x', description='del x'>]
+    >>> rns[1].line
+    3
+    >>> rns[1].column
+    4
+
+Deprecations
+------------
+
+The deprecation process is as follows:
+
+1. A deprecation is announced in any release.
+2. The next major release removes the deprecated functionality.

docs/docs/changelog.rst

@@ -0,0 +1 @@
+.. include:: ../../CHANGELOG.rst

docs/docs/development.rst

@@ -22,16 +22,12 @@ couldn't get rid of complexity. I know that **simple is better than complex**,
 but unfortunately it sometimes requires complex solutions to understand complex
 systems.
 
-Since most of the Jedi internals have been written by me (David Halter), this
-introduction will be written mostly by me, because no one else understands to
-the same level how Jedi works. Actually this is also the reason for exactly this
-part of the documentation. To make multiple people able to edit the Jedi core.
-
-In five chapters I'm trying to describe the internals of |jedi|:
+In six chapters I'm trying to describe the internals of |jedi|:
 
 - :ref:`The Jedi Core <core>`
 - :ref:`Core Extensions <core-extensions>`
 - :ref:`Imports & Modules <imports-modules>`
+- :ref:`Stubs & Annotations <stubs>`
 - :ref:`Caching & Recursions <caching-recursions>`
 - :ref:`Helper modules <dev-helpers>`
 
@@ -47,51 +43,51 @@ The Jedi Core
 The core of Jedi consists of three parts:
 
 - :ref:`Parser <parser>`
-- :ref:`Python code evaluation <evaluate>`
+- :ref:`Python type inference <inference>`
 - :ref:`API <dev-api>`
 
-Most people are probably interested in :ref:`code evaluation <evaluate>`,
+Most people are probably interested in :ref:`type inference <inference>`,
 because that's where all the magic happens. I need to introduce the :ref:`parser
-<parser>` first, because :mod:`jedi.evaluate` uses it extensively.
+<parser>` first, because :mod:`jedi.inference` uses it extensively.
 
 .. _parser:
 
 Parser
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Jedi used to have it's internal parser, however this is now a separate project
+Jedi used to have its internal parser, however this is now a separate project
 and is called `parso <http://parso.readthedocs.io>`_.
 
 The parser creates a syntax tree that |jedi| analyses and tries to understand.
-The grammar that this parsers uses is very similar to the official Python
+The grammar that this parser uses is very similar to the official Python
 `grammar files <https://docs.python.org/3/reference/grammar.html>`_.
 
-.. _evaluate:
+.. _inference:
 
-Evaluation of python code (evaluate/__init__.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Type inference of python code (inference/__init__.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate
+.. automodule:: jedi.inference
 
-Evaluation Contexts (evaluate/base_context.py)
+Inference Values (inference/base_value.py)
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-.. automodule:: jedi.evaluate.base_context
+.. automodule:: jedi.inference.base_value
 
 .. inheritance-diagram::
-   jedi.evaluate.context.instance.TreeInstance
-   jedi.evaluate.context.klass.ClassContext
-   jedi.evaluate.context.function.FunctionContext
-   jedi.evaluate.context.function.FunctionExecutionContext
+   jedi.inference.value.instance.TreeInstance
+   jedi.inference.value.klass.ClassValue
+   jedi.inference.value.function.FunctionValue
+   jedi.inference.value.function.FunctionExecutionContext
    :parts: 1
 
 
 .. _name_resolution:
 
-Name resolution (evaluate/finder.py)
-++++++++++++++++++++++++++++++++++++
+Name resolution (inference/finder.py)
++++++++++++++++++++++++++++++++++++++
 
-.. automodule:: jedi.evaluate.finder
+.. automodule:: jedi.inference.finder
 
 
 .. _dev-api:
@@ -114,7 +110,7 @@ Core Extensions
 Core Extensions is a summary of the following topics:
 
 - :ref:`Iterables & Dynamic Arrays <iterables>`
-- :ref:`Dynamic Parameters <dynamic>`
+- :ref:`Dynamic Parameters <dynamic_params>`
 - :ref:`Docstrings <docstrings>`
 - :ref:`Refactoring <refactoring>`
 
@@ -124,42 +120,42 @@ without some features.
 
 .. _iterables:
 
-Iterables & Dynamic Arrays (evaluate/context/iterable.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Iterables & Dynamic Arrays (inference/value/iterable.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 To understand Python on a deeper level, |jedi| needs to understand some of the
 dynamic features of Python like lists that are filled after creation:
 
-.. automodule:: jedi.evaluate.context.iterable
+.. automodule:: jedi.inference.value.iterable
 
 
-.. _dynamic:
+.. _dynamic_params:
 
-Parameter completion (evaluate/dynamic.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Parameter completion (inference/dynamic_params.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.dynamic
+.. automodule:: jedi.inference.dynamic_params
 
 
 .. _docstrings:
 
-Docstrings (evaluate/docstrings.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Docstrings (inference/docstrings.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.docstrings
+.. automodule:: jedi.inference.docstrings
 
 .. _refactoring:
 
-Refactoring (evaluate/refactoring.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Refactoring (api/refactoring.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.refactoring
+.. automodule:: jedi.api.refactoring
 
 
 .. _imports-modules:
 
 Imports & Modules
--------------------
+-----------------
 
 
 - :ref:`Modules <modules>`
@@ -169,19 +165,25 @@ Imports & Modules
 
 .. _builtin:
 
-Compiled Modules (evaluate/compiled.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Compiled Modules (inference/compiled.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.compiled
+.. automodule:: jedi.inference.compiled
 
 
 .. _imports:
 
-Imports (evaluate/imports.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Imports (inference/imports.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.imports
+.. automodule:: jedi.inference.imports
 
+.. _stubs:
+
+Stubs & Annotations (inference/gradual)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. automodule:: jedi.inference.gradual
 
 .. _caching-recursions:
 
@@ -204,19 +206,14 @@ Caching (cache.py)
 Recursions (recursion.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.recursion
+.. automodule:: jedi.inference.recursion
 
 
 .. _dev-helpers:
 
 Helper Modules
----------------
+--------------
 
 Most other modules are not really central to how Jedi works. They all contain
 relevant code, but you if you understand the modules above, you pretty much
 understand Jedi.
-
-Python 2/3 compatibility (_compatibility.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. automodule:: jedi._compatibility

docs/docs/features.rst

@@ -1,29 +1,30 @@
 .. include:: ../global.rst
 
-Features and Caveats
-====================
+Features and Limitations
+========================
 
-Jedi obviously supports autocompletion. It's also possible to get it working in
-(:ref:`your REPL (IPython, etc.) <repl-completion>`).
+Jedi's main API calls and features are:
 
-Static analysis is also possible by using the command ``jedi.names``.
+- Autocompletion: :meth:`.Script.complete`; It's also possible to get it
+  working in :ref:`your REPL (IPython, etc.) <repl-completion>`
+- Goto/Type Inference: :meth:`.Script.goto` and :meth:`.Script.infer`
+- Static Analysis: :meth:`.Script.get_names` and :meth:`.Script.get_syntax_errors`
+- Refactorings: :meth:`.Script.rename`, :meth:`.Script.inline`,
+  :meth:`.Script.extract_variable` and :meth:`.Script.extract_function`
+- Code Search: :meth:`.Script.search` and :meth:`.Project.search`
 
-Jedi would in theory support refactoring, but we have never publicized it,
-because it's not production ready. If you're interested in helping out here,
-let me know. With the latest parser changes, it should be very easy to actually
-make it work.
+Basic Features
+--------------
 
-
-General Features
-----------------
-
-- Python 2.7 and 3.4+ support
+- Python 3.6+ support
 - Ignores syntax errors and wrong indentation
 - Can deal with complex module / function / class structures
-- Great Virtualenv support
-- Can infer function arguments from sphinx, epydoc and basic numpydoc docstrings,
-  and PEP0484-style type hints (:ref:`type hinting <type-hinting>`)
-- Stub files
+- Great ``virtualenv``/``venv`` support
+- Works great with Python's :ref:`type hinting <type-hinting>`,
+- Understands stub files
+- Can infer function arguments for sphinx, epydoc and basic numpydoc docstrings
+- Is overall a very solid piece of software that has been refined for a long
+  time. Bug reports are very welcome and are usually fixed within a few weeks.
 
 
 Supported Python Features
@@ -38,7 +39,7 @@ Supported Python Features
 - ``*args`` / ``**kwargs``
 - decorators / lambdas / closures
 - generators / iterators
-- some descriptors: property / staticmethod / classmethod
+- descriptors: property / staticmethod / classmethod / custom descriptors
 - some magic methods: ``__call__``, ``__iter__``, ``__next__``, ``__get__``,
   ``__getitem__``, ``__init__``
 - ``list.append()``, ``set.add()``, ``list.extend()``, etc.
@@ -46,191 +47,64 @@ Supported Python Features
 - relative imports
 - ``getattr()`` / ``__getattr__`` / ``__getattribute__``
 - function annotations
-- class decorators (py3k feature, are being ignored too, until I find a use
-  case, that doesn't work with |jedi|)
-- simple/usual ``sys.path`` modifications
+- simple/typical ``sys.path`` modifications
 - ``isinstance`` checks for if/while/assert
 - namespace packages (includes ``pkgutil``, ``pkg_resources`` and PEP420 namespaces)
 - Django / Flask / Buildout support
+- Understands Pytest fixtures
 
 
-Not Supported
--------------
+Limitations
+-----------
 
-Not yet implemented:
+In general Jedi's limit is quite high, but for very big projects or very
+complex code, sometimes Jedi intentionally stops type inference, to avoid
+hanging for a long time.
 
-- manipulations of instances outside the instance variables without using
-  methods
+Additionally there are some Python patterns Jedi does not support. This is
+intentional and below should be a complete list:
 
-Will probably never be implemented:
-
-- metaclasses (how could an auto-completion ever support this)
+- Arbitrary metaclasses: Some metaclasses like enums and dataclasses are
+  reimplemented in Jedi to make them work. Most of the time stubs are good
+  enough to get type inference working, even when metaclasses are involved.
 - ``setattr()``, ``__import__()``
-- writing to some dicts: ``globals()``, ``locals()``, ``object.__dict__``
-- evaluating ``if`` / ``while`` / ``del``
+- Writing to some dicts: ``globals()``, ``locals()``, ``object.__dict__``
+- Manipulations of instances outside the instance variables without using
+  methods 
 
-
-Caveats
--------
-
-**Slow Performance**
+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 write import
-hooks in |jedi|, which preload stuff. However, once loaded, this is not a
-problem anymore.  The same is true for huge modules like ``PySide``, ``wx``,
-etc.
+builtins the first time. If you want to speed things up, you could preload
+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.
 
-**Security**
+Jedi does not have a very good cache layer. This is probably the biggest and
+only architectural `issue <https://github.com/davidhalter/jedi/issues/1059>`_ in
+Jedi. Unfortunately it is not easy to change that. Dave Halter is thinking
+about rewriting Jedi in Rust, but it has taken Jedi more than 8 years to reach
+version 1.0, a rewrite will probably also take years.
 
-Security is an important issue for |jedi|. Therefore no Python code is
-executed.  As long as you write pure Python, everything is evaluated
-statically. But: If you use builtin modules (``c_builtin``) there is no other
-option than to execute those modules. However: Execute isn't that critical (as
-e.g. in pythoncomplete, which used to execute *every* import!), because it
-means one import and no more.  So basically the only dangerous thing is using
-the import itself. If your ``c_builtin`` uses some strange initializations, it
-might be dangerous. But if it does you're screwed anyways, because eventually
-you're going to execute your code, which executes the import.
+Security
+--------
 
+For :class:`.Script`
+~~~~~~~~~~~~~~~~~~~~
 
-Recipes
--------
+Security is an important topic for |jedi|. By default, no code is executed
+within Jedi. As long as you write pure Python, everything is inferred
+statically. If you enable ``load_unsafe_extensions=True`` for your
+:class:`.Project` and you use builtin modules (``c_builtin``) Jedi will execute
+those modules. If you don't trust a code base, please do not enable that
+option. It might lead to arbitrary code execution.
 
-Here are some tips on how to use |jedi| efficiently.
+For :class:`.Interpreter`
+~~~~~~~~~~~~~~~~~~~~~~~~~
 
-
-.. _type-hinting:
-
-Type Hinting
-~~~~~~~~~~~~
-
-If |jedi| cannot detect the type of a function argument correctly (due to the
-dynamic nature of Python), you can help it by hinting the type using
-one of the following docstring/annotation syntax styles:
-
-**PEP-0484 style**
-
-https://www.python.org/dev/peps/pep-0484/
-
-function annotations
-
-::
-
-    def myfunction(node: ProgramNode, foo: str) -> None:
-        """Do something with a ``node``.
-
-        """
-        node.| # complete here
-
-
-assignment, for-loop and with-statement type hints (all Python versions).
-Note that the type hints must be on the same line as the statement
-
-::
-
-    x = foo()  # type: int
-    x, y = 2, 3  # type: typing.Optional[int], typing.Union[int, str] # typing module is mostly supported
-    for key, value in foo.items():  # type: str, Employee  # note that Employee must be in scope
-        pass
-    with foo() as f:  # type: int
-        print(f + 3)
-
-Most of the features in PEP-0484 are supported including the typing module
-(for Python < 3.5 you have to do ``pip install typing`` to use these),
-and forward references.
-
-You can also use stub files.
-
-
-**Sphinx style**
-
-http://www.sphinx-doc.org/en/stable/domains.html#info-field-lists
-
-::
-
-    def myfunction(node, foo):
-        """Do something with a ``node``.
-
-        :type node: ProgramNode
-        :param str foo: foo parameter description
-
-        """
-        node.| # complete here
-
-**Epydoc**
-
-http://epydoc.sourceforge.net/manual-fields.html
-
-::
-
-    def myfunction(node):
-        """Do something with a ``node``.
-
-        @type node: ProgramNode
-
-        """
-        node.| # complete here
-
-**Numpydoc**
-
-https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt
-
-In order to support the numpydoc format, you need to install the `numpydoc
-<https://pypi.python.org/pypi/numpydoc>`__ package.
-
-::
-
-    def foo(var1, var2, long_var_name='hi'):
-        r"""A one-line summary that does not use variable names or the
-        function name.
-
-        ...
-
-        Parameters
-        ----------
-        var1 : array_like
-            Array_like means all those objects -- lists, nested lists,
-            etc. -- that can be converted to an array. We can also
-            refer to variables like `var1`.
-        var2 : int
-            The type above can either refer to an actual Python type
-            (e.g. ``int``), or describe the type of the variable in more
-            detail, e.g. ``(N,) ndarray`` or ``array_like``.
-        long_variable_name : {'hi', 'ho'}, optional
-            Choices in brackets, default first when optional.
-
-        ...
-
-        """
-        var2.| # complete here
-
-A little history
-----------------
-
-The Star Wars Jedi are awesome. My Jedi software tries to imitate a little bit
-of the precognition the Jedi have. There's even an awesome `scene
-<https://youtu.be/yHRJLIf7wMU>`_ of Monty Python Jedis :-).
-
-But actually the name hasn't so much to do with Star Wars. It's part of my
-second name.
-
-After I explained Guido van Rossum, how some parts of my auto-completion work,
-he said (we drank a beer or two):
-
-    *"Oh, that worries me..."*
-
-When it's finished, I hope he'll like it :-)
-
-I actually started Jedi, because there were no good solutions available for VIM.
-Most auto-completions just didn't work well. The only good solution was PyCharm.
-But I like my good old VIM. Rope was never really intended to be an
-auto-completion (and also I really hate project folders for my Python scripts).
-It's more of a refactoring suite. So I decided to do my own version of a
-completion, which would execute non-dangerous code. But I soon realized, that
-this wouldn't work. So I built an extremely recursive thing which understands
-many of Python's key features.
-
-By the way, I really tried to program it as understandable as possible. But I
-think understanding it might need quite some time, because of its recursive
-nature.
+If you want security for :class:`.Interpreter`, ``do not`` use it. Jedi does
+execute properties and in general is not very careful to avoid code execution.
+This is intentional: Most people trust the code bases they have imported,
+because at that point a malicious code base would have had code execution
+already.

docs/docs/installation.rst

@@ -3,6 +3,15 @@
 Installation and Configuration
 ==============================
 
+.. warning:: Most people will want to install Jedi as a submodule/vendored and
+   not through pip/system wide. The reason for this is that it makes sense that
+   the plugin that uses Jedi has always access to it. Otherwise Jedi will not
+   work properly when virtualenvs are activated. So please read the
+   documentation of your editor/IDE plugin to install Jedi.
+
+   For plugin developers, Jedi works best if it is always available. Vendoring
+   is a pretty good option for that.
+
 You can either include |jedi| as a submodule in your text editor plugin (like
 jedi-vim_ does by default), or you can install it systemwide.
 
@@ -41,14 +50,6 @@ Arch Linux
 You can install |jedi| directly from official Arch Linux packages:
 
 - `python-jedi <https://www.archlinux.org/packages/community/any/python-jedi/>`__
-  (Python 3)
-- `python2-jedi <https://www.archlinux.org/packages/community/any/python2-jedi/>`__
-  (Python 2)
-
-The specified Python version just refers to the *runtime environment* for
-|jedi|. Use the Python 2 version if you're running vim (or whatever editor you
-use) under Python 2. Otherwise, use the Python 3 version. But whatever version
-you choose, both are able to complete both Python 2 and 3 *code*.
 
 (There is also a packaged version of the vim plugin available: 
 `vim-jedi at Arch Linux <https://www.archlinux.org/packages/community/any/vim-jedi/>`__.)

docs/docs/testing.rst

@@ -3,21 +3,17 @@
 Jedi Testing
 ============
 
-The test suite depends on ``tox`` and ``pytest``::
+The test suite depends on ``pytest``::
 
-    pip install tox pytest
+    pip install pytest
 
-To run the tests for all supported Python versions::
-
-    tox
-
-If you want to test only a specific Python version (e.g. Python 2.7), it's as
+If you want to test only a specific Python version (e.g. Python 3.8), it is as
 easy as::
 
-    tox -e py27
+    python3.8 -m pytest
 
-Tests are also run automatically on `Travis CI
-<https://travis-ci.org/davidhalter/jedi/>`_.
+Tests are also run automatically on `GitHub Actions
+<https://github.com/davidhalter/jedi/actions>`_.
 
 You want to add a test for |jedi|? Great! We love that. Normally you should
 write your tests as :ref:`Blackbox Tests <blackbox>`. Most tests would
@@ -28,8 +24,8 @@ simple and readable testing structure.
 
 .. _blackbox:
 
-Blackbox Tests (run.py)
-~~~~~~~~~~~~~~~~~~~~~~~
+Integration Tests (run.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: test.run
 

docs/docs/usage.rst

@@ -1,79 +1,109 @@
 .. include:: ../global.rst
 
-End User Usage
-==============
+Using Jedi
+==========
 
-If you are a not an IDE Developer, the odds are that you just want to use
-|jedi| as a browser plugin or in the shell. Yes that's :ref:`also possible
-<repl-completion>`!
+|jedi| is can be used with a variety of :ref:`plugins <editor-plugins>`,
+: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>`.
 
-|jedi| is relatively young and can be used in a variety of Plugins and
-Software. If your Editor/IDE is not among them, recommend |jedi| to your IDE
-developers.
+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>`_ (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:
 
 Editor Plugins
 --------------
 
-Vim:
+Vim
+~~~
 
 - jedi-vim_
 - YouCompleteMe_
 - deoplete-jedi_
 
-Emacs:
+Visual Studio Code
+~~~~~~~~~~~~~~~~~~
+
+- `Python Extension`_
+
+Emacs
+~~~~~
 
 - Jedi.el_
 - elpy_
 - anaconda-mode_
 
-Sublime Text 2/3:
+Sublime Text 2/3
+~~~~~~~~~~~~~~~~
 
 - SublimeJEDI_ (ST2 & ST3)
 - anaconda_ (only ST3)
 
-SynWrite:
+SynWrite
+~~~~~~~~
 
 - SynJedi_
 
-TextMate:
+TextMate
+~~~~~~~~
 
 - Textmate_ (Not sure if it's actually working)
 
-Kate:
+Kate
+~~~~
 
 - Kate_ version 4.13+ `supports it natively
   <https://projects.kde.org/projects/kde/applications/kate/repository/entry/addons/kate/pate/src/plugins/python_autocomplete_jedi.py?rev=KDE%2F4.13>`__,
   you have to enable it, though.
 
-Visual Studio Code:
-
-- `Python Extension`_
-
-Atom:
+Atom
+~~~~
 
 - autocomplete-python-jedi_
 
-GNOME Builder:
+GNOME Builder
+~~~~~~~~~~~~~
 
 - `GNOME Builder`_ `supports it natively
   <https://git.gnome.org/browse/gnome-builder/tree/plugins/jedi>`__,
   and is enabled by default.
 
-Gedit:
+Gedit
+~~~~~
 
 - gedi_
 
-Eric IDE:
+Eric IDE
+~~~~~~~~
 
-- `Eric IDE`_ (Available as a plugin)
+- `Eric IDE`_
 
-Web Debugger:
+Web Debugger
+~~~~~~~~~~~~
 
 - wdb_
 
+xonsh shell
+~~~~~~~~~~~
+
+Jedi is a preinstalled extension in `xonsh shell <https://xon.sh/contents.html>`_. 
+Run the following command to enable:
+
+::
+
+    xontrib load jedi
+
 and many more!
 
 .. _repl-completion:
@@ -81,11 +111,14 @@ and many more!
 Tab Completion in the Python Shell
 ----------------------------------
 
-Starting with Ipython `6.0.0` Jedi is a dependency of IPython. Autocompletion
-in IPython is therefore possible without additional configuration.
+Jedi is a dependency of IPython. Autocompletion in IPython is therefore
+possible without additional configuration.
+
+Here is an `example video <https://vimeo.com/122332037>`_ how REPL completion
+can look like in a different shell.
 
 There are two different options how you can use Jedi autocompletion in
-your Python interpreter. One with your custom ``$HOME/.pythonrc.py`` file
+your ``python`` interpreter. One with your custom ``$HOME/.pythonrc.py`` file
 and one that uses ``PYTHONSTARTUP``.
 
 Using ``PYTHONSTARTUP``
@@ -93,11 +126,137 @@ Using ``PYTHONSTARTUP``
 
 .. automodule:: jedi.api.replstartup
 
-Using a custom ``$HOME/.pythonrc.py``
+Using a Custom ``$HOME/.pythonrc.py``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. autofunction:: jedi.utils.setup_readline
 
+.. _recipes:
+
+Recipes
+-------
+
+Here are some tips on how to use |jedi| efficiently.
+
+
+.. _type-hinting:
+
+Type Hinting
+~~~~~~~~~~~~
+
+If |jedi| cannot detect the type of a function argument correctly (due to the
+dynamic nature of Python), you can help it by hinting the type using
+one of the docstring/annotation styles below. **Only gradual typing will
+always work**, all the docstring solutions are glorified hacks and more
+complicated cases will probably not work.
+
+Official Gradual Typing (Recommended)
++++++++++++++++++++++++++++++++++++++
+
+You can read a lot about Python's gradual typing system in the corresponding
+PEPs like:
+
+- `PEP 484 <https://www.python.org/dev/peps/pep-0484/>`_ as an introduction
+- `PEP 526 <https://www.python.org/dev/peps/pep-0526/>`_ for variable annotations
+- `PEP 589 <https://www.python.org/dev/peps/pep-0589/>`_ for ``TypeDict``
+- There are probably more :)
+
+Below you can find a few examples how you can use this feature.
+
+Function annotations::
+
+    def myfunction(node: ProgramNode, foo: str) -> None:
+        """Do something with a ``node``.
+
+        """
+        node.| # complete here
+
+
+Assignment, for-loop and with-statement type hints::
+
+    import typing
+    x: int = foo()
+    y: typing.Optional[int] = 3
+
+    key: str
+    value: Employee
+    for key, value in foo.items():
+        pass
+
+    f: Union[int, float]
+    with foo() as f:
+        print(f + 3)
+
+PEP-0484 should be supported in its entirety. Feel free to open issues if that
+is not the case. You can also use stub files.
+
+
+Sphinx style
+++++++++++++
+
+http://www.sphinx-doc.org/en/stable/domains.html#info-field-lists
+
+::
+
+    def myfunction(node, foo):
+        """
+        Do something with a ``node``.
+
+        :type node: ProgramNode
+        :param str foo: foo parameter description
+        """
+        node.| # complete here
+
+Epydoc
+++++++
+
+http://epydoc.sourceforge.net/manual-fields.html
+
+::
+
+    def myfunction(node):
+        """
+        Do something with a ``node``.
+
+        @type node: ProgramNode
+        """
+        node.| # complete here
+
+Numpydoc
+++++++++
+
+https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt
+
+In order to support the numpydoc format, you need to install the `numpydoc
+<https://pypi.python.org/pypi/numpydoc>`__ package.
+
+::
+
+    def foo(var1, var2, long_var_name='hi'):
+        r"""
+        A one-line summary that does not use variable names or the
+        function name.
+
+        ...
+
+        Parameters
+        ----------
+        var1 : array_like
+            Array_like means all those objects -- lists, nested lists,
+            etc. -- that can be converted to an array. We can also
+            refer to variables like `var1`.
+        var2 : int
+            The type above can either refer to an actual Python type
+            (e.g. ``int``), or describe the type of the variable in more
+            detail, e.g. ``(N,) ndarray`` or ``array_like``.
+        long_variable_name : {'hi', 'ho'}, optional
+            Choices in brackets, default first when optional.
+
+        ...
+
+        """
+        var2.| # complete here
+
 .. _jedi-vim: https://github.com/davidhalter/jedi-vim
 .. _youcompleteme: https://valloric.github.io/YouCompleteMe/
 .. _deoplete-jedi: https://github.com/zchee/deoplete-jedi
@@ -114,4 +273,4 @@ Using a custom ``$HOME/.pythonrc.py``
 .. _GNOME Builder: https://wiki.gnome.org/Apps/Builder/
 .. _gedi: https://github.com/isamert/gedi
 .. _Eric IDE: https://eric-ide.python-projects.org
-.. _Python Extension: https://marketplace.visualstudio.com/items?itemName=donjayamanne.python
+.. _Python Extension: https://marketplace.visualstudio.com/items?itemName=ms-python.python

docs/global.rst

@@ -1,3 +1,3 @@
 :orphan:
 
-.. |jedi| replace:: *Jedi*
+.. |jedi| replace:: Jedi

docs/index.rst

@@ -1,13 +1,40 @@
 .. include global.rst
 
-Jedi - an awesome autocompletion/static analysis library for Python
-===================================================================
+.. meta::
+    :github_url: https://github.com/davidhalter/jedi
 
-Release v\ |release|. (:doc:`Installation <docs/installation>`)
+Jedi - an awesome autocompletion, static analysis and refactoring library for Python
+====================================================================================
+
+.. image:: https://img.shields.io/github/stars/davidhalter/jedi.svg?style=social&label=Star&maxAge=2592000
+    :target: https://github.com/davidhalter/jedi
+    :alt: GitHub stars
+
+.. 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
+
+.. image:: http://isitmaintained.com/badge/resolution/davidhalter/jedi.svg
+    :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
+    :target: https://github.com/davidhalter/jedi/actions
+    :alt: Tests
+
+.. image:: https://coveralls.io/repos/davidhalter/jedi/badge.svg?branch=master
+    :target: https://coveralls.io/r/davidhalter/jedi
+    :alt: Coverage status
+
+.. image:: https://pepy.tech/badge/jedi
+    :target: https://pepy.tech/project/jedi
+    :alt: PyPI Downloads
+
+`Github Repository <https://github.com/davidhalter/jedi>`_
 
 .. automodule:: jedi
 
-Autocompletion can look like this (e.g. VIM plugin):
+Autocompletion can for example look like this in jedi-vim:
 
 .. figure:: _screenshots/screenshot_complete.png
 
@@ -18,16 +45,18 @@ Docs
 ----
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
 
    docs/usage
-   docs/installation
    docs/features
    docs/api
    docs/api-classes
+   docs/installation
    docs/settings
    docs/development
    docs/testing
+   docs/acknowledgements
+   docs/changelog
 
 
 .. _resources:
@@ -35,6 +64,9 @@ Docs
 Resources
 ---------
 
+If you want to stay **up-to-date** with releases, please **subscribe** to this
+mailing list: https://groups.google.com/g/jedi-announce. To subscribe you can
+simply send an empty email to ``jedi-announce+subscribe@googlegroups.com``.
+
 - `Source Code on Github <https://github.com/davidhalter/jedi>`_
-- `Travis Testing <https://travis-ci.org/davidhalter/jedi>`_
 - `Python Package Index <https://pypi.python.org/pypi/jedi/>`_

jedi/__init__.py

@@ -1,16 +1,13 @@
 """
-Jedi is a static analysis tool for Python that can be used in IDEs/editors.
-Jedi has a focus on autocompletion and goto functionality. Jedi is fast and is
-very well tested. It understands Python and stubs on a deep level.
+Jedi is a static analysis tool for Python that is typically used in
+IDEs/editors plugins. Jedi has a focus on autocompletion and goto
+functionality. Other features include refactoring, code search and finding
+references.
 
-Jedi has support for different goto functions. It's possible to search for
-usages and list names in a Python file to get information about them.
-
-Jedi uses a very simple API to connect with IDE's. There's a reference
-implementation as a `VIM-Plugin <https://github.com/davidhalter/jedi-vim>`_,
-which uses Jedi's autocompletion.  We encourage you to use Jedi in your IDEs.
-Autocompletion in your REPL is also possible, IPython uses it natively and for
-the CPython REPL you have to install it.
+Jedi has a simple API to work with. There is a reference implementation as a
+`VIM-Plugin <https://github.com/davidhalter/jedi-vim>`_. Autocompletion in your
+REPL is also possible, IPython uses it natively and for the CPython REPL you
+can install it. Jedi is well tested and bugs should be rare.
 
 Here's a simple example of the autocompletion feature:
 
@@ -18,30 +15,28 @@ Here's a simple example of the autocompletion feature:
 >>> source = '''
 ... import json
 ... json.lo'''
->>> script = jedi.Script(source, 3, len('json.lo'), 'example.py')
+>>> script = jedi.Script(source, path='example.py')
 >>> script
 <Script: 'example.py' ...>
->>> completions = script.completions()
+>>> completions = script.complete(3, len('json.lo'))
 >>> completions
 [<Completion: load>, <Completion: loads>]
 >>> print(completions[0].complete)
 ad
 >>> print(completions[0].name)
 load
-
-As you see Jedi is pretty simple and allows you to concentrate on writing a
-good text editor, while still having very good IDE features for Python.
 """
 
-__version__ = '0.15.1'
+__version__ = '0.19.1'
 
-from jedi.api import Script, Interpreter, set_debug_function, \
-    preload_module, names
+from jedi.api import Script, Interpreter, set_debug_function, preload_module
 from jedi import settings
 from jedi.api.environment import find_virtualenvs, find_system_environments, \
     get_default_environment, InvalidPythonEnvironment, create_environment, \
-    get_system_environment
-from jedi.api.exceptions import InternalError
+    get_system_environment, InterpreterEnvironment
+from jedi.api.project import Project, get_default_project
+from jedi.api.exceptions import InternalError, RefactoringError
+
 # Finally load the internal plugins. This is only internal.
 from jedi.plugins import registry
 del registry

jedi/__main__.py

@@ -27,8 +27,8 @@ def _start_linter():
             paths = [path]
 
         try:
-            for path in paths:
-                for error in jedi.Script(path=path)._analysis():
+            for p in paths:
+                for error in jedi.Script(path=p)._analysis():
                     print(error)
         except Exception:
             if '--pdb' in sys.argv:
@@ -40,9 +40,33 @@ def _start_linter():
                 raise
 
 
+def _complete():
+    import jedi
+    import pdb
+
+    if '-d' in sys.argv:
+        sys.argv.remove('-d')
+        jedi.set_debug_function()
+
+    try:
+        completions = jedi.Script(sys.argv[2]).complete()
+        for c in completions:
+            c.docstring()
+            c.type
+    except Exception as e:
+        print(repr(e))
+        pdb.post_mortem()
+    else:
+        print(completions)
+
+
 if len(sys.argv) == 2 and sys.argv[1] == 'repl':
     # don't want to use __main__ only for repl yet, maybe we want to use it for
     # something else. So just use the keyword ``repl`` for now.
     print(join(dirname(abspath(__file__)), 'api', 'replstartup.py'))
-elif len(sys.argv) > 1 and sys.argv[1] == 'linter':
+elif len(sys.argv) > 1 and sys.argv[1] == '_linter':
     _start_linter()
+elif len(sys.argv) > 1 and sys.argv[1] == '_complete':
+    _complete()
+else:
+    print('Command not implemented: %s' % sys.argv[1])

jedi/_compatibility.py

@@ -1,482 +1,28 @@
 """
-To ensure compatibility from Python ``2.7`` - ``3.x``, a module has been
-created. Clearly there is huge need to use conforming syntax.
+This module is here to ensure compatibility of Windows/Linux/MacOS and
+different Python versions.
 """
-from __future__ import print_function
-import atexit
 import errno
-import functools
 import sys
-import os
-import re
-import pkgutil
-import warnings
-import inspect
-import subprocess
-import weakref
-try:
-    import importlib
-except ImportError:
-    pass
-from zipimport import zipimporter
-
-from jedi.file_io import KnownContentFileIO, ZipFileIO
-
-is_py3 = sys.version_info[0] >= 3
-is_py35 = is_py3 and sys.version_info[1] >= 5
-py_version = int(str(sys.version_info[0]) + str(sys.version_info[1]))
-
-
-class DummyFile(object):
-    def __init__(self, loader, string):
-        self.loader = loader
-        self.string = string
-
-    def read(self):
-        return self.loader.get_source(self.string)
-
-    def close(self):
-        del self.loader
-
-
-def find_module_py34(string, path=None, full_name=None, is_global_search=True):
-    spec = None
-    loader = None
-
-    for finder in sys.meta_path:
-        if is_global_search and finder != importlib.machinery.PathFinder:
-            p = None
-        else:
-            p = path
-        try:
-            find_spec = finder.find_spec
-        except AttributeError:
-            # These are old-school clases that still have a different API, just
-            # ignore those.
-            continue
-
-        spec = find_spec(string, p)
-        if spec is not None:
-            loader = spec.loader
-            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)
-                return implicit_ns_info, True
-            break
-
-    return find_module_py33(string, path, loader)
-
-
-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 loader is None and path is None:  # Fallback to find builtins
-        try:
-            with warnings.catch_warnings(record=True):
-                # Mute "DeprecationWarning: Use importlib.util.find_spec()
-                # instead." While we should replace that in the future, it's
-                # 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.
-            raise ImportError("Originally  " + repr(e))
-
-    if loader is None:
-        raise ImportError("Couldn't find a loader for {}".format(string))
-
-    return _from_loader(loader, string)
-
-
-def _from_loader(loader, string):
-    is_package = loader.is_package(string)
-    try:
-        get_filename = loader.get_filename
-    except AttributeError:
-        return None, is_package
-    else:
-        module_path = cast_path(get_filename(string))
-
-    # To avoid unicode and read bytes, "overwrite" loader.get_source if
-    # possible.
-    f = type(loader).get_source
-    if is_py3 and f is not importlib.machinery.SourceFileLoader.get_source:
-        # Unfortunately we are reading unicode here, not bytes.
-        # It seems hard to get bytes, because the zip importer
-        # logic just unpacks the zip file and returns a file descriptor
-        # that we cannot as easily access. Therefore we just read it as
-        # a string in the cases where get_source was overwritten.
-        code = loader.get_source(string)
-    else:
-        code = _get_source(loader, string)
-
-    if code is None:
-        return None, is_package
-    if isinstance(loader, zipimporter):
-        return ZipFileIO(module_path, code, cast_path(loader.archive)), is_package
-
-    return KnownContentFileIO(module_path, code), is_package
-
-
-def _get_source(loader, fullname):
-    """
-    This method is here as a replacement for SourceLoader.get_source. That
-    method returns unicode, but we prefer bytes.
-    """
-    path = loader.get_filename(fullname)
-    try:
-        return loader.get_data(path)
-    except OSError:
-        raise ImportError('source not available through get_data()',
-                          name=fullname)
-
-
-def find_module_pre_py3(string, path=None, full_name=None, is_global_search=True):
-    # This import is here, because in other places it will raise a
-    # DeprecationWarning.
-    import imp
-    try:
-        module_file, module_path, description = imp.find_module(string, path)
-        module_type = description[2]
-        is_package = module_type is imp.PKG_DIRECTORY
-        if is_package:
-            # In Python 2 directory package imports are returned as folder
-            # paths, not __init__.py paths.
-            p = os.path.join(module_path, '__init__.py')
-            try:
-                module_file = open(p)
-                module_path = p
-            except FileNotFoundError:
-                pass
-        elif module_type != imp.PY_SOURCE:
-            if module_file is not None:
-                module_file.close()
-            module_file = None
-
-        if module_file is None:
-            code = None
-            return None, is_package
-
-        with module_file:
-            code = module_file.read()
-        return KnownContentFileIO(cast_path(module_path), code), is_package
-    except ImportError:
-        pass
-
-    if path is None:
-        path = sys.path
-    for item in path:
-        loader = pkgutil.get_importer(item)
-        if loader:
-            loader = loader.find_module(string)
-            if loader is not None:
-                return _from_loader(loader, string)
-    raise ImportError("No module named {}".format(string))
-
-
-find_module = find_module_py34 if is_py3 else find_module_pre_py3
-find_module.__doc__ = """
-Provides information about a module.
-
-This function isolates the differences in importing libraries introduced with
-python 3.3 on; it gets a module name and optionally a path. It will return a
-tuple containin an open file for the module (if not builtin), the filename
-or the name of the module if it is a builtin one and a boolean indicating
-if the module is contained in a package.
-"""
-
-
-def _iter_modules(paths, prefix=''):
-    # Copy of pkgutil.iter_modules adapted to work with namespaces
-
-    for path in paths:
-        importer = pkgutil.get_importer(path)
-
-        if not isinstance(importer, importlib.machinery.FileFinder):
-            # We're only modifying the case for FileFinder. All the other cases
-            # still need to be checked (like zip-importing). Do this by just
-            # calling the pkgutil version.
-            for mod_info in pkgutil.iter_modules([path], prefix):
-                yield mod_info
-            continue
-
-        # START COPY OF pkutils._iter_file_finder_modules.
-        if importer.path is None or not os.path.isdir(importer.path):
-            return
-
-        yielded = {}
-
-        try:
-            filenames = os.listdir(importer.path)
-        except OSError:
-            # ignore unreadable directories like import does
-            filenames = []
-        filenames.sort()  # handle packages before same-named modules
-
-        for fn in filenames:
-            modname = inspect.getmodulename(fn)
-            if modname == '__init__' or modname in yielded:
-                continue
-
-            # jedi addition: Avoid traversing special directories
-            if fn.startswith('.') or fn == '__pycache__':
-                continue
-
-            path = os.path.join(importer.path, fn)
-            ispkg = False
-
-            if not modname and os.path.isdir(path) and '.' not in fn:
-                modname = fn
-                # A few jedi modifications: Don't check if there's an
-                # __init__.py
-                try:
-                    os.listdir(path)
-                except OSError:
-                    # ignore unreadable directories like import does
-                    continue
-                ispkg = True
-
-            if modname and '.' not in modname:
-                yielded[modname] = 1
-                yield importer, prefix + modname, ispkg
-        # END COPY
-
-
-iter_modules = _iter_modules if py_version >= 34 else pkgutil.iter_modules
-
-
-class ImplicitNSInfo(object):
-    """Stores information returned from an implicit namespace spec"""
-    def __init__(self, name, paths):
-        self.name = name
-        self.paths = paths
-
-
-if is_py3:
-    all_suffixes = importlib.machinery.all_suffixes
-else:
-    def all_suffixes():
-        # Is deprecated and raises a warning in Python 3.6.
-        import imp
-        return [suffix for suffix, _, _ in imp.get_suffixes()]
-
-
-# unicode function
-try:
-    unicode = unicode
-except NameError:
-    unicode = str
-
-
-# re-raise function
-if is_py3:
-    def reraise(exception, traceback):
-        raise exception.with_traceback(traceback)
-else:
-    eval(compile("""
-def reraise(exception, traceback):
-    raise exception, None, traceback
-""", 'blub', 'exec'))
-
-reraise.__doc__ = """
-Re-raise `exception` with a `traceback` object.
-
-Usage::
-
-    reraise(Exception, sys.exc_info()[2])
-
-"""
-
-
-def use_metaclass(meta, *bases):
-    """ Create a class with a metaclass. """
-    if not bases:
-        bases = (object,)
-    return meta("Py2CompatibilityMetaClass", bases, {})
-
-
-try:
-    encoding = sys.stdout.encoding
-    if encoding is None:
-        encoding = 'utf-8'
-except AttributeError:
-    encoding = 'ascii'
-
-
-def u(string, errors='strict'):
-    """Cast to unicode DAMMIT!
-    Written because Python2 repr always implicitly casts to a string, so we
-    have to cast back to a unicode (and we now that we always deal with valid
-    unicode, because we check that in the beginning).
-    """
-    if isinstance(string, bytes):
-        return unicode(string, encoding='UTF-8', errors=errors)
-    return string
-
-
-def cast_path(obj):
-    """
-    Take a bytes or str path and cast it to unicode.
-
-    Apparently it is perfectly fine to pass both byte and unicode objects into
-    the sys.path. This probably means that byte paths are normal at other
-    places as well.
-
-    Since this just really complicates everything and Python 2.7 will be EOL
-    soon anyway, just go with always strings.
-    """
-    return u(obj, errors='replace')
-
-
-def force_unicode(obj):
-    # Intentionally don't mix those two up, because those two code paths might
-    # be different in the future (maybe windows?).
-    return cast_path(obj)
-
-
-try:
-    import builtins  # module name in python 3
-except ImportError:
-    import __builtin__ as builtins  # noqa: F401
-
-
-import ast  # noqa: F401
-
-
-def literal_eval(string):
-    return ast.literal_eval(string)
-
-
-try:
-    from itertools import zip_longest
-except ImportError:
-    from itertools import izip_longest as zip_longest  # Python 2  # noqa: F401
-
-try:
-    FileNotFoundError = FileNotFoundError
-except NameError:
-    FileNotFoundError = IOError
-
-try:
-    IsADirectoryError = IsADirectoryError
-except NameError:
-    IsADirectoryError = IOError
-
-try:
-    PermissionError = PermissionError
-except NameError:
-    PermissionError = IOError
-
-
-def no_unicode_pprint(dct):
-    """
-    Python 2/3 dict __repr__ may be different, because of unicode differens
-    (with or without a `u` prefix). Normally in doctests we could use `pprint`
-    to sort dicts and check for equality, but here we have to write a separate
-    function to do that.
-    """
-    import pprint
-    s = pprint.pformat(dct)
-    print(re.sub("u'", "'", s))
-
-
-def utf8_repr(func):
-    """
-    ``__repr__`` methods in Python 2 don't allow unicode objects to be
-    returned. Therefore cast them to utf-8 bytes in this decorator.
-    """
-    def wrapper(self):
-        result = func(self)
-        if isinstance(result, unicode):
-            return result.encode('utf-8')
-        else:
-            return result
-
-    if is_py3:
-        return func
-    else:
-        return wrapper
-
-
-if is_py3:
-    import queue
-else:
-    import Queue as queue  # noqa: F401
-
-try:
-    # Attempt to load the C implementation of pickle on Python 2 as it is way
-    # faster.
-    import cPickle as pickle
-except ImportError:
-    import pickle
-if sys.version_info[:2] == (3, 3):
-    """
-    Monkeypatch the unpickler in Python 3.3. This is needed, because the
-    argument `encoding='bytes'` is not supported in 3.3, but badly needed to
-    communicate with Python 2.
-    """
-
-    class NewUnpickler(pickle._Unpickler):
-        dispatch = dict(pickle._Unpickler.dispatch)
-
-        def _decode_string(self, value):
-            # Used to allow strings from Python 2 to be decoded either as
-            # bytes or Unicode strings.  This should be used only with the
-            # STRING, BINSTRING and SHORT_BINSTRING opcodes.
-            if self.encoding == "bytes":
-                return value
-            else:
-                return value.decode(self.encoding, self.errors)
-
-        def load_string(self):
-            data = self.readline()[:-1]
-            # Strip outermost quotes
-            if len(data) >= 2 and data[0] == data[-1] and data[0] in b'"\'':
-                data = data[1:-1]
-            else:
-                raise pickle.UnpicklingError("the STRING opcode argument must be quoted")
-            self.append(self._decode_string(pickle.codecs.escape_decode(data)[0]))
-        dispatch[pickle.STRING[0]] = load_string
-
-        def load_binstring(self):
-            # Deprecated BINSTRING uses signed 32-bit length
-            len, = pickle.struct.unpack('<i', self.read(4))
-            if len < 0:
-                raise pickle.UnpicklingError("BINSTRING pickle has negative byte count")
-            data = self.read(len)
-            self.append(self._decode_string(data))
-        dispatch[pickle.BINSTRING[0]] = load_binstring
-
-        def load_short_binstring(self):
-            len = self.read(1)[0]
-            data = self.read(len)
-            self.append(self._decode_string(data))
-        dispatch[pickle.SHORT_BINSTRING[0]] = load_short_binstring
-
-    def load(file, fix_imports=True, encoding="ASCII", errors="strict"):
-        return NewUnpickler(file, fix_imports=fix_imports,
-                            encoding=encoding, errors=errors).load()
-
-    def loads(s, fix_imports=True, encoding="ASCII", errors="strict"):
-        if isinstance(s, str):
-            raise TypeError("Can't load pickle from unicode string")
-        file = pickle.io.BytesIO(s)
-        return NewUnpickler(file, fix_imports=fix_imports,
-                            encoding=encoding, errors=errors).load()
-
-    pickle.Unpickler = NewUnpickler
-    pickle.load = load
-    pickle.loads = loads
+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:
-        if is_py3:
-            return pickle.load(file, encoding='bytes')
-        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:
@@ -485,24 +31,8 @@ def pickle_load(file):
         raise
 
 
-def _python2_dct_keys_to_unicode(data):
-    """
-    Python 2 stores object __dict__ entries as bytes, not unicode, correct it
-    here. Python 2 can deal with both, Python 3 expects unicode.
-    """
-    if isinstance(data, tuple):
-        return tuple(_python2_dct_keys_to_unicode(x) for x in data)
-    elif isinstance(data, list):
-        return list(_python2_dct_keys_to_unicode(x) for x in data)
-    elif hasattr(data, '__dict__') and type(data.__dict__) == dict:
-        data.__dict__ = {unicode(k): v for k, v in data.__dict__.items()}
-    return data
-
-
 def pickle_dump(data, file, protocol):
     try:
-        if not is_py3:
-            data = _python2_dct_keys_to_unicode(data)
         pickle.dump(data, file, protocol)
         # On Python 3.3 flush throws sometimes an error even though the writing
         # operation should be completed.
@@ -513,153 +43,3 @@ def pickle_dump(data, file, protocol):
         if sys.platform == 'win32':
             raise IOError(errno.EPIPE, "Broken pipe")
         raise
-
-
-# Determine the highest protocol version compatible for a given list of Python
-# versions.
-def highest_pickle_protocol(python_versions):
-    protocol = 4
-    for version in python_versions:
-        if version[0] == 2:
-            # The minimum protocol version for the versions of Python that we
-            # support (2.7 and 3.3+) is 2.
-            return 2
-        if version[1] < 4:
-            protocol = 3
-    return protocol
-
-
-try:
-    from inspect import Parameter
-except ImportError:
-    class Parameter(object):
-        POSITIONAL_ONLY = object()
-        POSITIONAL_OR_KEYWORD = object()
-        VAR_POSITIONAL = object()
-        KEYWORD_ONLY = object()
-        VAR_KEYWORD = object()
-
-
-class GeneralizedPopen(subprocess.Popen):
-    def __init__(self, *args, **kwargs):
-        if os.name == 'nt':
-            try:
-                # Was introduced in Python 3.7.
-                CREATE_NO_WINDOW = subprocess.CREATE_NO_WINDOW
-            except AttributeError:
-                CREATE_NO_WINDOW = 0x08000000
-            kwargs['creationflags'] = CREATE_NO_WINDOW
-        # The child process doesn't need file descriptors except 0, 1, 2.
-        # This is unix only.
-        kwargs['close_fds'] = 'posix' in sys.builtin_module_names
-        super(GeneralizedPopen, self).__init__(*args, **kwargs)
-
-
-# shutil.which is not available on Python 2.7.
-def which(cmd, mode=os.F_OK | os.X_OK, path=None):
-    """Given a command, mode, and a PATH string, return the path which
-    conforms to the given mode on the PATH, or None if there is no such
-    file.
-
-    `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
-    of os.environ.get("PATH"), or can be overridden with a custom search
-    path.
-
-    """
-    # Check that a given file can be accessed with the correct mode.
-    # Additionally check that `file` is not a directory, as on Windows
-    # directories pass the os.access check.
-    def _access_check(fn, mode):
-        return (os.path.exists(fn) and os.access(fn, mode)
-                and not os.path.isdir(fn))
-
-    # If we're given a path with a directory part, look it up directly rather
-    # than referring to PATH directories. This includes checking relative to the
-    # current directory, e.g. ./script
-    if os.path.dirname(cmd):
-        if _access_check(cmd, mode):
-            return cmd
-        return None
-
-    if path is None:
-        path = os.environ.get("PATH", os.defpath)
-    if not path:
-        return None
-    path = path.split(os.pathsep)
-
-    if sys.platform == "win32":
-        # The current directory takes precedence on Windows.
-        if os.curdir not in path:
-            path.insert(0, os.curdir)
-
-        # PATHEXT is necessary to check on Windows.
-        pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
-        # See if the given file matches any of the expected path extensions.
-        # This will allow us to short circuit when given "python.exe".
-        # If it does match, only test that one, otherwise we have to try
-        # others.
-        if any(cmd.lower().endswith(ext.lower()) for ext in pathext):
-            files = [cmd]
-        else:
-            files = [cmd + ext for ext in pathext]
-    else:
-        # On other platforms you don't have things like PATHEXT to tell you
-        # what file suffixes are executable, so just pass on cmd as-is.
-        files = [cmd]
-
-    seen = set()
-    for dir in path:
-        normdir = os.path.normcase(dir)
-        if normdir not in seen:
-            seen.add(normdir)
-            for thefile in files:
-                name = os.path.join(dir, thefile)
-                if _access_check(name, mode):
-                    return name
-    return None
-
-
-if not is_py3:
-    # Simplified backport of Python 3 weakref.finalize:
-    # https://github.com/python/cpython/blob/ded4737989316653469763230036b04513cb62b3/Lib/weakref.py#L502-L662
-    class finalize(object):
-        """Class for finalization of weakrefable objects.
-
-        finalize(obj, func, *args, **kwargs) returns a callable finalizer
-        object which will be called when obj is garbage collected. The
-        first time the finalizer is called it evaluates func(*arg, **kwargs)
-        and returns the result. After this the finalizer is dead, and
-        calling it just returns None.
-
-        When the program exits any remaining finalizers will be run.
-        """
-
-        # Finalizer objects don't have any state of their own.
-        # This ensures that they cannot be part of a ref-cycle.
-        __slots__ = ()
-        _registry = {}
-
-        def __init__(self, obj, func, *args, **kwargs):
-            info = functools.partial(func, *args, **kwargs)
-            info.weakref = weakref.ref(obj, self)
-            self._registry[self] = info
-
-        def __call__(self):
-            """Return func(*args, **kwargs) if alive."""
-            info = self._registry.pop(self, None)
-            if info:
-                return info()
-
-        @classmethod
-        def _exitfunc(cls):
-            if not cls._registry:
-                return
-            for finalizer in list(cls._registry):
-                try:
-                    finalizer()
-                except Exception:
-                    sys.excepthook(*sys.exc_info())
-                assert finalizer not in cls._registry
-
-    atexit.register(finalize._exitfunc)
-    weakref.finalize = finalize

jedi/api/completion.py

@@ -1,79 +1,112 @@
 import re
+from textwrap import dedent
+from inspect import Parameter
 
 from parso.python.token import PythonTokenTypes
 from parso.python import tree
 from parso.tree import search_ancestor, Leaf
+from parso import split_lines
 
-from jedi._compatibility import Parameter
 from jedi import debug
 from jedi import settings
 from jedi.api import classes
 from jedi.api import helpers
 from jedi.api import keywords
-from jedi.api.file_name import file_name_completions
-from jedi.evaluate import imports
-from jedi.evaluate.helpers import evaluate_call_of_leaf, parse_dotted_names
-from jedi.evaluate.filters import get_global_filters
-from jedi.evaluate.gradual.conversion import convert_contexts
-from jedi.parser_utils import get_statement_of_position, cut_value_at_position
+from jedi.api.strings import complete_dict
+from jedi.api.file_name import complete_file_name
+from jedi.inference import imports
+from jedi.inference.base_value import ValueSet
+from jedi.inference.helpers import infer_call_of_leaf, parse_dotted_names
+from jedi.inference.context import get_global_filters
+from jedi.inference.value import TreeInstance
+from jedi.inference.docstring_utils import DocstringModule
+from jedi.inference.names import ParamNameWrapper, SubModuleName
+from jedi.inference.gradual.conversion import convert_values, convert_names
+from jedi.parser_utils import cut_value_at_position
+from jedi.plugins import plugin_manager
 
 
-def get_call_signature_param_names(call_signatures):
-    # add named params
-    for call_sig in call_signatures:
-        for p in call_sig.params:
-            # Allow protected access, because it's a public API.
-            if p._name.get_kind() in (Parameter.POSITIONAL_OR_KEYWORD,
-                                      Parameter.KEYWORD_ONLY):
-                yield p._name
+class ParamNameWithEquals(ParamNameWrapper):
+    def get_public_name(self):
+        return self.string_name + '='
 
 
-def filter_names(evaluator, completion_names, stack, like_name):
-    comp_dct = {}
+def _get_signature_param_names(signatures, positional_count, used_kwargs):
+    # Add named params
+    for call_sig in signatures:
+        for i, p in enumerate(call_sig.params):
+            kind = p.kind
+            if i < positional_count and kind == Parameter.POSITIONAL_OR_KEYWORD:
+                continue
+            if kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY) \
+                    and p.name not in used_kwargs:
+                yield ParamNameWithEquals(p._name)
+
+
+def _must_be_kwarg(signatures, positional_count, used_kwargs):
+    if used_kwargs:
+        return True
+
+    must_be_kwarg = True
+    for signature in signatures:
+        for i, p in enumerate(signature.params):
+            kind = p.kind
+            if kind is Parameter.VAR_POSITIONAL:
+                # In case there were not already kwargs, the next param can
+                # always be a normal argument.
+                return False
+
+            if i >= positional_count and kind in (Parameter.POSITIONAL_OR_KEYWORD,
+                                                  Parameter.POSITIONAL_ONLY):
+                must_be_kwarg = False
+                break
+        if not must_be_kwarg:
+            break
+    return must_be_kwarg
+
+
+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 string.startswith(like_name):
+        if helpers.match(string, like_name, fuzzy=fuzzy):
             new = classes.Completion(
-                evaluator,
+                inference_state,
                 name,
                 stack,
-                len(like_name)
+                len(like_name),
+                is_fuzzy=fuzzy,
+                cached_name=cached_name,
             )
             k = (new.name, new.complete)  # key
-            if k in comp_dct and settings.no_completion_duplicates:
-                comp_dct[k]._same_name_completions.append(new)
-            else:
-                comp_dct[k] = new
+            if k not in comp_dct:
+                comp_dct.add(k)
+                tree_name = name.tree_name
+                if tree_name is not None:
+                    definition = tree_name.get_definition()
+                    if definition is not None and definition.type == 'del_stmt':
+                        continue
                 yield new
 
 
-def get_user_scope(module_context, position):
+def _remove_duplicates(completions, other_completions):
+    names = {d.name for d in other_completions}
+    return [c for c in completions if c.name not in names]
+
+
+def get_user_context(module_context, position):
     """
     Returns the scope in which the user resides. This includes flows.
     """
-    user_stmt = get_statement_of_position(module_context.tree_node, position)
-    if user_stmt is None:
-        def scan(scope):
-            for s in scope.children:
-                if s.start_pos <= position <= s.end_pos:
-                    if isinstance(s, (tree.Scope, tree.Flow)) \
-                            or s.type in ('async_stmt', 'async_funcdef'):
-                        return scan(s) or s
-                    elif s.type in ('suite', 'decorated'):
-                        return scan(s)
-            return None
-
-        scanned_node = scan(module_context.tree_node)
-        if scanned_node:
-            return module_context.create_context(scanned_node, node_is_context=True)
-        return module_context
-    else:
-        return module_context.create_context(user_stmt)
+    leaf = module_context.tree_node.get_leaf_for_position(position, include_prefixes=True)
+    return module_context.create_context(leaf)
 
 
 def get_flow_scope_node(module_node, position):
@@ -84,11 +117,19 @@ def get_flow_scope_node(module_node, position):
     return node
 
 
+@plugin_manager.decorate()
+def complete_param_names(context, function_name, decorator_nodes):
+    # Basically there's no way to do param completion. The plugins are
+    # responsible for this.
+    return []
+
+
 class Completion:
-    def __init__(self, evaluator, module, code_lines, position, call_signatures_callback):
-        self._evaluator = evaluator
-        self._module_context = module
-        self._module_node = module.tree_node
+    def __init__(self, inference_state, module_context, code_lines, position,
+                 signatures_callback, fuzzy=False):
+        self._inference_state = inference_state
+        self._module_context = module_context
+        self._module_node = module_context.tree_node
         self._code_lines = code_lines
 
         # The first step of completions is to get the name
@@ -96,33 +137,66 @@ class Completion:
         # The actual cursor position is not what we need to calculate
         # everything. We want the start of the name we're on.
         self._original_position = position
-        self._position = position[0], position[1] - len(self._like_name)
-        self._call_signatures_callback = call_signatures_callback
+        self._signatures_callback = signatures_callback
 
-    def completions(self):
-        leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True)
-        string, start_leaf = _extract_string_while_in_string(leaf, self._position)
-        if string is not None:
-            completions = list(file_name_completions(
-                self._evaluator, self._module_context, start_leaf, string,
-                self._like_name, self._call_signatures_callback,
-                self._code_lines, self._original_position
+        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,
+            include_prefixes=True
+        )
+        string, start_leaf, quote = _extract_string_while_in_string(leaf, self._original_position)
+
+        prefixed_completions = complete_dict(
+            self._module_context,
+            self._code_lines,
+            start_leaf or leaf,
+            self._original_position,
+            None if string is None else quote + string,
+            fuzzy=self._fuzzy,
+        )
+
+        if string is not None and not prefixed_completions:
+            prefixed_completions = list(complete_file_name(
+                self._inference_state, self._module_context, start_leaf, quote, string,
+                self._like_name, self._signatures_callback,
+                self._code_lines, self._original_position,
+                self._fuzzy
             ))
-            if completions:
-                return completions
+        if string is not None:
+            if not prefixed_completions and '\n' in string:
+                # Complete only multi line strings
+                prefixed_completions = self._complete_in_string(start_leaf, string)
+            return prefixed_completions
 
-        completion_names = self._get_context_completions(leaf)
+        cached_name, completion_names = self._complete_python(leaf)
 
-        completions = filter_names(self._evaluator, completion_names,
-                                   self.stack, self._like_name)
+        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))
 
-        return sorted(completions, key=lambda x: (x.name.startswith('__'),
-                                                  x.name.startswith('_'),
-                                                  x.name.lower()))
+        completions = list(filter_names(self._inference_state, completion_names,
+                                        self.stack, self._like_name,
+                                        self._fuzzy, imported_names, cached_name=cached_name))
 
-    def _get_context_completions(self, leaf):
+        return (
+            # Removing duplicates mostly to remove False/True/None duplicates.
+            _remove_duplicates(prefixed_completions, completions)
+            + sorted(completions, key=lambda x: (not x.name.startswith(self._like_name),
+                                                 x.name.startswith('__'),
+                                                 x.name.startswith('_'),
+                                                 x.name.lower()))
+        )
+
+    def _complete_python(self, leaf):
         """
-        Analyzes the context that a completion is made in and decides what to
+        Analyzes the current context of a completion and decides what to
         return.
 
         Technically this works by generating a parser stack and analysing the
@@ -134,9 +208,13 @@ class Completion:
         - In args: */**: no completion
         - In params (also lambda): no completion before =
         """
-
-        grammar = self._evaluator.grammar
+        grammar = self._inference_state.grammar
         self.stack = stack = None
+        self._position = (
+            self._original_position[0],
+            self._original_position[1] - len(self._like_name)
+        )
+        cached_name = None
 
         try:
             self.stack = stack = helpers.get_stack_at_position(
@@ -147,10 +225,10 @@ class Completion:
             if value == '.':
                 # After ErrorLeaf's that are dots, we will not do any
                 # completions since this probably just confuses the user.
-                return []
+                return cached_name, []
 
-            # If we don't have a context, just use global completion.
-            return self._global_completions()
+            # If we don't have a value, just use global completion.
+            return cached_name, self._complete_global_scope()
 
         allowed_transitions = \
             list(stack._allowed_transition_names_and_token_types())
@@ -188,27 +266,19 @@ class Completion:
                             allowed_transitions.append('else')
 
         completion_names = []
-        current_line = self._code_lines[self._position[0] - 1][:self._position[1]]
-        if not current_line or current_line[-1] in ' \t.;':
-            completion_names += self._get_keyword_completion_names(allowed_transitions)
 
+        kwargs_only = False
         if any(t in allowed_transitions for t in (PythonTokenTypes.NAME,
                                                   PythonTokenTypes.INDENT)):
             # This means that we actually have to do type inference.
 
             nonterminals = [stack_node.nonterminal for stack_node in stack]
 
-            nodes = []
-            for stack_node in stack:
-                if stack_node.dfa.from_rule == 'small_stmt':
-                    nodes = []
-                else:
-                    nodes += stack_node.nodes
-
+            nodes = _gather_nodes(stack)
             if nodes and nodes[-1] in ('as', 'def', 'class'):
                 # No completions for ``with x as foo`` and ``import x as foo``.
                 # Also true for defining names as a class or function.
-                return list(self._get_class_context_completions(is_function=True))
+                return cached_name, list(self._complete_inherited(is_function=True))
             elif "import_stmt" in nonterminals:
                 level, names = parse_dotted_names(nodes, "import_from" in nonterminals)
 
@@ -220,84 +290,153 @@ class Completion:
                 )
             elif nonterminals[-1] in ('trailer', 'dotted_name') and nodes[-1] == '.':
                 dot = self._module_node.get_leaf_for_position(self._position)
-                completion_names += self._trailer_completions(dot.get_previous_leaf())
+                if dot.type == "endmarker":
+                    # This is a bit of a weird edge case, maybe we can somehow
+                    # generalize this.
+                    dot = leaf.get_previous_leaf()
+                cached_name, n = self._complete_trailer(dot.get_previous_leaf())
+                completion_names += n
+            elif self._is_parameter_completion():
+                completion_names += self._complete_params(leaf)
             else:
-                completion_names += self._global_completions()
-                completion_names += self._get_class_context_completions(is_function=False)
+                # Apparently this looks like it's good enough to filter most cases
+                # so that signature completions don't randomly appear.
+                # To understand why this works, three things are important:
+                # 1. trailer with a `,` in it is either a subscript or an arglist.
+                # 2. If there's no `,`, it's at the start and only signatures start
+                #    with `(`. Other trailers could start with `.` or `[`.
+                # 3. Decorators are very primitive and have an optional `(` with
+                #    optional arglist in them.
+                if nodes[-1] in ['(', ','] \
+                        and nonterminals[-1] in ('trailer', 'arglist', 'decorator'):
+                    signatures = self._signatures_callback(*self._position)
+                    if signatures:
+                        call_details = signatures[0]._call_details
+                        used_kwargs = list(call_details.iter_used_keyword_arguments())
+                        positional_count = call_details.count_positional_arguments()
 
-            if 'trailer' in nonterminals:
-                call_signatures = self._call_signatures_callback()
-                completion_names += get_call_signature_param_names(call_signatures)
+                        completion_names += _get_signature_param_names(
+                            signatures,
+                            positional_count,
+                            used_kwargs,
+                        )
 
-        return completion_names
+                        kwargs_only = _must_be_kwarg(signatures, positional_count, used_kwargs)
 
-    def _get_keyword_completion_names(self, allowed_transitions):
+                if not kwargs_only:
+                    completion_names += self._complete_global_scope()
+                    completion_names += self._complete_inherited(is_function=False)
+
+        if not kwargs_only:
+            current_line = self._code_lines[self._position[0] - 1][:self._position[1]]
+            completion_names += self._complete_keywords(
+                allowed_transitions,
+                only_values=not (not current_line or current_line[-1] in ' \t.;'
+                                 and current_line[-3:] != '...')
+            )
+
+        return cached_name, completion_names
+
+    def _is_parameter_completion(self):
+        tos = self.stack[-1]
+        if tos.nonterminal == 'lambdef' and len(tos.nodes) == 1:
+            # We are at the position `lambda `, where basically the next node
+            # is a param.
+            return True
+        if tos.nonterminal in 'parameters':
+            # Basically we are at the position `foo(`, there's nothing there
+            # yet, so we have no `typedargslist`.
+            return True
+        # var args is for lambdas and typed args for normal functions
+        return tos.nonterminal in ('typedargslist', 'varargslist') and tos.nodes[-1] == ','
+
+    def _complete_params(self, leaf):
+        stack_node = self.stack[-2]
+        if stack_node.nonterminal == 'parameters':
+            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')
+            if node is not None:
+                if node.type == 'error_node':
+                    n = node.children[0]
+                    if n.type == 'decorators':
+                        decorators = n.children
+                    elif n.type == 'decorator':
+                        decorators = [n]
+                    else:
+                        decorators = []
+                else:
+                    decorators = node.get_decorators()
+                function_name = stack_node.nodes[1]
+
+                return complete_param_names(context, function_name.value, decorators)
+        return []
+
+    def _complete_keywords(self, allowed_transitions, only_values):
         for k in allowed_transitions:
             if isinstance(k, str) and k.isalpha():
-                yield keywords.KeywordName(self._evaluator, k)
+                if not only_values or k in ('True', 'False', 'None'):
+                    yield keywords.KeywordName(self._inference_state, k)
 
-    def _global_completions(self):
-        context = get_user_scope(self._module_context, self._position)
+    def _complete_global_scope(self):
+        context = get_user_context(self._module_context, self._position)
         debug.dbg('global completion scope: %s', context)
         flow_scope_node = get_flow_scope_node(self._module_node, self._position)
         filters = get_global_filters(
-            self._evaluator,
             context,
             self._position,
-            origin_scope=flow_scope_node
+            flow_scope_node
         )
         completion_names = []
         for filter in filters:
             completion_names += filter.values()
         return completion_names
 
-    def _trailer_completions(self, previous_leaf):
-        user_context = get_user_scope(self._module_context, self._position)
-        evaluation_context = self._evaluator.create_context(
-            self._module_context, previous_leaf
-        )
-        contexts = evaluate_call_of_leaf(evaluation_context, previous_leaf)
-        completion_names = []
-        debug.dbg('trailer completion contexts: %s', contexts, color='MAGENTA')
-        for context in contexts:
-            for filter in context.get_filters(
-                    search_global=False,
-                    origin_scope=user_context.tree_node):
-                completion_names += filter.values()
+    def _complete_trailer(self, previous_leaf):
+        inferred_context = self._module_context.create_context(previous_leaf)
+        values = infer_call_of_leaf(inferred_context, previous_leaf)
+        debug.dbg('trailer completion values: %s', values, color='MAGENTA')
 
-        python_contexts = convert_contexts(contexts)
-        for c in python_contexts:
-            if c not in contexts:
-                for filter in c.get_filters(
-                        search_global=False,
-                        origin_scope=user_context.tree_node):
-                    completion_names += filter.values()
-        return completion_names
+        # The cached name simply exists to make speed optimizations for certain
+        # modules.
+        cached_name = None
+        if len(values) == 1:
+            v, = values
+            if v.is_module():
+                if len(v.string_names) == 1:
+                    module_name = v.string_names[0]
+                    if module_name in ('numpy', 'tensorflow', 'matplotlib', 'pandas'):
+                        cached_name = module_name
+
+        return cached_name, self._complete_trailer_for_values(values)
+
+    def _complete_trailer_for_values(self, values):
+        user_context = get_user_context(self._module_context, self._position)
+
+        return complete_trailer(user_context, values)
 
     def _get_importer_names(self, names, level=0, only_modules=True):
         names = [n.value for n in names]
-        i = imports.Importer(self._evaluator, names, self._module_context, level)
-        return i.completion_names(self._evaluator, only_modules=only_modules)
+        i = imports.Importer(self._inference_state, names, self._module_context, level)
+        return i.completion_names(self._inference_state, only_modules=only_modules)
 
-    def _get_class_context_completions(self, is_function=True):
+    def _complete_inherited(self, is_function=True):
         """
         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')
-        if isinstance(cls, (tree.Class, tree.Function)):
-            # Complete the methods that are defined in the super classes.
-            random_context = self._module_context.create_context(
-                cls,
-                node_is_context=True
-            )
-        else:
+        if cls is None:
             return
 
+        # Complete the methods that are defined in the super classes.
+        class_value = self._module_context.create_value(cls)
+
         if cls.start_pos[1] >= leaf.start_pos[1]:
             return
 
-        filters = random_context.get_filters(search_global=False, is_instance=True)
+        filters = class_value.get_filters(is_instance=True)
         # The first dict is the dictionary of class itself.
         next(filters)
         for filter in filters:
@@ -306,21 +445,248 @@ class Completion:
                 if (name.api_type == 'function') == is_function:
                     yield name
 
+    def _complete_in_string(self, start_leaf, string):
+        """
+        To make it possible for people to have completions in doctests or
+        generally in "Python" code in docstrings, we use the following
+        heuristic:
+
+        - Having an indented block of code
+        - 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:
+                if include_next_line or l.startswith('>>>') or l.startswith(' '):
+                    yield re.sub(r'^( *>>> ?| +)', '', l)
+                else:
+                    yield None
+
+                include_next_line = bool(re.match(' *>>>', l))
+
+        string = dedent(string)
+        code_lines = split_lines(string, keepends=True)
+        relevant_code_lines = list(iter_relevant_lines(code_lines))
+        if relevant_code_lines[-1] is not None:
+            # Some code lines might be None, therefore get rid of that.
+            relevant_code_lines = ['\n' if c is None else c for c in relevant_code_lines]
+            return self._complete_code_lines(relevant_code_lines)
+        match = re.search(r'`([^`\s]+)', code_lines[-1])
+        if match:
+            return self._complete_code_lines([match.group(1)])
+        return []
+
+    def _complete_code_lines(self, code_lines):
+        module_node = self._inference_state.grammar.parse(''.join(code_lines))
+        module_value = DocstringModule(
+            in_module_context=self._module_context,
+            inference_state=self._inference_state,
+            module_node=module_node,
+            code_lines=code_lines,
+        )
+        return Completion(
+            self._inference_state,
+            module_value.as_context(),
+            code_lines=code_lines,
+            position=module_node.end_pos,
+            signatures_callback=lambda *args, **kwargs: [],
+            fuzzy=self._fuzzy
+        ).complete()
+
+
+def _gather_nodes(stack):
+    nodes = []
+    for stack_node in stack:
+        if stack_node.dfa.from_rule == 'small_stmt':
+            nodes = []
+        else:
+            nodes += stack_node.nodes
+    return nodes
+
+
+_string_start = re.compile(r'^\w*(\'{3}|"{3}|\'|")')
+
 
 def _extract_string_while_in_string(leaf, position):
-    if leaf.type == 'string':
-        match = re.match(r'^\w*(\'{3}|"{3}|\'|")', leaf.value)
-        quote = match.group(1)
+    def return_part_of_leaf(leaf):
+        kwargs = {}
+        if leaf.line == position[0]:
+            kwargs['endpos'] = position[1] - leaf.column
+        match = _string_start.match(leaf.value, **kwargs)
+        if not match:
+            return None, None, None
+        start = match.group(0)
         if leaf.line == position[0] and position[1] < leaf.column + match.end():
-            return None, None
-        if leaf.end_pos[0] == position[0] and position[1] > leaf.end_pos[1] - len(quote):
-            return None, None
-        return cut_value_at_position(leaf, position)[match.end():], leaf
+            return None, None, None
+        return cut_value_at_position(leaf, position)[match.end():], leaf, start
+
+    if position < leaf.start_pos:
+        return None, None, None
+
+    if leaf.type == 'string':
+        return return_part_of_leaf(leaf)
 
     leaves = []
-    while leaf is not None and leaf.line == position[0]:
+    while leaf is not None:
         if leaf.type == 'error_leaf' and ('"' in leaf.value or "'" in leaf.value):
-            return ''.join(l.get_code() for l in leaves), leaf
+            if len(leaf.value) > 1:
+                return return_part_of_leaf(leaf)
+            prefix_leaf = None
+            if not leaf.prefix:
+                prefix_leaf = leaf.get_previous_leaf()
+                if prefix_leaf is None or prefix_leaf.type != 'name' \
+                        or not all(c in 'rubf' for c in prefix_leaf.value.lower()):
+                    prefix_leaf = None
+
+            return (
+                ''.join(cut_value_at_position(l, position) for l in leaves),
+                prefix_leaf or leaf,
+                ('' if prefix_leaf is None else prefix_leaf.value)
+                + cut_value_at_position(leaf, position),
+            )
+        if leaf.line != position[0]:
+            # Multi line strings are always simple error leaves and contain the
+            # whole string, single line error leaves are atherefore important
+            # now and since the line is different, it's not really a single
+            # line string anymore.
+            break
         leaves.insert(0, leaf)
         leaf = leaf.get_previous_leaf()
-    return None, None
+    return None, None, None
+
+
+def complete_trailer(user_context, values):
+    completion_names = []
+    for value in values:
+        for filter in value.get_filters(origin_scope=user_context.tree_node):
+            completion_names += filter.values()
+
+        if not value.is_stub() and isinstance(value, TreeInstance):
+            completion_names += _complete_getattr(user_context, value)
+
+    python_values = convert_values(values)
+    for c in python_values:
+        if c not in values:
+            for filter in c.get_filters(origin_scope=user_context.tree_node):
+                completion_names += filter.values()
+    return completion_names
+
+
+def _complete_getattr(user_context, instance):
+    """
+    A heuristic to make completion for proxy objects work. This is not
+    intended to work in all cases. It works exactly in this case:
+
+        def __getattr__(self, name):
+            ...
+            return getattr(any_object, name)
+
+    It is important that the return contains getattr directly, otherwise it
+    won't work anymore. It's really just a stupid heuristic. It will not
+    work if you write e.g. `return (getatr(o, name))`, because of the
+    additional parentheses. It will also not work if you move the getattr
+    to some other place that is not the return statement itself.
+
+    It is intentional that it doesn't work in all cases. Generally it's
+    really hard to do even this case (as you can see below). Most people
+    will write it like this anyway and the other ones, well they are just
+    out of luck I guess :) ~dave.
+    """
+    names = (instance.get_function_slot_names('__getattr__')
+             or instance.get_function_slot_names('__getattribute__'))
+    functions = ValueSet.from_sets(
+        name.infer()
+        for name in names
+    )
+    for func in functions:
+        tree_node = func.tree_node
+        if tree_node is None or tree_node.type != 'funcdef':
+            continue
+
+        for return_stmt in tree_node.iter_return_stmts():
+            # Basically until the next comment we just try to find out if a
+            # return statement looks exactly like `return getattr(x, name)`.
+            if return_stmt.type != 'return_stmt':
+                continue
+            atom_expr = return_stmt.children[1]
+            if atom_expr.type != 'atom_expr':
+                continue
+            atom = atom_expr.children[0]
+            trailer = atom_expr.children[1]
+            if len(atom_expr.children) != 2 or atom.type != 'name' \
+                    or atom.value != 'getattr':
+                continue
+            arglist = trailer.children[1]
+            if arglist.type != 'arglist' or len(arglist.children) < 3:
+                continue
+            context = func.as_context()
+            object_node = arglist.children[0]
+
+            # Make sure it's a param: foo in __getattr__(self, foo)
+            name_node = arglist.children[2]
+            name_list = context.goto(name_node, name_node.start_pos)
+            if not any(n.api_type == 'param' for n in name_list):
+                continue
+
+            # Now that we know that these are most probably completion
+            # objects, we just infer the object and return them as
+            # completions.
+            objects = context.infer_node(object_node)
+            return complete_trailer(user_context, objects)
+    return []
+
+
+def search_in_module(inference_state, module_context, names, wanted_names,
+                     wanted_type, complete=False, fuzzy=False,
+                     ignore_imports=False, convert=False):
+    for s in wanted_names[:-1]:
+        new_names = []
+        for n in names:
+            if s == n.string_name:
+                if n.tree_name is not None and n.api_type in ('module', 'namespace') \
+                        and ignore_imports:
+                    continue
+                new_names += complete_trailer(
+                    module_context,
+                    n.infer()
+                )
+        debug.dbg('dot lookup on search %s from %s', new_names, names[:10])
+        names = new_names
+
+    last_name = wanted_names[-1].lower()
+    for n in names:
+        string = n.string_name.lower()
+        if complete and helpers.match(string, last_name, fuzzy=fuzzy) \
+                or not complete and string == last_name:
+            if isinstance(n, SubModuleName):
+                names = [v.name for v in n.infer()]
+            else:
+                names = [n]
+            if convert:
+                names = convert_names(names)
+            for n2 in names:
+                if complete:
+                    def_ = classes.Completion(
+                        inference_state, n2,
+                        stack=None,
+                        like_name_length=len(last_name),
+                        is_fuzzy=fuzzy,
+                    )
+                else:
+                    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', 'import_as_name']:
+        for child in node.children:
+            if child.type == 'name':
+                imported_names.append(child.value)
+            elif child.type == 'import_as_name':
+                imported_names.extend(extract_imported_names(child))
+
+    return imported_names

jedi/api/completion_cache.py

@@ -0,0 +1,31 @@
+from typing import Dict, Tuple, Callable
+
+CacheValues = Tuple[str, str, str]
+CacheValuesCallback = Callable[[], CacheValues]
+
+
+_cache: Dict[str, Dict[str, CacheValues]] = {}
+
+
+def save_entry(module_name: str, name: str, cache: CacheValues) -> None:
+    try:
+        module_cache = _cache[module_name]
+    except KeyError:
+        module_cache = _cache[module_name] = {}
+    module_cache[name] = cache
+
+
+def _create_get_from_cache(number: int) -> Callable[[str, str, CacheValuesCallback], str]:
+    def _get_from_cache(module_name: str, name: str, get_cache_values: CacheValuesCallback) -> str:
+        try:
+            return _cache[module_name][name][number]
+        except KeyError:
+            v = get_cache_values()
+            save_entry(module_name, name, v)
+            return v[number]
+    return _get_from_cache
+
+
+get_type = _create_get_from_cache(0)
+get_docstring_signature = _create_get_from_cache(1)
+get_docstring = _create_get_from_cache(2)

jedi/api/environment.py

@@ -7,18 +7,24 @@ import sys
 import hashlib
 import filecmp
 from collections import namedtuple
+from shutil import which
+from typing import TYPE_CHECKING
 
-from jedi._compatibility import highest_pickle_protocol, which
 from jedi.cache import memoize_method, time_cache
-from jedi.evaluate.compiled.subprocess import CompiledSubprocess, \
-    EvaluatorSameProcess, EvaluatorSubprocess
+from jedi.inference.compiled.subprocess import CompiledSubprocess, \
+    InferenceStateSameProcess, InferenceStateSubprocess
 
 import parso
 
-_VersionInfo = namedtuple('VersionInfo', 'major minor micro')
+if TYPE_CHECKING:
+    from jedi.inference import InferenceState
 
-_SUPPORTED_PYTHONS = ['3.8', '3.7', '3.6', '3.5', '3.4', '2.7']
+
+_VersionInfo = namedtuple('VersionInfo', 'major minor micro')  # type: ignore[name-match]
+
+_SUPPORTED_PYTHONS = ['3.13', '3.12', '3.11', '3.10', '3.9', '3.8', '3.7', '3.6']
 _SAFE_PATHS = ['/usr/bin', '/usr/local/bin']
+_CONDA_VAR = 'CONDA_PREFIX'
 _CURRENT_VERSION = '%s.%s' % (sys.version_info.major, sys.version_info.minor)
 
 
@@ -29,7 +35,7 @@ class InvalidPythonEnvironment(Exception):
     """
 
 
-class _BaseEnvironment(object):
+class _BaseEnvironment:
     @memoize_method
     def get_grammar(self):
         version_string = '%s.%s' % (self.version_info.major, self.version_info.minor)
@@ -60,8 +66,9 @@ class Environment(_BaseEnvironment):
     """
     _subprocess = None
 
-    def __init__(self, executable):
+    def __init__(self, executable, env_vars=None):
         self._start_executable = executable
+        self._env_vars = env_vars
         # Initialize the environment
         self._get_subprocess()
 
@@ -70,7 +77,8 @@ class Environment(_BaseEnvironment):
             return self._subprocess
 
         try:
-            self._subprocess = CompiledSubprocess(self._start_executable)
+            self._subprocess = CompiledSubprocess(self._start_executable,
+                                                  env_vars=self._env_vars)
             info = self._subprocess._send(None, _get_info)
         except Exception as exc:
             raise InvalidPythonEnvironment(
@@ -90,33 +98,26 @@ class Environment(_BaseEnvironment):
         """
         self.version_info = _VersionInfo(*info[2])
         """
-        Like ``sys.version_info``. A tuple to show the current Environment's
-        Python version.
+        Like :data:`sys.version_info`: a tuple to show the current
+        Environment's Python version.
         """
-
-        # py2 sends bytes via pickle apparently?!
-        if self.version_info.major == 2:
-            self.executable = self.executable.decode()
-            self.path = self.path.decode()
-
-        # Adjust pickle protocol according to host and client version.
-        self._subprocess._pickle_protocol = highest_pickle_protocol([
-            sys.version_info, self.version_info])
-
         return self._subprocess
 
     def __repr__(self):
         version = '.'.join(str(i) for i in self.version_info)
         return '<%s: %s in %s>' % (self.__class__.__name__, version, self.path)
 
-    def get_evaluator_subprocess(self, evaluator):
-        return EvaluatorSubprocess(evaluator, self._get_subprocess())
+    def get_inference_state_subprocess(
+        self,
+        inference_state: 'InferenceState',
+    ) -> InferenceStateSubprocess:
+        return InferenceStateSubprocess(inference_state, self._get_subprocess())
 
     @memoize_method
     def get_sys_path(self):
         """
         The sys path for this environment. Does not include potential
-        modifications like ``sys.path.append``.
+        modifications from e.g. appending to :data:`sys.path`.
 
         :returns: list of str
         """
@@ -128,11 +129,12 @@ class Environment(_BaseEnvironment):
         return self._get_subprocess().get_sys_path()
 
 
-class _SameEnvironmentMixin(object):
+class _SameEnvironmentMixin:
     def __init__(self):
         self._start_executable = self.executable = sys.executable
         self.path = sys.prefix
         self.version_info = _VersionInfo(*sys.version_info[:3])
+        self._env_vars = None
 
 
 class SameEnvironment(_SameEnvironmentMixin, Environment):
@@ -140,20 +142,23 @@ class SameEnvironment(_SameEnvironmentMixin, Environment):
 
 
 class InterpreterEnvironment(_SameEnvironmentMixin, _BaseEnvironment):
-    def get_evaluator_subprocess(self, evaluator):
-        return EvaluatorSameProcess(evaluator)
+    def get_inference_state_subprocess(
+        self,
+        inference_state: 'InferenceState',
+    ) -> InferenceStateSameProcess:
+        return InferenceStateSameProcess(inference_state)
 
     def get_sys_path(self):
         return sys.path
 
 
-def _get_virtual_env_from_var():
+def _get_virtual_env_from_var(env_var='VIRTUAL_ENV'):
     """Get virtualenv environment from VIRTUAL_ENV environment variable.
 
     It uses `safe=False` with ``create_environment``, because the environment
     variable is considered to be safe / controlled by the user solely.
     """
-    var = os.environ.get('VIRTUAL_ENV')
+    var = os.environ.get(env_var)
     if var:
         # Under macOS in some cases - notably when using Pipenv - the
         # sys.prefix of the virtualenv is /path/to/env/bin/.. instead of
@@ -178,17 +183,22 @@ def _calculate_sha256_for_file(path):
 
 def get_default_environment():
     """
-    Tries to return an active Virtualenv. If there is no VIRTUAL_ENV variable
+    Tries to return an active Virtualenv or conda environment.
+    If there is no VIRTUAL_ENV variable or no CONDA_PREFIX variable set
     set it will return the latest Python version installed on the system. This
     makes it possible to use as many new Python features as possible when using
     autocompletion and other functionality.
 
-    :returns: :class:`Environment`
+    :returns: :class:`.Environment`
     """
     virtual_env = _get_virtual_env_from_var()
     if virtual_env is not None:
         return virtual_env
 
+    conda_env = _get_virtual_env_from_var(_CONDA_VAR)
+    if conda_env is not None:
+        return conda_env
+
     return _try_get_same_env()
 
 
@@ -233,7 +243,7 @@ def _try_get_same_env():
 
 
 def get_cached_default_environment():
-    var = os.environ.get('VIRTUAL_ENV')
+    var = os.environ.get('VIRTUAL_ENV') or os.environ.get(_CONDA_VAR)
     environment = _get_cached_default_environment()
 
     # Under macOS in some cases - notably when using Pipenv - the
@@ -248,58 +258,71 @@ def get_cached_default_environment():
 
 @time_cache(seconds=10 * 60)  # 10 Minutes
 def _get_cached_default_environment():
-    return get_default_environment()
+    try:
+        return get_default_environment()
+    except InvalidPythonEnvironment:
+        # It's possible that `sys.executable` is wrong. Typically happens
+        # when Jedi is used in an executable that embeds Python. For further
+        # information, have a look at:
+        # https://github.com/davidhalter/jedi/issues/1531
+        return InterpreterEnvironment()
 
 
-def find_virtualenvs(paths=None, **kwargs):
+def find_virtualenvs(paths=None, *, safe=True, use_environment_vars=True):
     """
     :param paths: A list of paths in your file system to be scanned for
         Virtualenvs. It will search in these paths and potentially execute the
-        Python binaries. Also the VIRTUAL_ENV variable will be checked if it
-        contains a valid Virtualenv.
+        Python binaries.
     :param safe: Default True. In case this is False, it will allow this
         function to execute potential `python` environments. An attacker might
         be able to drop an executable in a path this function is searching by
         default. If the executable has not been installed by root, it will not
         be executed.
+    :param use_environment_vars: Default True. If True, the VIRTUAL_ENV
+        variable will be checked if it contains a valid VirtualEnv.
+        CONDA_PREFIX will be checked to see if it contains a valid conda
+        environment.
 
-    :yields: :class:`Environment`
+    :yields: :class:`.Environment`
     """
-    def py27_comp(paths=None, safe=True):
-        if paths is None:
-            paths = []
+    if paths is None:
+        paths = []
 
-        _used_paths = set()
+    _used_paths = set()
 
-        # Using this variable should be safe, because attackers might be able
-        # to drop files (via git) but not environment variables.
+    if use_environment_vars:
+        # Using this variable should be safe, because attackers might be
+        # able to drop files (via git) but not environment variables.
         virtual_env = _get_virtual_env_from_var()
         if virtual_env is not None:
             yield virtual_env
             _used_paths.add(virtual_env.path)
 
-        for directory in paths:
-            if not os.path.isdir(directory):
+        conda_env = _get_virtual_env_from_var(_CONDA_VAR)
+        if conda_env is not None:
+            yield conda_env
+            _used_paths.add(conda_env.path)
+
+    for directory in paths:
+        if not os.path.isdir(directory):
+            continue
+
+        directory = os.path.abspath(directory)
+        for path in os.listdir(directory):
+            path = os.path.join(directory, path)
+            if path in _used_paths:
+                # A path shouldn't be inferred twice.
                 continue
+            _used_paths.add(path)
 
-            directory = os.path.abspath(directory)
-            for path in os.listdir(directory):
-                path = os.path.join(directory, path)
-                if path in _used_paths:
-                    # A path shouldn't be evaluated twice.
-                    continue
-                _used_paths.add(path)
-
-                try:
-                    executable = _get_executable_path(path, safe=safe)
-                    yield Environment(executable)
-                except InvalidPythonEnvironment:
-                    pass
-
-    return py27_comp(paths, **kwargs)
+            try:
+                executable = _get_executable_path(path, safe=safe)
+                yield Environment(executable)
+            except InvalidPythonEnvironment:
+                pass
 
 
-def find_system_environments():
+def find_system_environments(*, env_vars=None):
     """
     Ignores virtualenvs and returns the Python versions that were installed on
     your system. This might return nothing, if you're running Python e.g. from
@@ -307,24 +330,24 @@ def find_system_environments():
 
     The environments are sorted from latest to oldest Python version.
 
-    :yields: :class:`Environment`
+    :yields: :class:`.Environment`
     """
     for version_string in _SUPPORTED_PYTHONS:
         try:
-            yield get_system_environment(version_string)
+            yield get_system_environment(version_string, env_vars=env_vars)
         except InvalidPythonEnvironment:
             pass
 
 
 # TODO: this function should probably return a list of environments since
 # multiple Python installations can be found on a system for the same version.
-def get_system_environment(version):
+def get_system_environment(version, *, env_vars=None):
     """
     Return the first Python environment found for a string of the form 'X.Y'
     where X and Y are the major and minor versions of Python.
 
     :raises: :exc:`.InvalidPythonEnvironment`
-    :returns: :class:`Environment`
+    :returns: :class:`.Environment`
     """
     exe = which('python' + version)
     if exe:
@@ -335,24 +358,24 @@ def get_system_environment(version):
     if os.name == 'nt':
         for exe in _get_executables_from_windows_registry(version):
             try:
-                return Environment(exe)
+                return Environment(exe, env_vars=env_vars)
             except InvalidPythonEnvironment:
                 pass
     raise InvalidPythonEnvironment("Cannot find executable python%s." % version)
 
 
-def create_environment(path, safe=True):
+def create_environment(path, *, safe=True, env_vars=None):
     """
     Make it possible to manually create an Environment object by specifying a
-    Virtualenv path or an executable path.
+    Virtualenv path or an executable path and optional environment variables.
 
     :raises: :exc:`.InvalidPythonEnvironment`
-    :returns: :class:`Environment`
+    :returns: :class:`.Environment`
     """
     if os.path.isfile(path):
         _assert_safe(path, safe)
-        return Environment(path)
-    return Environment(_get_executable_path(path, safe=safe))
+        return Environment(path, env_vars=env_vars)
+    return Environment(_get_executable_path(path, safe=safe), env_vars=env_vars)
 
 
 def _get_executable_path(path, safe=True):
@@ -361,10 +384,13 @@ def _get_executable_path(path, safe=True):
     """
 
     if os.name == 'nt':
-        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)
@@ -372,11 +398,7 @@ def _get_executable_path(path, safe=True):
 
 
 def _get_executables_from_windows_registry(version):
-    # The winreg module is named _winreg on Python 2.
-    try:
-        import winreg
-    except ImportError:
-        import _winreg as winreg
+    import winreg
 
     # TODO: support Python Anaconda.
     sub_keys = [
@@ -446,8 +468,8 @@ def _is_unix_safe_simple(real_path):
     # 2. The repository has an innocent looking folder called foobar. jedi
     #    searches for the folder and executes foobar/bin/python --version if
     #    there's also a foobar/bin/activate.
-    # 3. The bin/python is obviously not a python script but a bash script or
-    #    whatever the attacker wants.
+    # 3. The attacker has gained code execution, since he controls
+    #    foobar/bin/python.
     return uid == 0
 
 

jedi/api/errors.py

@@ -0,0 +1,46 @@
+"""
+This file is about errors in Python files and not about exception handling in
+Jedi.
+"""
+
+
+def parso_to_jedi_errors(grammar, module_node):
+    return [SyntaxError(e) for e in grammar.iter_errors(module_node)]
+
+
+class SyntaxError:
+    """
+    Syntax errors are generated by :meth:`.Script.get_syntax_errors`.
+    """
+    def __init__(self, parso_error):
+        self._parso_error = parso_error
+
+    @property
+    def line(self):
+        """The line where the error starts (starting with 1)."""
+        return self._parso_error.start_pos[0]
+
+    @property
+    def column(self):
+        """The column where the error starts (starting with 0)."""
+        return self._parso_error.start_pos[1]
+
+    @property
+    def until_line(self):
+        """The line where the error ends (starting with 1)."""
+        return self._parso_error.end_pos[0]
+
+    @property
+    def until_column(self):
+        """The column where the error ends (starting with 0)."""
+        return self._parso_error.end_pos[1]
+
+    def get_message(self):
+        return self._parso_error.message
+
+    def __repr__(self):
+        return '<%s from=%s to=%s>' % (
+            self.__class__.__name__,
+            self._parso_error.start_pos,
+            self._parso_error.end_pos,
+        )

jedi/api/exceptions.py

@@ -3,8 +3,29 @@ class _JediError(Exception):
 
 
 class InternalError(_JediError):
-    pass
+    """
+    This error might happen a subprocess is crashing. The reason for this is
+    usually broken C code in third party libraries. This is not a very common
+    thing and it is safe to use Jedi again. However using the same calls might
+    result in the same error again.
+    """
 
 
 class WrongVersion(_JediError):
-    pass
+    """
+    This error is reserved for the future, shouldn't really be happening at the
+    moment.
+    """
+
+
+class RefactoringError(_JediError):
+    """
+    Refactorings can fail for various reasons. So if you work with refactorings
+    like :meth:`.Script.rename`, :meth:`.Script.inline`,
+    :meth:`.Script.extract_variable` and :meth:`.Script.extract_function`, make
+    sure to catch these. The descriptions in the errors are usually valuable
+    for end users.
+
+    A typical ``RefactoringError`` would tell the user that inlining is not
+    possible if no name is under the cursor.
+    """

jedi/api/file_name.py

@@ -1,28 +1,33 @@
 import os
 
-from jedi._compatibility import FileNotFoundError, force_unicode
-from jedi.evaluate.names import AbstractArbitraryName
 from jedi.api import classes
-from jedi.evaluate.helpers import get_str_or_none
-from jedi.parser_utils import get_string_quote
+from jedi.api.strings import StringName, get_quote_ending
+from jedi.api.helpers import match
+from jedi.inference.helpers import get_str_or_none
 
 
-def file_name_completions(evaluator, module_context, start_leaf, string,
-                          like_name, call_signatures_callback, code_lines, position):
+class PathName(StringName):
+    api_type = 'path'
+
+
+def complete_file_name(inference_state, module_context, start_leaf, quote, string,
+                       like_name, signatures_callback, code_lines, position, fuzzy):
     # First we want to find out what can actually be changed as a name.
-    like_name_length = len(os.path.basename(string) + like_name)
+    like_name_length = len(os.path.basename(string))
 
     addition = _get_string_additions(module_context, start_leaf)
+    if string.startswith('~'):
+        string = os.path.expanduser(string)
     if addition is None:
         return
     string = addition + string
 
     # Here we use basename again, because if strings are added like
     # `'foo' + 'bar`, it should complete to `foobar/`.
-    must_start_with = os.path.basename(string) + like_name
+    must_start_with = os.path.basename(string)
     string = os.path.dirname(string)
 
-    sigs = call_signatures_callback()
+    sigs = signatures_callback(*position)
     is_in_os_path_join = sigs and all(s.full_name == 'os.path.join' for s in sigs)
     if is_in_os_path_join:
         to_be_added = _add_os_path_join(module_context, start_leaf, sigs[0].bracket_start)
@@ -30,33 +35,27 @@ def file_name_completions(evaluator, module_context, start_leaf, string,
             is_in_os_path_join = False
         else:
             string = to_be_added + string
-    base_path = os.path.join(evaluator.project._path, string)
+    base_path = os.path.join(inference_state.project.path, string)
     try:
-        listed = os.listdir(base_path)
-    except FileNotFoundError:
+        listed = sorted(os.scandir(base_path), key=lambda e: e.name)
+        # OSError: [Errno 36] File name too long: '...'
+    except (FileNotFoundError, OSError):
         return
-    for name in listed:
-        if name.startswith(must_start_with):
-            path_for_name = os.path.join(base_path, name)
-            if is_in_os_path_join or not os.path.isdir(path_for_name):
-                if start_leaf.type == 'string':
-                    quote = get_string_quote(start_leaf)
-                else:
-                    assert start_leaf.type == 'error_leaf'
-                    quote = start_leaf.value
-                potential_other_quote = \
-                    code_lines[position[0] - 1][position[1]:position[1] + len(quote)]
-                # Add a quote if it's not already there.
-                if quote != potential_other_quote:
-                    name += quote
+    quote_ending = get_quote_ending(quote, code_lines, position)
+    for entry in listed:
+        name = entry.name
+        if match(name, must_start_with, fuzzy=fuzzy):
+            if is_in_os_path_join or not entry.is_dir():
+                name += quote_ending
             else:
                 name += os.path.sep
 
             yield classes.Completion(
-                evaluator,
-                FileName(evaluator, name[len(must_start_with) - like_name_length:]),
+                inference_state,
+                PathName(inference_state, name[len(must_start_with) - like_name_length:]),
                 stack=None,
-                like_name_length=like_name_length
+                like_name_length=like_name_length,
+                is_fuzzy=fuzzy,
             )
 
 
@@ -85,25 +84,20 @@ def _add_strings(context, nodes, add_slash=False):
     string = ''
     first = True
     for child_node in nodes:
-        contexts = context.eval_node(child_node)
-        if len(contexts) != 1:
+        values = context.infer_node(child_node)
+        if len(values) != 1:
             return None
-        c, = contexts
+        c, = values
         s = get_str_or_none(c)
         if s is None:
             return None
         if not first and add_slash:
             string += os.path.sep
-        string += force_unicode(s)
+        string += s
         first = False
     return string
 
 
-class FileName(AbstractArbitraryName):
-    api_type = u'path'
-    is_context_name = False
-
-
 def _add_os_path_join(module_context, start_leaf, bracket_start):
     def check(maybe_bracket, nodes):
         if maybe_bracket.start_pos != bracket_start:
@@ -116,10 +110,10 @@ def _add_os_path_join(module_context, start_leaf, bracket_start):
 
     if start_leaf.type == 'error_leaf':
         # Unfinished string literal, like `join('`
-        context_node = start_leaf.parent
-        index = context_node.children.index(start_leaf)
+        value_node = start_leaf.parent
+        index = value_node.children.index(start_leaf)
         if index > 0:
-            error_node = context_node.children[index - 1]
+            error_node = value_node.children[index - 1]
             if error_node.type == 'error_node' and len(error_node.children) >= 2:
                 index = -2
                 if error_node.children[-1].type == 'arglist':

jedi/api/helpers.py

@@ -4,24 +4,50 @@ Helpers for the API
 import re
 from collections import namedtuple
 from textwrap import dedent
+from itertools import chain
+from functools import wraps
+from inspect import Parameter
 
 from parso.python.parser import Parser
 from parso.python import tree
 
-from jedi._compatibility import u, Parameter
-from jedi.evaluate.base_context import NO_CONTEXTS
-from jedi.evaluate.syntax_tree import eval_atom
-from jedi.evaluate.helpers import evaluate_call_of_leaf
-from jedi.evaluate.compiled import get_string_context_set
-from jedi.cache import call_signature_time_cache
+from jedi.inference.base_value import NO_VALUES
+from jedi.inference.syntax_tree import infer_atom
+from jedi.inference.helpers import infer_call_of_leaf
+from jedi.inference.compiled import get_string_value_set
+from jedi.cache import signature_time_cache, memoize_method
+from jedi.parser_utils import get_parent_scope
 
 
 CompletionParts = namedtuple('CompletionParts', ['path', 'has_dot', 'name'])
 
 
+def _start_match(string, like_name):
+    return string.startswith(like_name)
+
+
+def _fuzzy_match(string, like_name):
+    if len(like_name) <= 1:
+        return like_name in string
+    pos = string.find(like_name[0])
+    if pos >= 0:
+        return _fuzzy_match(string[pos + 1:], like_name[1:])
+    return False
+
+
+def match(string, like_name, fuzzy=False):
+    if fuzzy:
+        return _fuzzy_match(string, like_name)
+    else:
+        return _start_match(string, like_name)
+
+
 def sorted_definitions(defs):
     # Note: `or ''` below is required because `module_path` could be
-    return sorted(defs, key=lambda x: (x.module_path or '', x.line or 0, x.column or 0, x.name))
+    return sorted(defs, key=lambda x: (str(x.module_path or ''),
+                                       x.line or 0,
+                                       x.column or 0,
+                                       x.name))
 
 
 def get_on_completion_name(module_node, lines, position):
@@ -61,18 +87,18 @@ def _get_code_for_stack(code_lines, leaf, position):
         # If we're not on a comment simply get the previous leaf and proceed.
         leaf = leaf.get_previous_leaf()
         if leaf is None:
-            return u('')  # At the beginning of the file.
+            return ''  # At the beginning of the file.
 
     is_after_newline = leaf.type == 'newline'
     while leaf.type == 'newline':
         leaf = leaf.get_previous_leaf()
         if leaf is None:
-            return u('')
+            return ''
 
     if leaf.type == 'error_leaf' or leaf.type == 'string':
         if leaf.start_pos[0] < position[0]:
             # On a different line, we just begin anew.
-            return u('')
+            return ''
 
         # Error leafs cannot be parsed, completion in strings is also
         # impossible.
@@ -87,8 +113,8 @@ def _get_code_for_stack(code_lines, leaf, position):
         if is_after_newline:
             if user_stmt.start_pos[1] > position[1]:
                 # This means that it's actually a dedent and that means that we
-                # start without context (part of a suite).
-                return u('')
+                # start without value (part of a suite).
+                return ''
 
         # This is basically getting the relevant lines.
         return _get_code(code_lines, user_stmt.get_start_pos_of_prefix(), position)
@@ -136,31 +162,49 @@ def get_stack_at_position(grammar, code_lines, leaf, pos):
     )
 
 
-def evaluate_goto_definition(evaluator, context, leaf):
+def infer(inference_state, context, leaf):
     if leaf.type == 'name':
-        # In case of a name we can just use goto_definition which does all the
-        # magic itself.
-        return evaluator.goto_definitions(context, leaf)
+        return inference_state.infer(context, leaf)
 
     parent = leaf.parent
-    definitions = NO_CONTEXTS
+    definitions = NO_VALUES
     if parent.type == 'atom':
         # e.g. `(a + b)`
-        definitions = context.eval_node(leaf.parent)
+        definitions = context.infer_node(leaf.parent)
     elif parent.type == 'trailer':
         # e.g. `a()`
-        definitions = evaluate_call_of_leaf(context, leaf)
+        definitions = infer_call_of_leaf(context, leaf)
     elif isinstance(leaf, tree.Literal):
         # e.g. `"foo"` or `1.0`
-        return eval_atom(context, leaf)
+        return infer_atom(context, leaf)
     elif leaf.type in ('fstring_string', 'fstring_start', 'fstring_end'):
-        return get_string_context_set(evaluator)
+        return get_string_value_set(inference_state)
     return definitions
 
 
-class CallDetails(object):
+def filter_follow_imports(names, follow_builtin_imports=False):
+    for name in names:
+        if name.is_import():
+            new_names = list(filter_follow_imports(
+                name.goto(),
+                follow_builtin_imports=follow_builtin_imports,
+            ))
+            found_builtin = False
+            if follow_builtin_imports:
+                for new_name in new_names:
+                    if new_name.start_pos is None:
+                        found_builtin = True
+
+            if found_builtin:
+                yield name
+            else:
+                yield from new_names
+        else:
+            yield name
+
+
+class CallDetails:
     def __init__(self, bracket_leaf, children, position):
-        ['bracket_leaf', 'call_index', 'keyword_name_str']
         self.bracket_leaf = bracket_leaf
         self._children = children
         self._position = position
@@ -173,11 +217,15 @@ class CallDetails(object):
     def keyword_name_str(self):
         return _get_index_and_key(self._children, self._position)[1]
 
+    @memoize_method
+    def _list_arguments(self):
+        return list(_iter_arguments(self._children, self._position))
+
     def calculate_index(self, param_names):
         positional_count = 0
         used_names = set()
         star_count = -1
-        args = list(_iter_arguments(self._children, self._position))
+        args = self._list_arguments()
         if not args:
             if param_names:
                 return 0
@@ -224,6 +272,19 @@ class CallDetails(object):
                     return i
         return None
 
+    def iter_used_keyword_arguments(self):
+        for star_count, key_start, had_equal in list(self._list_arguments()):
+            if had_equal and key_start:
+                yield key_start
+
+    def count_positional_arguments(self):
+        count = 0
+        for star_count, key_start, had_equal in self._list_arguments()[:-1]:
+            if star_count or key_start:
+                break
+            count += 1
+        return count
+
 
 def _iter_arguments(nodes, position):
     def remove_after_pos(name):
@@ -234,8 +295,7 @@ def _iter_arguments(nodes, position):
     # Returns Generator[Tuple[star_count, Optional[key_start: str], had_equal]]
     nodes_before = [c for c in nodes if c.start_pos < position]
     if nodes_before[-1].type == 'arglist':
-        for x in _iter_arguments(nodes_before[-1].children, position):
-            yield x  # Python 2 :(
+        yield from _iter_arguments(nodes_before[-1].children, position)
         return
 
     previous_node_yielded = False
@@ -246,7 +306,7 @@ def _iter_arguments(nodes, position):
             first = node.children[0]
             second = node.children[1]
             if second == '=':
-                if second.start_pos < position:
+                if second.start_pos < position and first.type == 'name':
                     yield 0, first.value, True
                 else:
                     yield 0, remove_after_pos(first), False
@@ -260,7 +320,7 @@ def _iter_arguments(nodes, position):
                 else:
                     yield 0, None, False
             stars_seen = 0
-        elif node.type in ('testlist', 'testlist_star_expr'):  # testlist is Python 2
+        elif node.type == 'testlist_star_expr':
             for n in node.children[::2]:
                 if n.type == 'star_expr':
                     stars_seen = 1
@@ -314,7 +374,7 @@ def _get_index_and_key(nodes, position):
     return nodes_before.count(','), key_str
 
 
-def _get_call_signature_details_from_error_node(node, additional_children, position):
+def _get_signature_details_from_error_node(node, additional_children, position):
     for index, element in reversed(list(enumerate(node.children))):
         # `index > 0` means that it's a trailer and not an atom.
         if element == '(' and element.end_pos <= position and index > 0:
@@ -328,33 +388,30 @@ def _get_call_signature_details_from_error_node(node, additional_children, posit
                 return CallDetails(element, children + additional_children, position)
 
 
-def get_call_signature_details(module, position):
+def get_signature_details(module, position):
     leaf = module.get_leaf_for_position(position, include_prefixes=True)
+    # It's easier to deal with the previous token than the next one in this
+    # case.
     if leaf.start_pos >= position:
         # Whitespace / comments after the leaf count towards the previous leaf.
         leaf = leaf.get_previous_leaf()
         if leaf is None:
             return None
 
-    if leaf == ')':
-        # TODO is this ok?
-        if leaf.end_pos == position:
-            leaf = leaf.get_next_leaf()
-
     # Now that we know where we are in the syntax tree, we start to look at
     # parents for possible function definitions.
     node = leaf.parent
     while node is not None:
-        if node.type in ('funcdef', 'classdef'):
-            # Don't show call signatures if there's stuff before it that just
-            # makes it feel strange to have a call signature.
+        if node.type in ('funcdef', 'classdef', 'decorated', 'async_stmt'):
+            # Don't show signatures if there's stuff before it that just
+            # makes it feel strange to have a signature.
             return None
 
         additional_children = []
         for n in reversed(node.children):
             if n.start_pos < position:
                 if n.type == 'error_node':
-                    result = _get_call_signature_details_from_error_node(
+                    result = _get_signature_details_from_error_node(
                         n, additional_children, position
                     )
                     if result is not None:
@@ -364,19 +421,30 @@ def get_call_signature_details(module, position):
                     continue
                 additional_children.insert(0, n)
 
-        if node.type == 'trailer' and node.children[0] == '(':
-            leaf = node.get_previous_leaf()
-            if leaf is None:
-                return None
-            return CallDetails(node.children[0], node.children, position)
+        # Find a valid trailer
+        if node.type == 'trailer' and node.children[0] == '(' \
+                or node.type == 'decorator' and node.children[2] == '(':
+            # Additionally we have to check that an ending parenthesis isn't
+            # interpreted wrong. There are two cases:
+            # 1. Cursor before paren -> The current signature is good
+            # 2. Cursor after paren -> We need to skip the current signature
+            if not (leaf is node.children[-1] and position >= leaf.end_pos):
+                leaf = node.get_previous_leaf()
+                if leaf is None:
+                    return None
+                return CallDetails(
+                    node.children[0] if node.type == 'trailer' else node.children[2],
+                    node.children,
+                    position
+                )
 
         node = node.parent
 
     return None
 
 
-@call_signature_time_cache("call_signatures_validity")
-def cache_call_signatures(evaluator, context, bracket_leaf, code_lines, user_pos):
+@signature_time_cache("call_signatures_validity")
+def cache_signatures(inference_state, context, bracket_leaf, code_lines, user_pos):
     """This function calculates the cache key."""
     line_index = user_pos[0] - 1
 
@@ -390,8 +458,65 @@ def cache_call_signatures(evaluator, context, bracket_leaf, code_lines, user_pos
         yield None  # Don't cache!
     else:
         yield (module_path, before_bracket, bracket_leaf.start_pos)
-    yield evaluate_goto_definition(
-        evaluator,
+    yield infer(
+        inference_state,
         context,
         bracket_leaf.get_previous_leaf(),
     )
+
+
+def validate_line_column(func):
+    @wraps(func)
+    def wrapper(self, line=None, column=None, *args, **kwargs):
+        line = max(len(self._code_lines), 1) if line is None else line
+        if not (0 < line <= len(self._code_lines)):
+            raise ValueError('`line` parameter is not in a valid range.')
+
+        line_string = self._code_lines[line - 1]
+        line_len = len(line_string)
+        if line_string.endswith('\r\n'):
+            line_len -= 2
+        elif line_string.endswith('\n'):
+            line_len -= 1
+
+        column = line_len if column is None else column
+        if not (0 <= column <= line_len):
+            raise ValueError('`column` parameter (%d) is not in a valid range '
+                             '(0-%d) for line %d (%r).' % (
+                                 column, line_len, line, line_string))
+        return func(self, line, column, *args, **kwargs)
+    return wrapper
+
+
+def get_module_names(module, all_scopes, definitions=True, references=False):
+    """
+    Returns a dictionary with name parts as keys and their call paths as
+    values.
+    """
+    def def_ref_filter(name):
+        is_def = name.is_definition()
+        return definitions and is_def or references and not is_def
+
+    names = list(chain.from_iterable(module.get_used_names().values()))
+    if not all_scopes:
+        # We have to filter all the names that don't have the module as a
+        # parent_scope. There's None as a parent, because nodes in the module
+        # node have the parent module and not suite as all the others.
+        # Therefore it's important to catch that case.
+
+        def is_module_scope_name(name):
+            parent_scope = get_parent_scope(name)
+            # async functions have an extra wrapper. Strip it.
+            if parent_scope and parent_scope.type == 'async_stmt':
+                parent_scope = parent_scope.parent
+            return parent_scope in (module, None)
+
+        names = [n for n in names if is_module_scope_name(n)]
+    return filter(def_ref_filter, names)
+
+
+def split_search_string(name):
+    type, _, dotted_names = name.rpartition(' ')
+    if type == 'def':
+        type = 'function'
+    return type, dotted_names.split('.')

jedi/api/interpreter.py

@@ -2,46 +2,73 @@
 TODO Some parts of this module are still not well documented.
 """
 
-from jedi.evaluate.context import ModuleContext
-from jedi.evaluate import compiled
-from jedi.evaluate.compiled import mixed
-from jedi.evaluate.compiled.access import create_access_path
-from jedi.evaluate.base_context import ContextWrapper
+from jedi.inference import compiled
+from jedi.inference.base_value import ValueSet
+from jedi.inference.filters import ParserTreeFilter, MergedFilter
+from jedi.inference.names import TreeNameDefinition
+from jedi.inference.compiled import mixed
+from jedi.inference.compiled.access import create_access_path
+from jedi.inference.context import ModuleContext
 
 
-def _create(evaluator, obj):
+def _create(inference_state, obj):
     return compiled.create_from_access_path(
-        evaluator, create_access_path(evaluator, obj)
+        inference_state, create_access_path(inference_state, obj)
     )
 
 
-class NamespaceObject(object):
+class NamespaceObject:
     def __init__(self, dct):
         self.__dict__ = dct
 
 
-class MixedModuleContext(ContextWrapper):
-    type = 'mixed_module'
+class MixedTreeName(TreeNameDefinition):
+    def infer(self):
+        """
+        In IPython notebook it is typical that some parts of the code that is
+        provided was already executed. In that case if something is not properly
+        inferred, it should still infer from the variables it already knows.
+        """
+        inferred = super().infer()
+        if not inferred:
+            for compiled_value in self.parent_context.mixed_values:
+                for f in compiled_value.get_filters():
+                    values = ValueSet.from_sets(
+                        n.infer() for n in f.get(self.string_name)
+                    )
+                    if values:
+                        return values
+        return inferred
 
-    def __init__(self, evaluator, tree_module, namespaces, file_io, code_lines):
-        module_context = ModuleContext(
-            evaluator, tree_module,
-            file_io=file_io,
-            string_names=('__main__',),
-            code_lines=code_lines
+
+class MixedParserTreeFilter(ParserTreeFilter):
+    name_class = MixedTreeName
+
+
+class MixedModuleContext(ModuleContext):
+    def __init__(self, tree_module_value, namespaces):
+        super().__init__(tree_module_value)
+        self.mixed_values = [
+            self._get_mixed_object(
+                _create(self.inference_state, NamespaceObject(n))
+            ) for n in namespaces
+        ]
+
+    def _get_mixed_object(self, compiled_value):
+        return mixed.MixedObject(
+            compiled_value=compiled_value,
+            tree_value=self._value
         )
-        super(MixedModuleContext, self).__init__(module_context)
-        self._namespace_objects = [NamespaceObject(n) for n in namespaces]
 
-    def get_filters(self, *args, **kwargs):
-        for filter in self._wrapped_context.get_filters(*args, **kwargs):
-            yield filter
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield MergedFilter(
+            MixedParserTreeFilter(
+                parent_context=self,
+                until_position=until_position,
+                origin_scope=origin_scope
+            ),
+            self.get_global_filter(),
+        )
 
-        for namespace_obj in self._namespace_objects:
-            compiled_object = _create(self.evaluator, namespace_obj)
-            mixed_object = mixed.MixedObject(
-                compiled_object=compiled_object,
-                tree_context=self._wrapped_context
-            )
-            for filter in mixed_object.get_filters(*args, **kwargs):
-                yield filter
+        for mixed_object in self.mixed_values:
+            yield from mixed_object.get_filters(until_position, origin_scope)

jedi/api/keywords.py

@@ -1,55 +1,22 @@
 import pydoc
+from contextlib import suppress
+from typing import Dict, Optional
 
-from jedi.evaluate.utils import ignored
-from jedi.evaluate.names import AbstractArbitraryName
+from jedi.inference.names import AbstractArbitraryName
 
 try:
-    from pydoc_data import topics as pydoc_topics
+    from pydoc_data import topics
+    pydoc_topics: Optional[Dict[str, str]] = topics.topics
 except ImportError:
-    # Python 2
-    try:
-        import pydoc_topics
-    except ImportError:
-        # This is for Python 3 embeddable version, which dont have
-        # pydoc_data module in its file python3x.zip.
-        pydoc_topics = None
-
-
-def get_operator(evaluator, string, pos):
-    return Keyword(evaluator, string, pos)
+    # Python 3.6.8 embeddable does not have pydoc_data.
+    pydoc_topics = None
 
 
 class KeywordName(AbstractArbitraryName):
-    api_type = u'keyword'
-
-    def infer(self):
-        return [Keyword(self.evaluator, self.string_name, (0, 0))]
-
-
-class Keyword(object):
-    api_type = u'keyword'
-
-    def __init__(self, evaluator, name, pos):
-        self.name = KeywordName(evaluator, name)
-        self.start_pos = pos
-        self.parent = evaluator.builtins_module
-
-    @property
-    def names(self):
-        """ For a `parsing.Name` like comparision """
-        return [self.name]
+    api_type = 'keyword'
 
     def py__doc__(self):
-        return imitate_pydoc(self.name.string_name)
-
-    def get_signatures(self):
-        # TODO this makes no sense, I think Keyword should somehow merge with
-        #   Context to make it easier for the api/classes.py to deal with all
-        #   of it.
-        return []
-
-    def __repr__(self):
-        return '<%s: %s>' % (type(self).__name__, self.name)
+        return imitate_pydoc(self.string_name)
 
 
 def imitate_pydoc(string):
@@ -60,16 +27,15 @@ def imitate_pydoc(string):
     if pydoc_topics is None:
         return ''
 
-    # str needed because of possible unicode stuff in py2k (pydoc doesn't work
-    # with unicode strings)
-    string = str(string)
     h = pydoc.help
-    with ignored(KeyError):
+    with suppress(KeyError):
         # try to access symbols
         string = h.symbols[string]
         string, _, related = string.partition(' ')
 
-    get_target = lambda s: h.topics.get(s, h.keywords.get(s))
+    def get_target(s):
+        return h.topics.get(s, h.keywords.get(s))
+
     while isinstance(string, str):
         string = get_target(string)
 
@@ -80,6 +46,6 @@ def imitate_pydoc(string):
         return ''
 
     try:
-        return pydoc_topics.topics[label].strip() if pydoc_topics else ''
+        return pydoc_topics[label].strip() if pydoc_topics else ''
     except KeyError:
         return ''

jedi/api/project.py

@@ -1,21 +1,52 @@
-import os
-import json
+"""
+Projects are a way to handle Python projects within Jedi. For simpler plugins
+you might not want to deal with projects, but if you want to give the user more
+flexibility to define sys paths and Python interpreters for a project,
+:class:`.Project` is the perfect way to allow for that.
 
-from jedi._compatibility import FileNotFoundError, PermissionError, IsADirectoryError
-from jedi.api.environment import SameEnvironment, \
-    get_cached_default_environment
+Projects can be saved to disk and loaded again, to allow project definitions to
+be used across repositories.
+"""
+import json
+from pathlib import Path
+from itertools import chain
+
+from jedi import debug
+from jedi.api.environment import get_cached_default_environment, create_environment
 from jedi.api.exceptions import WrongVersion
-from jedi._compatibility import force_unicode
-from jedi.evaluate.sys_path import discover_buildout_paths
-from jedi.evaluate.cache import evaluator_as_method_param_cache
-from jedi.common.utils import traverse_parents
+from jedi.api.completion import search_in_module
+from jedi.api.helpers import split_search_string, get_module_names
+from jedi.inference.imports import load_module_from_path, \
+    load_namespace_from_path, iter_module_names
+from jedi.inference.sys_path import discover_buildout_paths
+from jedi.inference.cache import inference_state_as_method_param_cache
+from jedi.inference.references import recurse_find_python_folders_and_files, search_in_file_ios
+from jedi.file_io import FolderIO
 
 _CONFIG_FOLDER = '.jedi'
-_CONTAINS_POTENTIAL_PROJECT = 'setup.py', '.git', '.hg', 'requirements.txt', 'MANIFEST.in'
+_CONTAINS_POTENTIAL_PROJECT = \
+    'setup.py', '.git', '.hg', 'requirements.txt', 'MANIFEST.in', 'pyproject.toml'
 
 _SERIALIZER_VERSION = 1
 
 
+def _try_to_skip_duplicates(func):
+    def wrapper(*args, **kwargs):
+        found_tree_nodes = []
+        found_modules = []
+        for definition in func(*args, **kwargs):
+            tree_node = definition._name.tree_name
+            if tree_node is not None and tree_node in found_tree_nodes:
+                continue
+            if definition.type == 'module' and definition.module_path is not None:
+                if definition.module_path in found_modules:
+                    continue
+                found_modules.append(definition.module_path)
+            yield definition
+            found_tree_nodes.append(tree_node)
+    return wrapper
+
+
 def _remove_duplicates_from_path(path):
     used = set()
     for p in path:
@@ -25,92 +56,177 @@ def _remove_duplicates_from_path(path):
         yield p
 
 
-def _force_unicode_list(lst):
-    return list(map(force_unicode, lst))
-
-
-class Project(object):
-    # TODO serialize environment
-    _serializer_ignore_attributes = ('_environment',)
+class Project:
+    """
+    Projects are a simple way to manage Python folders and define how Jedi does
+    import resolution. It is mostly used as a parameter to :class:`.Script`.
+    Additionally there are functions to search a whole project.
+    """
     _environment = None
 
+    @staticmethod
+    def _get_config_folder_path(base_path):
+        return base_path.joinpath(_CONFIG_FOLDER)
+
     @staticmethod
     def _get_json_path(base_path):
-        return os.path.join(base_path, _CONFIG_FOLDER, 'project.json')
+        return Project._get_config_folder_path(base_path).joinpath('project.json')
 
     @classmethod
     def load(cls, path):
         """
+        Loads a project from a specific path. You should not provide the path
+        to ``.jedi/project.json``, but rather the path to the project folder.
+
         :param path: The path of the directory you want to use as a project.
         """
+        if isinstance(path, str):
+            path = Path(path)
         with open(cls._get_json_path(path)) as f:
             version, data = json.load(f)
 
         if version == 1:
-            self = cls.__new__()
-            self.__dict__.update(data)
-            return self
+            return cls(**data)
         else:
             raise WrongVersion(
                 "The Jedi version of this project seems newer than what we can handle."
             )
 
-    def __init__(self, path, **kwargs):
+    def save(self):
+        """
+        Saves the project configuration in the project in ``.jedi/project.json``.
+        """
+        data = dict(self.__dict__)
+        data.pop('_environment', None)
+        data.pop('_django', None)  # TODO make django setting public?
+        data = {k.lstrip('_'): v for k, v in data.items()}
+        data['path'] = str(data['path'])
+
+        self._get_config_folder_path(self._path).mkdir(parents=True, exist_ok=True)
+        with open(self._get_json_path(self._path), 'w') as f:
+            return json.dump((_SERIALIZER_VERSION, data), f)
+
+    def __init__(
+        self,
+        path,
+        *,
+        environment_path=None,
+        load_unsafe_extensions=False,
+        sys_path=None,
+        added_sys_path=(),
+        smart_sys_path=True,
+    ) -> None:
         """
         :param path: The base path for this project.
+        :param environment_path: The Python executable path, typically the path
+            of a virtual environment.
+        :param load_unsafe_extensions: Default False, Loads extensions that are not in the
+            sys path and in the local directories. With this option enabled,
+            this is potentially unsafe if you clone a git repository and
+            analyze it's code, because those compiled extensions will be
+            important and therefore have execution privileges.
         :param sys_path: list of str. You can override the sys path if you
-            want. By default the ``sys.path.`` is generated from the
+            want. By default the ``sys.path.`` is generated by the
             environment (virtualenvs, etc).
+        :param added_sys_path: list of str. Adds these paths at the end of the
+            sys path.
         :param smart_sys_path: If this is enabled (default), adds paths from
             local directories. Otherwise you will have to rely on your packages
             being properly configured on the ``sys.path``.
         """
-        def py2_comp(path, environment=None, sys_path=None,
-                     smart_sys_path=True, _django=False):
-            self._path = os.path.abspath(path)
-            if isinstance(environment, SameEnvironment):
-                self._environment = environment
 
-            self._sys_path = sys_path
-            self._smart_sys_path = smart_sys_path
-            self._django = _django
+        if isinstance(path, str):
+            path = Path(path).absolute()
+        self._path = path
 
-        py2_comp(path, **kwargs)
+        self._environment_path = environment_path
+        if sys_path is not None:
+            # Remap potential pathlib.Path entries
+            sys_path = list(map(str, sys_path))
+        self._sys_path = sys_path
+        self._smart_sys_path = smart_sys_path
+        self._load_unsafe_extensions = load_unsafe_extensions
+        self._django = False
+        # Remap potential pathlib.Path entries
+        self.added_sys_path = list(map(str, added_sys_path))
+        """The sys path that is going to be added at the end of the """
 
-    @evaluator_as_method_param_cache()
-    def _get_base_sys_path(self, evaluator, environment=None):
-        if self._sys_path is not None:
-            return self._sys_path
+    @property
+    def path(self):
+        """
+        The base path for this project.
+        """
+        return self._path
 
+    @property
+    def sys_path(self):
+        """
+        The sys path provided to this project. This can be None and in that
+        case will be auto generated.
+        """
+        return self._sys_path
+
+    @property
+    def smart_sys_path(self):
+        """
+        If the sys path is going to be calculated in a smart way, where
+        additional paths are added.
+        """
+        return self._smart_sys_path
+
+    @property
+    def load_unsafe_extensions(self):
+        """
+        Wheter the project loads unsafe extensions.
+        """
+        return self._load_unsafe_extensions
+
+    @inference_state_as_method_param_cache()
+    def _get_base_sys_path(self, inference_state):
         # The sys path has not been set explicitly.
-        if environment is None:
-            environment = self.get_environment()
-
-        sys_path = list(environment.get_sys_path())
+        sys_path = list(inference_state.environment.get_sys_path())
         try:
             sys_path.remove('')
         except ValueError:
             pass
         return sys_path
 
-    @evaluator_as_method_param_cache()
-    def _get_sys_path(self, evaluator, environment=None, add_parent_paths=True):
+    @inference_state_as_method_param_cache()
+    def _get_sys_path(self, inference_state, add_parent_paths=True, add_init_paths=False):
         """
         Keep this method private for all users of jedi. However internally this
         one is used like a public method.
         """
-        suffixed = []
+        suffixed = list(self.added_sys_path)
         prefixed = []
 
-        sys_path = list(self._get_base_sys_path(evaluator, environment))
-        if self._smart_sys_path:
-            prefixed.append(self._path)
+        if self._sys_path is None:
+            sys_path = list(self._get_base_sys_path(inference_state))
+        else:
+            sys_path = list(self._sys_path)
 
-            if evaluator.script_path is not None:
-                suffixed += discover_buildout_paths(evaluator, evaluator.script_path)
+        if self._smart_sys_path:
+            prefixed.append(str(self._path))
+
+            if inference_state.script_path is not None:
+                suffixed += map(str, discover_buildout_paths(
+                    inference_state,
+                    inference_state.script_path
+                ))
 
                 if add_parent_paths:
-                    traversed = list(traverse_parents(evaluator.script_path))
+                    # Collect directories in upward search by:
+                    #   1. Skipping directories with __init__.py
+                    #   2. Stopping immediately when above self._path
+                    traversed = []
+                    for parent_path in inference_state.script_path.parents:
+                        if parent_path == self._path \
+                                or self._path not in parent_path.parents:
+                            break
+                        if not add_init_paths \
+                                and parent_path.joinpath("__init__.py").is_file():
+                            continue
+                        traversed.append(str(parent_path))
 
                     # AFAIK some libraries have imports like `foo.foo.bar`, which
                     # leads to the conclusion to by default prefer longer paths
@@ -118,80 +234,215 @@ class Project(object):
                     suffixed += reversed(traversed)
 
         if self._django:
-            prefixed.append(self._path)
+            prefixed.append(str(self._path))
 
         path = prefixed + sys_path + suffixed
-        return list(_force_unicode_list(_remove_duplicates_from_path(path)))
-
-    def save(self):
-        data = dict(self.__dict__)
-        for attribute in self._serializer_ignore_attributes:
-            data.pop(attribute, None)
-
-        with open(self._get_json_path(self._path), 'wb') as f:
-            return json.dump((_SERIALIZER_VERSION, data), f)
+        return list(_remove_duplicates_from_path(path))
 
     def get_environment(self):
         if self._environment is None:
-            return get_cached_default_environment()
-
+            if self._environment_path is not None:
+                self._environment = create_environment(self._environment_path, safe=False)
+            else:
+                self._environment = get_cached_default_environment()
         return self._environment
 
+    def search(self, string, *, all_scopes=False):
+        """
+        Searches a name in the whole project. If the project is very big,
+        at some point Jedi will stop searching. However it's also very much
+        recommended to not exhaust the generator. Just display the first ten
+        results to the user.
+
+        There are currently three different search patterns:
+
+        - ``foo`` to search for a definition foo in any file or a file called
+          ``foo.py`` or ``foo.pyi``.
+        - ``foo.bar`` to search for the ``foo`` and then an attribute ``bar``
+          in it.
+        - ``class foo.bar.Bar`` or ``def foo.bar.baz`` to search for a specific
+          API type.
+
+        :param bool all_scopes: Default False; searches not only for
+            definitions on the top level of a module level, but also in
+            functions and classes.
+        :yields: :class:`.Name`
+        """
+        return self._search_func(string, all_scopes=all_scopes)
+
+    def complete_search(self, string, **kwargs):
+        """
+        Like :meth:`.Script.search`, but completes that string. An empty string
+        lists all definitions in a project, so be careful with that.
+
+        :param bool all_scopes: Default False; searches not only for
+            definitions on the top level of a module level, but also in
+            functions and classes.
+        :yields: :class:`.Completion`
+        """
+        return self._search_func(string, complete=True, **kwargs)
+
+    @_try_to_skip_duplicates
+    def _search_func(self, string, complete=False, all_scopes=False):
+        # Using a Script is they easiest way to get an empty module context.
+        from jedi import Script
+        s = Script('', project=self)
+        inference_state = s._inference_state
+        empty_module_context = s._get_module_context()
+
+        debug.dbg('Search for string %s, complete=%s', string, complete)
+        wanted_type, wanted_names = split_search_string(string)
+        name = wanted_names[0]
+        stub_folder_name = name + '-stubs'
+
+        ios = recurse_find_python_folders_and_files(FolderIO(str(self._path)))
+        file_ios = []
+
+        # 1. Search for modules in the current project
+        for folder_io, file_io in ios:
+            if file_io is None:
+                file_name = folder_io.get_base_name()
+                if file_name == name or file_name == stub_folder_name:
+                    f = folder_io.get_file_io('__init__.py')
+                    try:
+                        m = load_module_from_path(inference_state, f).as_context()
+                    except FileNotFoundError:
+                        f = folder_io.get_file_io('__init__.pyi')
+                        try:
+                            m = load_module_from_path(inference_state, f).as_context()
+                        except FileNotFoundError:
+                            m = load_namespace_from_path(inference_state, folder_io).as_context()
+                else:
+                    continue
+            else:
+                file_ios.append(file_io)
+                if Path(file_io.path).name in (name + '.py', name + '.pyi'):
+                    m = load_module_from_path(inference_state, file_io).as_context()
+                else:
+                    continue
+
+            debug.dbg('Search of a specific module %s', m)
+            yield from search_in_module(
+                inference_state,
+                m,
+                names=[m.name],
+                wanted_type=wanted_type,
+                wanted_names=wanted_names,
+                complete=complete,
+                convert=True,
+                ignore_imports=True,
+            )
+
+        # 2. Search for identifiers in the project.
+        for module_context in search_in_file_ios(inference_state, file_ios,
+                                                 name, complete=complete):
+            names = get_module_names(module_context.tree_node, all_scopes=all_scopes)
+            names = [module_context.create_name(n) for n in names]
+            names = _remove_imports(names)
+            yield from search_in_module(
+                inference_state,
+                module_context,
+                names=names,
+                wanted_type=wanted_type,
+                wanted_names=wanted_names,
+                complete=complete,
+                ignore_imports=True,
+            )
+
+        # 3. Search for modules on sys.path
+        sys_path = [
+            p for p in self._get_sys_path(inference_state)
+            # Exclude the current folder which is handled by recursing the folders.
+            if p != self._path
+        ]
+        names = list(iter_module_names(inference_state, empty_module_context, sys_path))
+        yield from search_in_module(
+            inference_state,
+            empty_module_context,
+            names=names,
+            wanted_type=wanted_type,
+            wanted_names=wanted_names,
+            complete=complete,
+            convert=True,
+        )
+
     def __repr__(self):
         return '<%s: %s>' % (self.__class__.__name__, self._path)
 
 
 def _is_potential_project(path):
     for name in _CONTAINS_POTENTIAL_PROJECT:
-        if os.path.exists(os.path.join(path, name)):
-            return True
+        try:
+            if path.joinpath(name).exists():
+                return True
+        except OSError:
+            continue
     return False
 
 
 def _is_django_path(directory):
     """ Detects the path of the very well known Django library (if used) """
     try:
-        with open(os.path.join(directory, 'manage.py'), 'rb') as f:
+        with open(directory.joinpath('manage.py'), 'rb') as f:
             return b"DJANGO_SETTINGS_MODULE" in f.read()
     except (FileNotFoundError, IsADirectoryError, PermissionError):
         return False
 
-    return False
-
 
 def get_default_project(path=None):
-    if path is None:
-        path = os.getcwd()
+    """
+    If a project is not defined by the user, Jedi tries to define a project by
+    itself as well as possible. Jedi traverses folders until it finds one of
+    the following:
 
-    check = os.path.realpath(path)
+    1. A ``.jedi/config.json``
+    2. One of the following files: ``setup.py``, ``.git``, ``.hg``,
+       ``requirements.txt`` and ``MANIFEST.in``.
+    """
+    if path is None:
+        path = Path.cwd()
+    elif isinstance(path, str):
+        path = Path(path)
+
+    check = path.absolute()
     probable_path = None
     first_no_init_file = None
-    for dir in traverse_parents(check, include_current=True):
+    for dir in chain([check], check.parents):
         try:
             return Project.load(dir)
         except (FileNotFoundError, IsADirectoryError, PermissionError):
             pass
+        except NotADirectoryError:
+            continue
 
         if first_no_init_file is None:
-            if os.path.exists(os.path.join(dir, '__init__.py')):
+            if dir.joinpath('__init__.py').exists():
                 # In the case that a __init__.py exists, it's in 99% just a
                 # Python package and the project sits at least one level above.
                 continue
-            else:
+            elif not dir.is_file():
                 first_no_init_file = dir
 
         if _is_django_path(dir):
-            return Project(dir, _django=True)
+            project = Project(dir)
+            project._django = True
+            return project
 
         if probable_path is None and _is_potential_project(dir):
             probable_path = dir
 
     if probable_path is not None:
-        # TODO search for setup.py etc
         return Project(probable_path)
 
     if first_no_init_file is not None:
         return Project(first_no_init_file)
 
-    curdir = path if os.path.isdir(path) else os.path.dirname(path)
+    curdir = path if path.is_dir() else path.parent
     return Project(curdir)
+
+
+def _remove_imports(names):
+    return [
+        n for n in names
+        if n.tree_name is None or n.api_type not in ('module', 'namespace')
+    ]

jedi/api/refactoring/__init__.py

@@ -0,0 +1,264 @@
+import difflib
+from pathlib import Path
+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 '
+    'expr xor_expr and_expr shift_expr arith_expr term factor power atom_expr'
+).split()
+
+
+class ChangedFile:
+    def __init__(self, inference_state, from_path, to_path,
+                 module_node, node_to_str_map):
+        self._inference_state = inference_state
+        self._from_path = from_path
+        self._to_path = to_path
+        self._module_node = module_node
+        self._node_to_str_map = node_to_str_map
+
+    def get_diff(self):
+        old_lines = split_lines(self._module_node.get_code(), keepends=True)
+        new_lines = split_lines(self.get_new_code(), keepends=True)
+
+        # Add a newline at the end if it's missing. Otherwise the diff will be
+        # very weird. A `diff -u file1 file2` would show the string:
+        #
+        #     \ No newline at end of file
+        #
+        # This is not necessary IMO, because Jedi does not really play with
+        # newlines and the ending newline does not really matter in Python
+        # files. ~dave
+        if old_lines[-1] != '':
+            old_lines[-1] += '\n'
+        if new_lines[-1] != '':
+            new_lines[-1] += '\n'
+
+        project_path = self._inference_state.project.path
+        if self._from_path is None:
+            from_p = ''
+        else:
+            try:
+                from_p = self._from_path.relative_to(project_path)
+            except ValueError:  # Happens it the path is not on th project_path
+                from_p = self._from_path
+        if self._to_path is None:
+            to_p = ''
+        else:
+            try:
+                to_p = self._to_path.relative_to(project_path)
+            except ValueError:
+                to_p = self._to_path
+        diff = difflib.unified_diff(
+            old_lines, new_lines,
+            fromfile=str(from_p),
+            tofile=str(to_p),
+        )
+        # Apparently there's a space at the end of the diff - for whatever
+        # reason.
+        return ''.join(diff).rstrip(' ')
+
+    def get_new_code(self):
+        return self._inference_state.grammar.refactor(self._module_node, self._node_to_str_map)
+
+    def apply(self):
+        if self._from_path is None:
+            raise RefactoringError(
+                'Cannot apply a refactoring on a Script with path=None'
+            )
+
+        with open(self._from_path, 'w', newline='') as f:
+            f.write(self.get_new_code())
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._from_path)
+
+
+class Refactoring:
+    def __init__(self, inference_state, file_to_node_changes, renames=()):
+        self._inference_state = inference_state
+        self._renames = renames
+        self._file_to_node_changes = file_to_node_changes
+
+    def get_changed_files(self) -> Dict[Path, ChangedFile]:
+        def calculate_to_path(p):
+            if p is None:
+                return p
+            p = str(p)
+            for from_, to in renames:
+                if p.startswith(str(from_)):
+                    p = str(to) + p[len(str(from_)):]
+            return Path(p)
+
+        renames = self.get_renames()
+        return {
+            path: ChangedFile(
+                self._inference_state,
+                from_path=path,
+                to_path=calculate_to_path(path),
+                module_node=next(iter(map_)).get_root_node(),
+                node_to_str_map=map_
+            )
+            # 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]]:
+        """
+        Files can be renamed in a refactoring.
+        """
+        return sorted(self._renames)
+
+    def get_diff(self):
+        text = ''
+        project_path = self._inference_state.project.path
+        for from_, to in self.get_renames():
+            text += 'rename from %s\nrename to %s\n' \
+                % (_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())
+
+    def apply(self):
+        """
+        Applies the whole refactoring to the files, which includes renames.
+        """
+        for f in self.get_changed_files().values():
+            f.apply()
+
+        for old, new in self.get_renames():
+            old.rename(new)
+
+
+def _calculate_rename(path, new_name):
+    dir_ = path.parent
+    if path.name in ('__init__.py', '__init__.pyi'):
+        return dir_, dir_.parent.joinpath(new_name)
+    return path, dir_.joinpath(new_name + path.suffix)
+
+
+def rename(inference_state, definitions, new_name):
+    file_renames = set()
+    file_tree_name_map = {}
+
+    if not definitions:
+        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 and d.module_path is not None:
+            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:
+            if tree_name is not None:
+                fmap = file_tree_name_map.setdefault(d.module_path, {})
+                fmap[tree_name] = tree_name.prefix + new_name
+    return Refactoring(inference_state, file_tree_name_map, file_renames)
+
+
+def inline(inference_state, names):
+    if not names:
+        raise RefactoringError("There is no name under the cursor")
+    if any(n.api_type in ('module', 'namespace') for n in names):
+        raise RefactoringError("Cannot inline imports, modules or namespaces")
+    if any(n.tree_name is None for n in names):
+        raise RefactoringError("Cannot inline builtins/extensions")
+
+    definitions = [n for n in names if n.tree_name.is_definition()]
+    if len(definitions) == 0:
+        raise RefactoringError("No definition found to inline")
+    if len(definitions) > 1:
+        raise RefactoringError("Cannot inline a name with multiple definitions")
+    if len(names) == 1:
+        raise RefactoringError("There are no references to this name")
+
+    tree_name = definitions[0].tree_name
+
+    expr_stmt = tree_name.get_definition()
+    if expr_stmt.type != 'expr_stmt':
+        type_ = dict(
+            funcdef='function',
+            classdef='class',
+        ).get(expr_stmt.type, expr_stmt.type)
+        raise RefactoringError("Cannot inline a %s" % type_)
+
+    if len(expr_stmt.get_defined_names(include_setitem=True)) > 1:
+        raise RefactoringError("Cannot inline a statement with multiple definitions")
+    first_child = expr_stmt.children[1]
+    if first_child.type == 'annassign' and len(first_child.children) == 4:
+        first_child = first_child.children[2]
+    if first_child != '=':
+        if first_child.type == 'annassign':
+            raise RefactoringError(
+                'Cannot inline a statement that is defined by an annotation'
+            )
+        else:
+            raise RefactoringError(
+                'Cannot inline a statement with "%s"'
+                % first_child.get_code(include_prefix=False)
+            )
+
+    rhs = expr_stmt.get_rhs()
+    replace_code = rhs.get_code(include_prefix=False)
+
+    references = [n for n in names if not n.tree_name.is_definition()]
+    file_to_node_changes = {}
+    for name in references:
+        tree_name = name.tree_name
+        path = name.get_root_context().py__file__()
+        s = replace_code
+        if rhs.type == 'testlist_star_expr' \
+                or tree_name.parent.type in EXPRESSION_PARTS \
+                or tree_name.parent.type == 'trailer' \
+                and tree_name.parent.get_next_sibling() is not None:
+            s = '(' + replace_code + ')'
+
+        of_path = file_to_node_changes.setdefault(path, {})
+
+        n = tree_name
+        prefix = n.prefix
+        par = n.parent
+        if par.type == 'trailer' and par.children[0] == '.':
+            prefix = par.parent.children[0].prefix
+            n = par
+            for some_node in par.parent.children[:par.parent.children.index(par)]:
+                of_path[some_node] = ''
+        of_path[n] = prefix + s
+
+    path = definitions[0].get_root_context().py__file__()
+    changes = file_to_node_changes.setdefault(path, {})
+    changes[expr_stmt] = _remove_indent_of_prefix(expr_stmt.get_first_leaf().prefix)
+    next_leaf = expr_stmt.get_next_leaf()
+
+    # Most of the time we have to remove the newline at the end of the
+    # statement, but if there's a comment we might not need to.
+    if next_leaf.prefix.strip(' \t') == '' \
+            and (next_leaf.type == 'newline' or next_leaf == ';'):
+        changes[next_leaf] = ''
+    return Refactoring(inference_state, file_to_node_changes)
+
+
+def _remove_indent_of_prefix(prefix):
+    r"""
+    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/refactoring/extract.py

@@ -0,0 +1,386 @@
+from textwrap import dedent
+
+from parso import split_lines
+
+from jedi import debug
+from jedi.api.exceptions import RefactoringError
+from jedi.api.refactoring import Refactoring, EXPRESSION_PARTS
+from jedi.common import indent_block
+from jedi.parser_utils import function_is_classmethod, function_is_staticmethod
+
+
+_DEFINITION_SCOPES = ('suite', 'file_input')
+_VARIABLE_EXCTRACTABLE = EXPRESSION_PARTS + \
+    ('atom testlist_star_expr testlist test lambdef lambdef_nocond '
+     'keyword name number string fstring').split()
+
+
+def extract_variable(inference_state, path, module_node, name, pos, until_pos):
+    nodes = _find_nodes(module_node, pos, until_pos)
+    debug.dbg('Extracting nodes: %s', nodes)
+
+    is_expression, message = _is_expression_with_error(nodes)
+    if not is_expression:
+        raise RefactoringError(message)
+
+    generated_code = name + ' = ' + _expression_nodes_to_string(nodes)
+    file_to_node_changes = {path: _replace(nodes, name, generated_code, pos)}
+    return Refactoring(inference_state, file_to_node_changes)
+
+
+def _is_expression_with_error(nodes):
+    """
+    Returns a tuple (is_expression, error_string).
+    """
+    if any(node.type == 'name' and node.is_definition() for node in nodes):
+        return False, 'Cannot extract a name that defines something'
+
+    if nodes[0].type not in _VARIABLE_EXCTRACTABLE:
+        return False, 'Cannot extract a "%s"' % nodes[0].type
+    return True, ''
+
+
+def _find_nodes(module_node, pos, until_pos):
+    """
+    Looks up a module and tries to find the appropriate amount of nodes that
+    are in there.
+    """
+    start_node = module_node.get_leaf_for_position(pos, include_prefixes=True)
+
+    if until_pos is None:
+        if start_node.type == 'operator':
+            next_leaf = start_node.get_next_leaf()
+            if next_leaf is not None and next_leaf.start_pos == pos:
+                start_node = next_leaf
+
+        if _is_not_extractable_syntax(start_node):
+            start_node = start_node.parent
+
+        if start_node.parent.type == 'trailer':
+            start_node = start_node.parent.parent
+        while start_node.parent.type in EXPRESSION_PARTS:
+            start_node = start_node.parent
+
+        nodes = [start_node]
+    else:
+        # Get the next leaf if we are at the end of a leaf
+        if start_node.end_pos == pos:
+            next_leaf = start_node.get_next_leaf()
+            if next_leaf is not None:
+                start_node = next_leaf
+
+        # Some syntax is not exactable, just use its parent
+        if _is_not_extractable_syntax(start_node):
+            start_node = start_node.parent
+
+        # Find the end
+        end_leaf = module_node.get_leaf_for_position(until_pos, include_prefixes=True)
+        if end_leaf.start_pos > until_pos:
+            end_leaf = end_leaf.get_previous_leaf()
+            if end_leaf is None:
+                raise RefactoringError('Cannot extract anything from that')
+
+        parent_node = start_node
+        while parent_node.end_pos < end_leaf.end_pos:
+            parent_node = parent_node.parent
+
+        nodes = _remove_unwanted_expression_nodes(parent_node, pos, until_pos)
+
+    # If the user marks just a return statement, we return the expression
+    # instead of the whole statement, because the user obviously wants to
+    # extract that part.
+    if len(nodes) == 1 and start_node.type in ('return_stmt', 'yield_expr'):
+        return [nodes[0].children[1]]
+    return nodes
+
+
+def _replace(nodes, expression_replacement, extracted, pos,
+             insert_before_leaf=None, remaining_prefix=None):
+    # Now try to replace the nodes found with a variable and move the code
+    # before the current statement.
+    definition = _get_parent_definition(nodes[0])
+    if insert_before_leaf is None:
+        insert_before_leaf = definition.get_first_leaf()
+    first_node_leaf = nodes[0].get_first_leaf()
+
+    lines = split_lines(insert_before_leaf.prefix, keepends=True)
+    if first_node_leaf is insert_before_leaf:
+        if remaining_prefix is not None:
+            # The remaining prefix has already been calculated.
+            lines[:-1] = remaining_prefix
+    lines[-1:-1] = [indent_block(extracted, lines[-1]) + '\n']
+    extracted_prefix = ''.join(lines)
+
+    replacement_dct = {}
+    if first_node_leaf is insert_before_leaf:
+        replacement_dct[nodes[0]] = extracted_prefix + expression_replacement
+    else:
+        if remaining_prefix is None:
+            p = first_node_leaf.prefix
+        else:
+            p = remaining_prefix + _get_indentation(nodes[0])
+        replacement_dct[nodes[0]] = p + expression_replacement
+        replacement_dct[insert_before_leaf] = extracted_prefix + insert_before_leaf.value
+
+    for node in nodes[1:]:
+        replacement_dct[node] = ''
+    return replacement_dct
+
+
+def _expression_nodes_to_string(nodes):
+    return ''.join(n.get_code(include_prefix=i != 0) for i, n in enumerate(nodes))
+
+
+def _suite_nodes_to_string(nodes, pos):
+    n = nodes[0]
+    prefix, part_of_code = _split_prefix_at(n.get_first_leaf(), pos[0] - 1)
+    code = part_of_code + n.get_code(include_prefix=False) \
+        + ''.join(n.get_code() for n in nodes[1:])
+    return prefix, code
+
+
+def _split_prefix_at(leaf, until_line):
+    """
+    Returns a tuple of the leaf's prefix, split at the until_line
+    position.
+    """
+    # second means the second returned part
+    second_line_count = leaf.start_pos[0] - until_line
+    lines = split_lines(leaf.prefix, keepends=True)
+    return ''.join(lines[:-second_line_count]), ''.join(lines[-second_line_count:])
+
+
+def _get_indentation(node):
+    return split_lines(node.get_first_leaf().prefix)[-1]
+
+
+def _get_parent_definition(node):
+    """
+    Returns the statement where a node is defined.
+    """
+    while node is not None:
+        if node.parent.type in _DEFINITION_SCOPES:
+            return node
+        node = node.parent
+    raise NotImplementedError('We should never even get here')
+
+
+def _remove_unwanted_expression_nodes(parent_node, pos, until_pos):
+    """
+    This function makes it so for `1 * 2 + 3` you can extract `2 + 3`, even
+    though it is not part of the expression.
+    """
+    typ = parent_node.type
+    is_suite_part = typ in ('suite', 'file_input')
+    if typ in EXPRESSION_PARTS or is_suite_part:
+        nodes = parent_node.children
+        for i, n in enumerate(nodes):
+            if n.end_pos > pos:
+                start_index = i
+                if n.type == 'operator':
+                    start_index -= 1
+                break
+        for i, n in reversed(list(enumerate(nodes))):
+            if n.start_pos < until_pos:
+                end_index = i
+                if n.type == 'operator':
+                    end_index += 1
+
+                # Something like `not foo or bar` should not be cut after not
+                for n2 in nodes[i:]:
+                    if _is_not_extractable_syntax(n2):
+                        end_index += 1
+                    else:
+                        break
+                break
+        nodes = nodes[start_index:end_index + 1]
+        if not is_suite_part:
+            nodes[0:1] = _remove_unwanted_expression_nodes(nodes[0], pos, until_pos)
+            nodes[-1:] = _remove_unwanted_expression_nodes(nodes[-1], pos, until_pos)
+        return nodes
+    return [parent_node]
+
+
+def _is_not_extractable_syntax(node):
+    return node.type == 'operator' \
+        or node.type == 'keyword' and node.value not in ('None', 'True', 'False')
+
+
+def extract_function(inference_state, path, module_context, name, pos, until_pos):
+    nodes = _find_nodes(module_context.tree_node, pos, until_pos)
+    assert len(nodes)
+
+    is_expression, _ = _is_expression_with_error(nodes)
+    context = module_context.create_context(nodes[0])
+    is_bound_method = context.is_bound_method()
+    params, return_variables = list(_find_inputs_and_outputs(module_context, context, nodes))
+
+    # Find variables
+    # Is a class method / method
+    if context.is_module():
+        insert_before_leaf = None  # Leaf will be determined later
+    else:
+        node = _get_code_insertion_node(context.tree_node, is_bound_method)
+        insert_before_leaf = node.get_first_leaf()
+    if is_expression:
+        code_block = 'return ' + _expression_nodes_to_string(nodes) + '\n'
+        remaining_prefix = None
+        has_ending_return_stmt = False
+    else:
+        has_ending_return_stmt = _is_node_ending_return_stmt(nodes[-1])
+        if not has_ending_return_stmt:
+            # Find the actually used variables (of the defined ones). If none are
+            # used (e.g. if the range covers the whole function), return the last
+            # defined variable.
+            return_variables = list(_find_needed_output_variables(
+                context,
+                nodes[0].parent,
+                nodes[-1].end_pos,
+                return_variables
+            )) or [return_variables[-1]] if return_variables else []
+
+        remaining_prefix, code_block = _suite_nodes_to_string(nodes, pos)
+        after_leaf = nodes[-1].get_next_leaf()
+        first, second = _split_prefix_at(after_leaf, until_pos[0])
+        code_block += first
+
+        code_block = dedent(code_block)
+        if not has_ending_return_stmt:
+            output_var_str = ', '.join(return_variables)
+            code_block += 'return ' + output_var_str + '\n'
+
+    # Check if we have to raise RefactoringError
+    _check_for_non_extractables(nodes[:-1] if has_ending_return_stmt else nodes)
+
+    decorator = ''
+    self_param = None
+    if is_bound_method:
+        if not function_is_staticmethod(context.tree_node):
+            function_param_names = context.get_value().get_param_names()
+            if len(function_param_names):
+                self_param = function_param_names[0].string_name
+                params = [p for p in params if p != self_param]
+
+        if function_is_classmethod(context.tree_node):
+            decorator = '@classmethod\n'
+    else:
+        code_block += '\n'
+
+    function_code = '%sdef %s(%s):\n%s' % (
+        decorator,
+        name,
+        ', '.join(params if self_param is None else [self_param] + params),
+        indent_block(code_block)
+    )
+
+    function_call = '%s(%s)' % (
+        ('' if self_param is None else self_param + '.') + name,
+        ', '.join(params)
+    )
+    if is_expression:
+        replacement = function_call
+    else:
+        if has_ending_return_stmt:
+            replacement = 'return ' + function_call + '\n'
+        else:
+            replacement = output_var_str + ' = ' + function_call + '\n'
+
+    replacement_dct = _replace(nodes, replacement, function_code, pos,
+                               insert_before_leaf, remaining_prefix)
+    if not is_expression:
+        replacement_dct[after_leaf] = second + after_leaf.value
+    file_to_node_changes = {path: replacement_dct}
+    return Refactoring(inference_state, file_to_node_changes)
+
+
+def _check_for_non_extractables(nodes):
+    for n in nodes:
+        try:
+            children = n.children
+        except AttributeError:
+            if n.value == 'return':
+                raise RefactoringError(
+                    'Can only extract return statements if they are at the end.')
+            if n.value == 'yield':
+                raise RefactoringError('Cannot extract yield statements.')
+        else:
+            _check_for_non_extractables(children)
+
+
+def _is_name_input(module_context, names, first, last):
+    for name in names:
+        if name.api_type == 'param' or not name.parent_context.is_module():
+            if name.get_root_context() is not module_context:
+                return True
+            if name.start_pos is None or not (first <= name.start_pos < last):
+                return True
+    return False
+
+
+def _find_inputs_and_outputs(module_context, context, nodes):
+    first = nodes[0].start_pos
+    last = nodes[-1].end_pos
+
+    inputs = []
+    outputs = []
+    for name in _find_non_global_names(nodes):
+        if name.is_definition():
+            if name not in outputs:
+                outputs.append(name.value)
+        else:
+            if name.value not in inputs:
+                name_definitions = context.goto(name, name.start_pos)
+                if not name_definitions \
+                        or _is_name_input(module_context, name_definitions, first, last):
+                    inputs.append(name.value)
+
+    # Check if outputs are really needed:
+    return inputs, outputs
+
+
+def _find_non_global_names(nodes):
+    for node in nodes:
+        try:
+            children = node.children
+        except AttributeError:
+            if node.type == 'name':
+                yield node
+        else:
+            # We only want to check foo in foo.bar
+            if node.type == 'trailer' and node.children[0] == '.':
+                continue
+
+            yield from _find_non_global_names(children)
+
+
+def _get_code_insertion_node(node, is_bound_method):
+    if not is_bound_method or function_is_staticmethod(node):
+        while node.parent.type != 'file_input':
+            node = node.parent
+
+    while node.parent.type in ('async_funcdef', 'decorated', 'async_stmt'):
+        node = node.parent
+    return node
+
+
+def _find_needed_output_variables(context, search_node, at_least_pos, return_variables):
+    """
+    Searches everything after at_least_pos in a node and checks if any of the
+    return_variables are used in there and returns those.
+    """
+    for node in search_node.children:
+        if node.start_pos < at_least_pos:
+            continue
+
+        return_variables = set(return_variables)
+        for name in _find_non_global_names([node]):
+            if not name.is_definition() and name.value in return_variables:
+                return_variables.remove(name.value)
+                yield name.value
+
+
+def _is_node_ending_return_stmt(node):
+    t = node.type
+    if t == 'simple_stmt':
+        return _is_node_ending_return_stmt(node.children[0])
+    return t == 'return_stmt'

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 2.7.2+ (default, Jul 20 2012, 22:15:08)
+    Python 3.9.2+ (default, Jul 20 2020, 22:15:08)
     [GCC 4.6.1] on linux2
     Type "help", "copyright", "credits" or "license" for more information.
     >>> import os
@@ -21,7 +21,7 @@ import jedi.utils
 from jedi import __version__ as __jedi_version__
 
 print('REPL completion using Jedi %s' % __jedi_version__)
-jedi.utils.setup_readline()
+jedi.utils.setup_readline(fuzzy=False)
 
 del jedi
 

jedi/api/strings.py

@@ -0,0 +1,111 @@
+"""
+This module is here for string completions. This means mostly stuff where
+strings are returned, like `foo = dict(bar=3); foo["ba` would complete to
+`"bar"]`.
+
+It however does the same for numbers. The difference between string completions
+and other completions is mostly that this module doesn't return defined
+names in a module, but pretty much an arbitrary string.
+"""
+import re
+
+from jedi.inference.names import AbstractArbitraryName
+from jedi.inference.helpers import infer_call_of_leaf
+from jedi.api.classes import Completion
+from jedi.parser_utils import cut_value_at_position
+
+_sentinel = object()
+
+
+class StringName(AbstractArbitraryName):
+    api_type = 'string'
+    is_value_name = False
+
+
+def complete_dict(module_context, code_lines, leaf, position, string, fuzzy):
+    bracket_leaf = leaf
+    if bracket_leaf != '[':
+        bracket_leaf = leaf.get_previous_leaf()
+
+    cut_end_quote = ''
+    if string:
+        cut_end_quote = get_quote_ending(string, code_lines, position, invert_result=True)
+
+    if bracket_leaf == '[':
+        if string is None and leaf is not bracket_leaf:
+            string = cut_value_at_position(leaf, position)
+
+        context = module_context.create_context(bracket_leaf)
+
+        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,
+                values,
+                '' if string is None else string,
+                cut_end_quote,
+                fuzzy=fuzzy,
+            ))
+    return []
+
+
+def _completions_for_dicts(inference_state, dicts, literal_string, cut_end_quote, fuzzy):
+    for dict_key in sorted(_get_python_keys(dicts), key=lambda x: repr(x)):
+        dict_key_str = _create_repr_string(literal_string, dict_key)
+        if dict_key_str.startswith(literal_string):
+            name = StringName(inference_state, dict_key_str[:-len(cut_end_quote) or None])
+            yield Completion(
+                inference_state,
+                name,
+                stack=None,
+                like_name_length=len(literal_string),
+                is_fuzzy=fuzzy
+            )
+
+
+def _create_repr_string(literal_string, dict_key):
+    if not isinstance(dict_key, (str, bytes)) or not literal_string:
+        return repr(dict_key)
+
+    r = repr(dict_key)
+    prefix, quote = _get_string_prefix_and_quote(literal_string)
+    if quote is None:
+        return r
+    if quote == r[0]:
+        return prefix + r
+    return prefix + quote + r[1:-1] + quote
+
+
+def _get_python_keys(dicts):
+    for dct in dicts:
+        if dct.array_type == 'dict':
+            for key in dct.get_key_values():
+                dict_key = key.get_safe_value(default=_sentinel)
+                if dict_key is not _sentinel:
+                    yield dict_key
+
+
+def _get_string_prefix_and_quote(string):
+    match = re.match(r'(\w*)("""|\'{3}|"|\')', string)
+    if match is None:
+        return None, None
+    return match.group(1), match.group(2)
+
+
+def _matches_quote_at_position(code_lines, quote, position):
+    string = code_lines[position[0] - 1][position[1]:position[1] + len(quote)]
+    return string == quote
+
+
+def get_quote_ending(string, code_lines, position, invert_result=False):
+    _, quote = _get_string_prefix_and_quote(string)
+    if quote is None:
+        return ''
+
+    # Add a quote only if it's not already there.
+    if _matches_quote_at_position(code_lines, quote, position) != invert_result:
+        return ''
+    return quote

jedi/cache.py

@@ -13,46 +13,15 @@ these variables are being cleaned after every API usage.
 """
 import time
 from functools import wraps
+from typing import Any, Dict, Tuple
 
 from jedi import settings
 from parso.cache import parser_cache
 
-_time_caches = {}
+_time_caches: Dict[str, Dict[Any, Tuple[float, Any]]] = {}
 
 
-def underscore_memoization(func):
-    """
-    Decorator for methods::
-
-        class A(object):
-            def x(self):
-                if self._x:
-                    self._x = 10
-                return self._x
-
-    Becomes::
-
-        class A(object):
-            @underscore_memoization
-            def x(self):
-                return 10
-
-    A now has an attribute ``_x`` written by this decorator.
-    """
-    name = '_' + func.__name__
-
-    def wrapper(self):
-        try:
-            return getattr(self, name)
-        except AttributeError:
-            result = func(self)
-            setattr(self, name, result)
-            return result
-
-    return wrapper
-
-
-def clear_time_caches(delete_all=False):
+def clear_time_caches(delete_all: bool = False) -> None:
     """ Jedi caches many things, that should be completed after each completion
     finishes.
 
@@ -75,7 +44,7 @@ def clear_time_caches(delete_all=False):
                     del tc[key]
 
 
-def call_signature_time_cache(time_add_setting):
+def signature_time_cache(time_add_setting):
     """
     This decorator works as follows: Call it with a setting and after that
     use the function with a callable that returns the key.

jedi/common.py

@@ -0,0 +1,24 @@
+from contextlib import contextmanager
+
+
+@contextmanager
+def monkeypatch(obj, attribute_name, new_value):
+    """
+    Like pytest's monkeypatch, but as a value manager.
+    """
+    old_value = getattr(obj, attribute_name)
+    try:
+        setattr(obj, attribute_name, new_value)
+        yield
+    finally:
+        setattr(obj, attribute_name, old_value)
+
+
+def indent_block(text, indention='    '):
+    """This function indents a text block with a default of four spaces."""
+    temp = ''
+    while text and text[-1] == '\n':
+        temp += text[-1]
+        text = text[:-1]
+    lines = text.split('\n')
+    return '\n'.join(map(lambda s: indention + s, lines)) + temp

jedi/common/__init__.py

@@ -1 +0,0 @@
-from jedi.common.context import BaseContextSet, BaseContext

jedi/common/context.py

@@ -1,73 +0,0 @@
-class BaseContext(object):
-    def __init__(self, evaluator, parent_context=None):
-        self.evaluator = evaluator
-        self.parent_context = parent_context
-
-    def get_root_context(self):
-        context = self
-        while True:
-            if context.parent_context is None:
-                return context
-            context = context.parent_context
-
-
-class BaseContextSet(object):
-    def __init__(self, iterable):
-        self._set = frozenset(iterable)
-        for context in iterable:
-            assert not isinstance(context, BaseContextSet)
-
-    @classmethod
-    def _from_frozen_set(cls, frozenset_):
-        self = cls.__new__(cls)
-        self._set = frozenset_
-        return self
-
-    @classmethod
-    def from_sets(cls, sets):
-        """
-        Used to work with an iterable of set.
-        """
-        aggregated = set()
-        for set_ in sets:
-            if isinstance(set_, BaseContextSet):
-                aggregated |= set_._set
-            else:
-                aggregated |= frozenset(set_)
-        return cls._from_frozen_set(frozenset(aggregated))
-
-    def __or__(self, other):
-        return self._from_frozen_set(self._set | other._set)
-
-    def __and__(self, other):
-        return self._from_frozen_set(self._set & other._set)
-
-    def __iter__(self):
-        for element in self._set:
-            yield element
-
-    def __bool__(self):
-        return bool(self._set)
-
-    def __len__(self):
-        return len(self._set)
-
-    def __repr__(self):
-        return 'S{%s}' % (', '.join(str(s) for s in self._set))
-
-    def filter(self, filter_func):
-        return self.__class__(filter(filter_func, self._set))
-
-    def __getattr__(self, name):
-        def mapper(*args, **kwargs):
-            return self.from_sets(
-                getattr(context, name)(*args, **kwargs)
-                for context in self._set
-            )
-        return mapper
-
-    def __eq__(self, other):
-        return self._set == other._set
-
-    def __hash__(self):
-        return hash(self._set)

jedi/common/utils.py

@@ -1,26 +0,0 @@
-import os
-from contextlib import contextmanager
-
-
-def traverse_parents(path, include_current=False):
-    if not include_current:
-        path = os.path.dirname(path)
-
-    previous = None
-    while previous != path:
-        yield path
-        previous = path
-        path = os.path.dirname(path)
-
-
-@contextmanager
-def monkeypatch(obj, attribute_name, new_value):
-    """
-    Like pytest's monkeypatch, but as a context manager.
-    """
-    old_value = getattr(obj, attribute_name)
-    try:
-        setattr(obj, attribute_name, new_value)
-        yield
-    finally:
-        setattr(obj, attribute_name, old_value)

jedi/debug.py

@@ -1,8 +1,7 @@
 import os
 import time
 from contextlib import contextmanager
-
-from jedi._compatibility import encoding, is_py3, u
+from typing import Callable, Optional
 
 _inited = False
 
@@ -22,7 +21,7 @@ try:
         raise ImportError
     else:
         # Use colorama for nicer console output.
-        from colorama import Fore, init
+        from colorama import Fore, init  # type: ignore[import]
         from colorama import initialise
 
         def _lazy_colorama_init():  # noqa: F811
@@ -47,7 +46,7 @@ try:
             _inited = True
 
 except ImportError:
-    class Fore(object):
+    class Fore:  # type: ignore[no-redef]
         RED = ''
         GREEN = ''
         YELLOW = ''
@@ -64,7 +63,7 @@ enable_warning = False
 enable_notice = False
 
 # callback, interface: level, str
-debug_function = None
+debug_function: Optional[Callable[[str, str], None]] = None
 _debug_indent = 0
 _start_time = time.time()
 
@@ -84,39 +83,34 @@ def increase_indent(func):
 
 
 @contextmanager
-def increase_indent_cm(title=None):
+def increase_indent_cm(title=None, color='MAGENTA'):
     global _debug_indent
     if title:
-        dbg('Start: ' + title, color='MAGENTA')
+        dbg('Start: ' + title, color=color)
     _debug_indent += 1
     try:
         yield
     finally:
         _debug_indent -= 1
         if title:
-            dbg('End: ' + title, color='MAGENTA')
+            dbg('End: ' + title, color=color)
 
 
-def dbg(message, *args, **kwargs):
+def dbg(message, *args, color='GREEN'):
     """ Looks at the stack, to see if a debug message should be printed. """
-    # Python 2 compatibility, because it doesn't understand default args
-    color = kwargs.pop('color', 'GREEN')
     assert color
 
     if debug_function and enable_notice:
         i = ' ' * _debug_indent
         _lazy_colorama_init()
-        debug_function(color, i + 'dbg: ' + message % tuple(u(repr(a)) for a in args))
+        debug_function(color, i + 'dbg: ' + message % tuple(repr(a) for a in args))
 
 
-def warning(message, *args, **kwargs):
-    format = kwargs.pop('format', True)
-    assert not kwargs
-
+def warning(message, *args, format=True):
     if debug_function and enable_warning:
         i = ' ' * _debug_indent
         if format:
-            message = message % tuple(u(repr(a)) for a in args)
+            message = message % tuple(repr(a) for a in args)
         debug_function('RED', i + 'warning: ' + message)
 
 
@@ -135,9 +129,4 @@ def print_to_stdout(color, str_out):
     """
     col = getattr(Fore, color)
     _lazy_colorama_init()
-    if not is_py3:
-        str_out = str_out.encode(encoding, 'replace')
     print(col + str_out + Fore.RESET)
-
-
-# debug_function = print_to_stdout

jedi/evaluate/__init__.py

@@ -1,443 +0,0 @@
-"""
-Evaluation of Python code in |jedi| is based on three assumptions:
-
-* The code uses as least side effects as possible. Jedi understands certain
-  list/tuple/set modifications, but there's no guarantee that Jedi detects
-  everything (list.append in different modules for example).
-* No magic is being used:
-
-  - metaclasses
-  - ``setattr()`` / ``__import__()``
-  - writing to ``globals()``, ``locals()``, ``object.__dict__``
-* The programmer is not a total dick, e.g. like `this
-  <https://github.com/davidhalter/jedi/issues/24>`_ :-)
-
-The actual algorithm is based on a principle called lazy evaluation.  That
-said, the typical entry point for static analysis is calling
-``eval_expr_stmt``. There's separate logic for autocompletion in the API, the
-evaluator is all about evaluating an expression.
-
-TODO this paragraph is not what jedi does anymore, it's similar, but not the
-same.
-
-Now you need to understand what follows after ``eval_expr_stmt``. Let's
-make an example::
-
-    import datetime
-    datetime.date.toda# <-- cursor here
-
-First of all, this module doesn't care about completion. It really just cares
-about ``datetime.date``. At the end of the procedure ``eval_expr_stmt`` will
-return the ``date`` class.
-
-To *visualize* this (simplified):
-
-- ``Evaluator.eval_expr_stmt`` doesn't do much, because there's no assignment.
-- ``Context.eval_node`` cares for resolving the dotted path
-- ``Evaluator.find_types`` searches for global definitions of datetime, which
-  it finds in the definition of an import, by scanning the syntax tree.
-- Using the import logic, the datetime module is found.
-- Now ``find_types`` is called again by ``eval_node`` to find ``date``
-  inside the datetime module.
-
-Now what would happen if we wanted ``datetime.date.foo.bar``? Two more
-calls to ``find_types``. However the second call would be ignored, because the
-first one would return nothing (there's no foo attribute in ``date``).
-
-What if the import would contain another ``ExprStmt`` like this::
-
-    from foo import bar
-    Date = bar.baz
-
-Well... You get it. Just another ``eval_expr_stmt`` recursion. It's really
-easy. Python can obviously get way more complicated then this. To understand
-tuple assignments, list comprehensions and everything else, a lot more code had
-to be written.
-
-Jedi has been tested very well, so you can just start modifying code. It's best
-to write your own test first for your "new" feature. Don't be scared of
-breaking stuff. As long as the tests pass, you're most likely to be fine.
-
-I need to mention now that lazy evaluation is really good because it
-only *evaluates* what needs to be *evaluated*. All the statements and modules
-that are not used are just being ignored.
-"""
-from parso.python import tree
-import parso
-from parso import python_bytes_to_unicode
-from jedi.file_io import FileIO
-
-from jedi import debug
-from jedi import parser_utils
-from jedi.evaluate.utils import unite
-from jedi.evaluate import imports
-from jedi.evaluate import recursion
-from jedi.evaluate.cache import evaluator_function_cache
-from jedi.evaluate import helpers
-from jedi.evaluate.names import TreeNameDefinition, ParamName
-from jedi.evaluate.base_context import ContextualizedName, ContextualizedNode, \
-    ContextSet, NO_CONTEXTS, iterate_contexts
-from jedi.evaluate.context import ClassContext, FunctionContext, \
-    AnonymousInstance, BoundMethod
-from jedi.evaluate.context.iterable import CompForContext
-from jedi.evaluate.syntax_tree import eval_trailer, eval_expr_stmt, \
-    eval_node, check_tuple_assignments
-from jedi.plugins import plugin_manager
-
-
-class Evaluator(object):
-    def __init__(self, project, environment=None, script_path=None):
-        if environment is None:
-            environment = project.get_environment()
-        self.environment = environment
-        self.script_path = script_path
-        self.compiled_subprocess = environment.get_evaluator_subprocess(self)
-        self.grammar = environment.get_grammar()
-
-        self.latest_grammar = parso.load_grammar(version='3.7')
-        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[ModuleContext]]
-        self.compiled_cache = {}  # see `evaluate.compiled.create()`
-        self.inferred_element_counts = {}
-        self.mixed_cache = {}  # see `evaluate.compiled.mixed._create()`
-        self.analysis = []
-        self.dynamic_params_depth = 0
-        self.is_analysis = False
-        self.project = project
-        self.access_cache = {}
-        self.allow_descriptor_getattr = False
-
-        self.reset_recursion_limitations()
-        self.allow_different_encoding = True
-
-    def import_module(self, import_names, parent_module_context=None,
-                      sys_path=None, prefer_stubs=True):
-        if sys_path is None:
-            sys_path = self.get_sys_path()
-        return imports.import_module(self, import_names, parent_module_context,
-                                     sys_path, prefer_stubs=prefer_stubs)
-
-    @staticmethod
-    @plugin_manager.decorate()
-    def execute(context, arguments):
-        debug.dbg('execute: %s %s', context, arguments)
-        with debug.increase_indent_cm():
-            context_set = context.py__call__(arguments=arguments)
-        debug.dbg('execute result: %s in %s', context_set, context)
-        return context_set
-
-    @property
-    @evaluator_function_cache()
-    def builtins_module(self):
-        module_name = u'builtins'
-        if self.environment.version_info.major == 2:
-            module_name = u'__builtin__'
-        builtins_module, = self.import_module((module_name,), sys_path=())
-        return builtins_module
-
-    @property
-    @evaluator_function_cache()
-    def typing_module(self):
-        typing_module, = self.import_module((u'typing',))
-        return typing_module
-
-    def reset_recursion_limitations(self):
-        self.recursion_detector = recursion.RecursionDetector()
-        self.execution_recursion_detector = recursion.ExecutionRecursionDetector(self)
-
-    def get_sys_path(self, **kwargs):
-        """Convenience function"""
-        return self.project._get_sys_path(self, environment=self.environment, **kwargs)
-
-    def eval_element(self, context, element):
-        if isinstance(context, CompForContext):
-            return eval_node(context, element)
-
-        if_stmt = element
-        while if_stmt is not None:
-            if_stmt = if_stmt.parent
-            if if_stmt.type in ('if_stmt', 'for_stmt'):
-                break
-            if parser_utils.is_scope(if_stmt):
-                if_stmt = None
-                break
-        predefined_if_name_dict = context.predefined_names.get(if_stmt)
-        # TODO there's a lot of issues with this one. We actually should do
-        # this in a different way. Caching should only be active in certain
-        # cases and this all sucks.
-        if predefined_if_name_dict is None and if_stmt \
-                and if_stmt.type == 'if_stmt' and self.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
-            # context.predefined_names is filled, we stop.
-            # We don't want to check the if stmt itself, it's just about
-            # the content.
-            if element.start_pos > if_stmt_test.end_pos:
-                # Now we need to check if the names in the if_stmt match the
-                # names in the suite.
-                if_names = helpers.get_names_of_node(if_stmt_test)
-                element_names = helpers.get_names_of_node(element)
-                str_element_names = [e.value for e in element_names]
-                if any(i.value in str_element_names for i in if_names):
-                    for if_name in if_names:
-                        definitions = self.goto_definitions(context, if_name)
-                        # Every name that has multiple different definitions
-                        # causes the complexity to rise. The complexity should
-                        # never fall below 1.
-                        if len(definitions) > 1:
-                            if len(name_dicts) * len(definitions) > 16:
-                                debug.dbg('Too many options for if branch evaluation %s.', if_stmt)
-                                # There's only a certain amount of branches
-                                # Jedi can evaluate, otherwise it will take to
-                                # long.
-                                name_dicts = [{}]
-                                break
-
-                            original_name_dicts = list(name_dicts)
-                            name_dicts = []
-                            for definition in definitions:
-                                new_name_dicts = list(original_name_dicts)
-                                for i, name_dict in enumerate(new_name_dicts):
-                                    new_name_dicts[i] = name_dict.copy()
-                                    new_name_dicts[i][if_name.value] = ContextSet([definition])
-
-                                name_dicts += new_name_dicts
-                        else:
-                            for name_dict in name_dicts:
-                                name_dict[if_name.value] = definitions
-            if len(name_dicts) > 1:
-                result = NO_CONTEXTS
-                for name_dict in name_dicts:
-                    with helpers.predefine_names(context, if_stmt, name_dict):
-                        result |= eval_node(context, element)
-                return result
-            else:
-                return self._eval_element_if_evaluated(context, element)
-        else:
-            if predefined_if_name_dict:
-                return eval_node(context, element)
-            else:
-                return self._eval_element_if_evaluated(context, element)
-
-    def _eval_element_if_evaluated(self, context, element):
-        """
-        TODO This function is temporary: Merge with eval_element.
-        """
-        parent = element
-        while parent is not None:
-            parent = parent.parent
-            predefined_if_name_dict = context.predefined_names.get(parent)
-            if predefined_if_name_dict is not None:
-                return eval_node(context, element)
-        return self._eval_element_cached(context, element)
-
-    @evaluator_function_cache(default=NO_CONTEXTS)
-    def _eval_element_cached(self, context, element):
-        return eval_node(context, element)
-
-    def goto_definitions(self, context, name):
-        def_ = name.get_definition(import_name_always=True)
-        if def_ is not None:
-            type_ = def_.type
-            is_classdef = type_ == 'classdef'
-            if is_classdef or type_ == 'funcdef':
-                if is_classdef:
-                    c = ClassContext(self, context, name.parent)
-                else:
-                    c = FunctionContext.from_context(context, name.parent)
-                return ContextSet([c])
-
-            if type_ == 'expr_stmt':
-                is_simple_name = name.parent.type not in ('power', 'trailer')
-                if is_simple_name:
-                    return eval_expr_stmt(context, def_, name)
-            if type_ == 'for_stmt':
-                container_types = context.eval_node(def_.children[3])
-                cn = ContextualizedNode(context, def_.children[3])
-                for_types = iterate_contexts(container_types, cn)
-                c_node = ContextualizedName(context, name)
-                return check_tuple_assignments(self, c_node, for_types)
-            if type_ in ('import_from', 'import_name'):
-                return imports.infer_import(context, name)
-        else:
-            result = self._follow_error_node_imports_if_possible(context, name)
-            if result is not None:
-                return result
-
-        return helpers.evaluate_call_of_leaf(context, name)
-
-    def _follow_error_node_imports_if_possible(self, context, name):
-        error_node = tree.search_ancestor(name, '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
-            # for ; leaves that start a new statements.
-            start_index = 0
-            for index, n in enumerate(error_node.children):
-                if n.start_pos > name.start_pos:
-                    break
-                if n == ';':
-                    start_index = index + 1
-            nodes = error_node.children[start_index:]
-            first_name = nodes[0].get_first_leaf().value
-
-            # Make it possible to infer stuff like `import foo.` or
-            # `from foo.bar`.
-            if first_name in ('from', 'import'):
-                is_import_from = first_name == 'from'
-                level, names = helpers.parse_dotted_names(
-                    nodes,
-                    is_import_from=is_import_from,
-                    until_node=name,
-                )
-                return imports.Importer(self, names, context.get_root_context(), level).follow()
-        return None
-
-    def goto(self, context, name):
-        definition = name.get_definition(import_name_always=True)
-        if definition is not None:
-            type_ = definition.type
-            if type_ == 'expr_stmt':
-                # Only take the parent, because if it's more complicated than just
-                # a name it's something you can "goto" again.
-                is_simple_name = name.parent.type not in ('power', 'trailer')
-                if is_simple_name:
-                    return [TreeNameDefinition(context, name)]
-            elif type_ == 'param':
-                return [ParamName(context, name)]
-            elif type_ in ('import_from', 'import_name'):
-                module_names = imports.infer_import(context, name, is_goto=True)
-                return module_names
-            else:
-                return [TreeNameDefinition(context, name)]
-        else:
-            contexts = self._follow_error_node_imports_if_possible(context, name)
-            if contexts is not None:
-                return [context.name for context in contexts]
-
-        par = name.parent
-        node_type = par.type
-        if node_type == 'argument' and par.children[1] == '=' and par.children[0] == name:
-            # Named param goto.
-            trailer = par.parent
-            if trailer.type == 'arglist':
-                trailer = trailer.parent
-            if trailer.type != 'classdef':
-                if trailer.type == 'decorator':
-                    context_set = context.eval_node(trailer.children[1])
-                else:
-                    i = trailer.parent.children.index(trailer)
-                    to_evaluate = trailer.parent.children[:i]
-                    if to_evaluate[0] == 'await':
-                        to_evaluate.pop(0)
-                    context_set = context.eval_node(to_evaluate[0])
-                    for trailer in to_evaluate[1:]:
-                        context_set = eval_trailer(context, context_set, trailer)
-                param_names = []
-                for context in context_set:
-                    for signature in context.get_signatures():
-                        for param_name in signature.get_param_names():
-                            if param_name.string_name == name.value:
-                                param_names.append(param_name)
-                return param_names
-        elif node_type == 'dotted_name':  # Is a decorator.
-            index = par.children.index(name)
-            if index > 0:
-                new_dotted = helpers.deep_ast_copy(par)
-                new_dotted.children[index - 1:] = []
-                values = context.eval_node(new_dotted)
-                return unite(
-                    value.py__getattribute__(name, name_context=context, is_goto=True)
-                    for value in values
-                )
-
-        if node_type == 'trailer' and par.children[0] == '.':
-            values = helpers.evaluate_call_of_leaf(context, name, cut_own_trailer=True)
-            return values.py__getattribute__(name, name_context=context, is_goto=True)
-        else:
-            stmt = tree.search_ancestor(
-                name, 'expr_stmt', 'lambdef'
-            ) or name
-            if stmt.type == 'lambdef':
-                stmt = name
-            return context.py__getattribute__(
-                name,
-                position=stmt.start_pos,
-                search_global=True, is_goto=True
-            )
-
-    def create_context(self, base_context, node, node_is_context=False, node_is_object=False):
-        def parent_scope(node):
-            while True:
-                node = node.parent
-
-                if parser_utils.is_scope(node):
-                    return node
-                elif node.type in ('argument', 'testlist_comp'):
-                    if node.children[1].type in ('comp_for', 'sync_comp_for'):
-                        return node.children[1]
-                elif node.type == 'dictorsetmaker':
-                    for n in node.children[1:4]:
-                        # In dictionaries it can be pretty much anything.
-                        if n.type in ('comp_for', 'sync_comp_for'):
-                            return n
-
-        def from_scope_node(scope_node, is_nested=True, node_is_object=False):
-            if scope_node == base_node:
-                return base_context
-
-            is_funcdef = scope_node.type in ('funcdef', 'lambdef')
-            parent_scope = parser_utils.get_parent_scope(scope_node)
-            parent_context = from_scope_node(parent_scope)
-
-            if is_funcdef:
-                func = FunctionContext.from_context(parent_context, scope_node)
-                if parent_context.is_class():
-                    instance = AnonymousInstance(
-                        self, parent_context.parent_context, parent_context)
-                    func = BoundMethod(
-                        instance=instance,
-                        function=func
-                    )
-
-                if is_nested and not node_is_object:
-                    return func.get_function_execution()
-                return func
-            elif scope_node.type == 'classdef':
-                return ClassContext(self, parent_context, scope_node)
-            elif scope_node.type in ('comp_for', 'sync_comp_for'):
-                if node.start_pos >= scope_node.children[-1].start_pos:
-                    return parent_context
-                return CompForContext.from_comp_for(parent_context, scope_node)
-            raise Exception("There's a scope that was not managed.")
-
-        base_node = base_context.tree_node
-
-        if node_is_context and parser_utils.is_scope(node):
-            scope_node = node
-        else:
-            scope_node = parent_scope(node)
-            if scope_node.type in ('funcdef', 'classdef'):
-                colon = scope_node.children[scope_node.children.index(':')]
-                if node.start_pos < colon.start_pos:
-                    parent = node.parent
-                    if not (parent.type == 'param' and parent.name == node):
-                        scope_node = parent_scope(scope_node)
-        return from_scope_node(scope_node, is_nested=True, node_is_object=node_is_object)
-
-    def parse_and_get_code(self, code=None, path=None, encoding='utf-8',
-                           use_latest_grammar=False, file_io=None, **kwargs):
-        if self.allow_different_encoding:
-            if code is None:
-                if file_io is None:
-                    file_io = FileIO(path)
-                code = file_io.read()
-            code = python_bytes_to_unicode(code, encoding=encoding, errors='replace')
-
-        grammar = self.latest_grammar if use_latest_grammar else self.grammar
-        return grammar.parse(code=code, path=path, file_io=file_io, **kwargs), code
-
-    def parse(self, *args, **kwargs):
-        return self.parse_and_get_code(*args, **kwargs)[0]

jedi/evaluate/base_context.py

@@ -1,436 +0,0 @@
-"""
-Contexts are the "values" that Python would return. However Contexts are at the
-same time also the "contexts" that a user is currently sitting in.
-
-A ContextSet is typically used to specify the return of a function or any other
-static analysis operation. In jedi there are always multiple returns and not
-just one.
-"""
-from functools import reduce
-from operator import add
-from parso.python.tree import ExprStmt, SyncCompFor
-
-from jedi import debug
-from jedi._compatibility import zip_longest, unicode
-from jedi.parser_utils import clean_scope_docstring
-from jedi.common import BaseContextSet, BaseContext
-from jedi.evaluate.helpers import SimpleGetItemNotFound
-from jedi.evaluate.utils import safe_property
-from jedi.evaluate.cache import evaluator_as_method_param_cache
-from jedi.cache import memoize_method
-
-_sentinel = object()
-
-
-class HelperContextMixin(object):
-    def get_root_context(self):
-        context = self
-        while True:
-            if context.parent_context is None:
-                return context
-            context = context.parent_context
-
-    @classmethod
-    @evaluator_as_method_param_cache()
-    def create_cached(cls, *args, **kwargs):
-        return cls(*args, **kwargs)
-
-    def execute(self, arguments):
-        return self.evaluator.execute(self, arguments=arguments)
-
-    def execute_evaluated(self, *value_list):
-        from jedi.evaluate.arguments import ValuesArguments
-        arguments = ValuesArguments([ContextSet([value]) for value in value_list])
-        return self.evaluator.execute(self, arguments)
-
-    def execute_annotation(self):
-        return self.execute_evaluated()
-
-    def gather_annotation_classes(self):
-        return ContextSet([self])
-
-    def merge_types_of_iterate(self, contextualized_node=None, is_async=False):
-        return ContextSet.from_sets(
-            lazy_context.infer()
-            for lazy_context in self.iterate(contextualized_node, is_async)
-        )
-
-    def py__getattribute__(self, name_or_str, name_context=None, position=None,
-                           search_global=False, is_goto=False,
-                           analysis_errors=True):
-        """
-        :param position: Position of the last statement -> tuple of line, column
-        """
-        if name_context is None:
-            name_context = self
-        from jedi.evaluate import finder
-        f = finder.NameFinder(self.evaluator, self, name_context, name_or_str,
-                              position, analysis_errors=analysis_errors)
-        filters = f.get_filters(search_global)
-        if is_goto:
-            return f.filter_name(filters)
-        return f.find(filters, attribute_lookup=not search_global)
-
-    def py__await__(self):
-        await_context_set = self.py__getattribute__(u"__await__")
-        if not await_context_set:
-            debug.warning('Tried to run __await__ on context %s', self)
-        return await_context_set.execute_evaluated()
-
-    def eval_node(self, node):
-        return self.evaluator.eval_element(self, node)
-
-    def create_context(self, node, node_is_context=False, node_is_object=False):
-        return self.evaluator.create_context(self, node, node_is_context, node_is_object)
-
-    def iterate(self, contextualized_node=None, is_async=False):
-        debug.dbg('iterate %s', self)
-        if is_async:
-            from jedi.evaluate.lazy_context import LazyKnownContexts
-            # TODO if no __aiter__ contexts are there, error should be:
-            # TypeError: 'async for' requires an object with __aiter__ method, got int
-            return iter([
-                LazyKnownContexts(
-                    self.py__getattribute__('__aiter__').execute_evaluated()
-                        .py__getattribute__('__anext__').execute_evaluated()
-                        .py__getattribute__('__await__').execute_evaluated()
-                        .py__stop_iteration_returns()
-                )  # noqa
-            ])
-        return self.py__iter__(contextualized_node)
-
-    def is_sub_class_of(self, class_context):
-        for cls in self.py__mro__():
-            if cls.is_same_class(class_context):
-                return True
-        return False
-
-    def is_same_class(self, class2):
-        # Class matching should prefer comparisons that are not this function.
-        if type(class2).is_same_class != HelperContextMixin.is_same_class:
-            return class2.is_same_class(self)
-        return self == class2
-
-
-class Context(HelperContextMixin, BaseContext):
-    """
-    Should be defined, otherwise the API returns empty types.
-    """
-    predefined_names = {}
-    """
-    To be defined by subclasses.
-    """
-    tree_node = None
-
-    @property
-    def api_type(self):
-        # By default just lower name of the class. Can and should be
-        # overwritten.
-        return self.__class__.__name__.lower()
-
-    def py__getitem__(self, index_context_set, contextualized_node):
-        from jedi.evaluate import analysis
-        # TODO this context is probably not right.
-        analysis.add(
-            contextualized_node.context,
-            'type-error-not-subscriptable',
-            contextualized_node.node,
-            message="TypeError: '%s' object is not subscriptable" % self
-        )
-        return NO_CONTEXTS
-
-    def py__iter__(self, contextualized_node=None):
-        if contextualized_node is not None:
-            from jedi.evaluate import analysis
-            analysis.add(
-                contextualized_node.context,
-                'type-error-not-iterable',
-                contextualized_node.node,
-                message="TypeError: '%s' object is not iterable" % self)
-        return iter([])
-
-    def get_signatures(self):
-        return []
-
-    def is_class(self):
-        return False
-
-    def is_instance(self):
-        return False
-
-    def is_function(self):
-        return False
-
-    def is_module(self):
-        return False
-
-    def is_namespace(self):
-        return False
-
-    def is_compiled(self):
-        return False
-
-    def is_bound_method(self):
-        return False
-
-    def py__bool__(self):
-        """
-        Since Wrapper is a super class for classes, functions and modules,
-        the return value will always be true.
-        """
-        return True
-
-    def py__doc__(self):
-        try:
-            self.tree_node.get_doc_node
-        except AttributeError:
-            return ''
-        else:
-            return clean_scope_docstring(self.tree_node)
-        return None
-
-    def get_safe_value(self, default=_sentinel):
-        if default is _sentinel:
-            raise ValueError("There exists no safe value for context %s" % self)
-        return default
-
-    def py__call__(self, arguments):
-        debug.warning("no execution possible %s", self)
-        return NO_CONTEXTS
-
-    def py__stop_iteration_returns(self):
-        debug.warning("Not possible to return the stop iterations of %s", self)
-        return NO_CONTEXTS
-
-    def get_qualified_names(self):
-        # Returns Optional[Tuple[str, ...]]
-        return None
-
-    def is_stub(self):
-        # The root context knows if it's a stub or not.
-        return self.parent_context.is_stub()
-
-
-def iterate_contexts(contexts, contextualized_node=None, is_async=False):
-    """
-    Calls `iterate`, on all contexts but ignores the ordering and just returns
-    all contexts that the iterate functions yield.
-    """
-    return ContextSet.from_sets(
-        lazy_context.infer()
-        for lazy_context in contexts.iterate(contextualized_node, is_async=is_async)
-    )
-
-
-class _ContextWrapperBase(HelperContextMixin):
-    predefined_names = {}
-
-    @safe_property
-    def name(self):
-        from jedi.evaluate.names import ContextName
-        wrapped_name = self._wrapped_context.name
-        if wrapped_name.tree_name is not None:
-            return ContextName(self, wrapped_name.tree_name)
-        else:
-            from jedi.evaluate.compiled import CompiledContextName
-            return CompiledContextName(self, wrapped_name.string_name)
-
-    @classmethod
-    @evaluator_as_method_param_cache()
-    def create_cached(cls, evaluator, *args, **kwargs):
-        return cls(*args, **kwargs)
-
-    def __getattr__(self, name):
-        assert name != '_wrapped_context', 'Problem with _get_wrapped_context'
-        return getattr(self._wrapped_context, name)
-
-
-class LazyContextWrapper(_ContextWrapperBase):
-    @safe_property
-    @memoize_method
-    def _wrapped_context(self):
-        with debug.increase_indent_cm('Resolve lazy context wrapper'):
-            return self._get_wrapped_context()
-
-    def __repr__(self):
-        return '<%s>' % (self.__class__.__name__)
-
-    def _get_wrapped_context(self):
-        raise NotImplementedError
-
-
-class ContextWrapper(_ContextWrapperBase):
-    def __init__(self, wrapped_context):
-        self._wrapped_context = wrapped_context
-
-    def __repr__(self):
-        return '%s(%s)' % (self.__class__.__name__, self._wrapped_context)
-
-
-class TreeContext(Context):
-    def __init__(self, evaluator, parent_context, tree_node):
-        super(TreeContext, self).__init__(evaluator, parent_context)
-        self.predefined_names = {}
-        self.tree_node = tree_node
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self.tree_node)
-
-
-class ContextualizedNode(object):
-    def __init__(self, context, node):
-        self.context = context
-        self.node = node
-
-    def get_root_context(self):
-        return self.context.get_root_context()
-
-    def infer(self):
-        return self.context.eval_node(self.node)
-
-    def __repr__(self):
-        return '<%s: %s in %s>' % (self.__class__.__name__, self.node, self.context)
-
-
-class ContextualizedName(ContextualizedNode):
-    # TODO merge with TreeNameDefinition?!
-    @property
-    def name(self):
-        return self.node
-
-    def assignment_indexes(self):
-        """
-        Returns an array of tuple(int, node) of the indexes that are used in
-        tuple assignments.
-
-        For example if the name is ``y`` in the following code::
-
-            x, (y, z) = 2, ''
-
-        would result in ``[(1, xyz_node), (0, yz_node)]``.
-
-        When searching for b in the case ``a, *b, c = [...]`` it will return::
-
-            [(slice(1, -1), abc_node)]
-        """
-        indexes = []
-        is_star_expr = False
-        node = self.node.parent
-        compare = self.node
-        while node is not None:
-            if node.type in ('testlist', 'testlist_comp', 'testlist_star_expr', 'exprlist'):
-                for i, child in enumerate(node.children):
-                    if child == compare:
-                        index = int(i / 2)
-                        if is_star_expr:
-                            from_end = int((len(node.children) - i) / 2)
-                            index = slice(index, -from_end)
-                        indexes.insert(0, (index, node))
-                        break
-                else:
-                    raise LookupError("Couldn't find the assignment.")
-                is_star_expr = False
-            elif node.type == 'star_expr':
-                is_star_expr = True
-            elif isinstance(node, (ExprStmt, SyncCompFor)):
-                break
-
-            compare = node
-            node = node.parent
-        return indexes
-
-
-def _getitem(context, index_contexts, contextualized_node):
-    from jedi.evaluate.context.iterable import Slice
-
-    # The actual getitem call.
-    simple_getitem = getattr(context, 'py__simple_getitem__', None)
-
-    result = NO_CONTEXTS
-    unused_contexts = set()
-    for index_context in index_contexts:
-        if simple_getitem is not None:
-            index = index_context
-            if isinstance(index_context, Slice):
-                index = index.obj
-
-            try:
-                method = index.get_safe_value
-            except AttributeError:
-                pass
-            else:
-                index = method(default=None)
-
-            if type(index) in (float, int, str, unicode, slice, bytes):
-                try:
-                    result |= simple_getitem(index)
-                    continue
-                except SimpleGetItemNotFound:
-                    pass
-
-        unused_contexts.add(index_context)
-
-    # The index was somehow not good enough or simply a wrong type.
-    # Therefore we now iterate through all the contexts and just take
-    # all results.
-    if unused_contexts or not index_contexts:
-        result |= context.py__getitem__(
-            ContextSet(unused_contexts),
-            contextualized_node
-        )
-    debug.dbg('py__getitem__ result: %s', result)
-    return result
-
-
-class ContextSet(BaseContextSet):
-    def py__class__(self):
-        return ContextSet(c.py__class__() for c in self._set)
-
-    def iterate(self, contextualized_node=None, is_async=False):
-        from jedi.evaluate.lazy_context import get_merged_lazy_context
-        type_iters = [c.iterate(contextualized_node, is_async=is_async) for c in self._set]
-        for lazy_contexts in zip_longest(*type_iters):
-            yield get_merged_lazy_context(
-                [l for l in lazy_contexts if l is not None]
-            )
-
-    def execute(self, arguments):
-        return ContextSet.from_sets(c.evaluator.execute(c, arguments) for c in self._set)
-
-    def execute_evaluated(self, *args, **kwargs):
-        return ContextSet.from_sets(c.execute_evaluated(*args, **kwargs) for c in self._set)
-
-    def py__getattribute__(self, *args, **kwargs):
-        if kwargs.get('is_goto'):
-            return reduce(add, [c.py__getattribute__(*args, **kwargs) for c in self._set], [])
-        return ContextSet.from_sets(c.py__getattribute__(*args, **kwargs) for c in self._set)
-
-    def get_item(self, *args, **kwargs):
-        return ContextSet.from_sets(_getitem(c, *args, **kwargs) for c in self._set)
-
-    def try_merge(self, function_name):
-        context_set = self.__class__([])
-        for c in self._set:
-            try:
-                method = getattr(c, function_name)
-            except AttributeError:
-                pass
-            else:
-                context_set |= method()
-        return context_set
-
-    def gather_annotation_classes(self):
-        return ContextSet.from_sets([c.gather_annotation_classes() for c in self._set])
-
-    def get_signatures(self):
-        return [sig for c in self._set for sig in c.get_signatures()]
-
-
-NO_CONTEXTS = ContextSet([])
-
-
-def iterator_to_context_set(func):
-    def wrapper(*args, **kwargs):
-        return ContextSet(func(*args, **kwargs))
-
-    return wrapper

jedi/evaluate/compiled/__init__.py

@@ -1,64 +0,0 @@
-from jedi._compatibility import unicode
-from jedi.evaluate.compiled.context import CompiledObject, CompiledName, \
-    CompiledObjectFilter, CompiledContextName, create_from_access_path
-from jedi.evaluate.base_context import ContextWrapper, LazyContextWrapper
-
-
-def builtin_from_name(evaluator, string):
-    typing_builtins_module = evaluator.builtins_module
-    if string in ('None', 'True', 'False'):
-        builtins, = typing_builtins_module.non_stub_context_set
-        filter_ = next(builtins.get_filters())
-    else:
-        filter_ = next(typing_builtins_module.get_filters())
-    name, = filter_.get(string)
-    context, = name.infer()
-    return context
-
-
-class CompiledValue(LazyContextWrapper):
-    def __init__(self, compiled_obj):
-        self.evaluator = compiled_obj.evaluator
-        self._compiled_obj = compiled_obj
-
-    def __getattribute__(self, name):
-        if name in ('get_safe_value', 'execute_operation', 'access_handle',
-                    'negate', 'py__bool__', 'is_compiled'):
-            return getattr(self._compiled_obj, name)
-        return super(CompiledValue, self).__getattribute__(name)
-
-    def _get_wrapped_context(self):
-        instance, = builtin_from_name(
-            self.evaluator, self._compiled_obj.name.string_name).execute_evaluated()
-        return instance
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self._compiled_obj)
-
-
-def create_simple_object(evaluator, obj):
-    """
-    Only allows creations of objects that are easily picklable across Python
-    versions.
-    """
-    assert type(obj) in (int, float, str, bytes, unicode, slice, complex, bool), obj
-    compiled_obj = create_from_access_path(
-        evaluator,
-        evaluator.compiled_subprocess.create_simple_object(obj)
-    )
-    return CompiledValue(compiled_obj)
-
-
-def get_string_context_set(evaluator):
-    return builtin_from_name(evaluator, u'str').execute_evaluated()
-
-
-def load_module(evaluator, dotted_name, **kwargs):
-    # Temporary, some tensorflow builtins cannot be loaded, so it's tried again
-    # and again and it's really slow.
-    if dotted_name.startswith('tensorflow.'):
-        return None
-    access_path = evaluator.compiled_subprocess.load_module(dotted_name=dotted_name, **kwargs)
-    if access_path is None:
-        return None
-    return create_from_access_path(evaluator, access_path)

jedi/evaluate/compiled/context.py

@@ -1,541 +0,0 @@
-"""
-Imitate the parser representation.
-"""
-import re
-from functools import partial
-
-from jedi import debug
-from jedi.evaluate.utils import to_list
-from jedi._compatibility import force_unicode, Parameter, cast_path
-from jedi.cache import underscore_memoization, memoize_method
-from jedi.evaluate.filters import AbstractFilter
-from jedi.evaluate.names import AbstractNameDefinition, ContextNameMixin, \
-    ParamNameInterface
-from jedi.evaluate.base_context import Context, ContextSet, NO_CONTEXTS
-from jedi.evaluate.lazy_context import LazyKnownContext
-from jedi.evaluate.compiled.access import _sentinel
-from jedi.evaluate.cache import evaluator_function_cache
-from jedi.evaluate.helpers import reraise_getitem_errors
-from jedi.evaluate.signature import BuiltinSignature
-
-
-class CheckAttribute(object):
-    """Raises an AttributeError if the attribute X isn't available."""
-    def __init__(self, check_name=None):
-        # Remove the py in front of e.g. py__call__.
-        self.check_name = check_name
-
-    def __call__(self, func):
-        self.func = func
-        if self.check_name is None:
-            self.check_name = force_unicode(func.__name__[2:])
-        return self
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-
-        # This might raise an AttributeError. That's wanted.
-        instance.access_handle.getattr_paths(self.check_name)
-        return partial(self.func, instance)
-
-
-class CompiledObject(Context):
-    def __init__(self, evaluator, access_handle, parent_context=None):
-        super(CompiledObject, self).__init__(evaluator, parent_context)
-        self.access_handle = access_handle
-
-    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.evaluator, return_annotation).execute_annotation()
-
-        try:
-            self.access_handle.getattr_paths(u'__call__')
-        except AttributeError:
-            return super(CompiledObject, self).py__call__(arguments)
-        else:
-            if self.access_handle.is_class():
-                from jedi.evaluate.context import CompiledInstance
-                return ContextSet([
-                    CompiledInstance(self.evaluator, self.parent_context, self, arguments)
-                ])
-            else:
-                return ContextSet(self._execute_function(arguments))
-
-    @CheckAttribute()
-    def py__class__(self):
-        return create_from_access_path(self.evaluator, self.access_handle.py__class__())
-
-    @CheckAttribute()
-    def py__mro__(self):
-        return (self,) + tuple(
-            create_from_access_path(self.evaluator, access)
-            for access in self.access_handle.py__mro__accesses()
-        )
-
-    @CheckAttribute()
-    def py__bases__(self):
-        return tuple(
-            create_from_access_path(self.evaluator, access)
-            for access in self.access_handle.py__bases__()
-        )
-
-    @CheckAttribute()
-    def py__path__(self):
-        return map(cast_path, self.access_handle.py__path__())
-
-    @property
-    def string_names(self):
-        # For modules
-        name = self.py__name__()
-        if name is None:
-            return ()
-        return tuple(name.split('.'))
-
-    def get_qualified_names(self):
-        return self.access_handle.get_qualified_names()
-
-    def py__bool__(self):
-        return self.access_handle.py__bool__()
-
-    def py__file__(self):
-        return cast_path(self.access_handle.py__file__())
-
-    def is_class(self):
-        return self.access_handle.is_class()
-
-    def is_module(self):
-        return self.access_handle.is_module()
-
-    def is_compiled(self):
-        return True
-
-    def is_stub(self):
-        return False
-
-    def is_instance(self):
-        return self.access_handle.is_instance()
-
-    def py__doc__(self):
-        return self.access_handle.py__doc__()
-
-    @to_list
-    def get_param_names(self):
-        try:
-            signature_params = self.access_handle.get_signature_params()
-        except ValueError:  # Has no signature
-            params_str, ret = self._parse_function_doc()
-            if not params_str:
-                tokens = []
-            else:
-                tokens = params_str.split(',')
-            if self.access_handle.ismethoddescriptor():
-                tokens.insert(0, 'self')
-            for p in tokens:
-                name, _, default = p.strip().partition('=')
-                yield UnresolvableParamName(self, name, default)
-        else:
-            for signature_param in signature_params:
-                yield SignatureParamName(self, signature_param)
-
-    def get_signatures(self):
-        _, return_string = self._parse_function_doc()
-        return [BuiltinSignature(self, return_string)]
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self.access_handle.get_repr())
-
-    @underscore_memoization
-    def _parse_function_doc(self):
-        doc = self.py__doc__()
-        if doc is None:
-            return '', ''
-
-        return _parse_function_doc(doc)
-
-    @property
-    def api_type(self):
-        return self.access_handle.get_api_type()
-
-    @underscore_memoization
-    def _cls(self):
-        """
-        We used to limit the lookups for instantiated objects like list(), but
-        this is not the case anymore. Python itself
-        """
-        # Ensures that a CompiledObject is returned that is not an instance (like list)
-        return self
-
-    def get_filters(self, search_global=False, is_instance=False,
-                    until_position=None, origin_scope=None):
-        yield self._ensure_one_filter(is_instance)
-
-    @memoize_method
-    def _ensure_one_filter(self, is_instance):
-        """
-        search_global shouldn't change the fact that there's one dict, this way
-        there's only one `object`.
-        """
-        return CompiledObjectFilter(self.evaluator, self, is_instance)
-
-    @CheckAttribute(u'__getitem__')
-    def py__simple_getitem__(self, index):
-        with reraise_getitem_errors(IndexError, KeyError, TypeError):
-            access = self.access_handle.py__simple_getitem__(index)
-        if access is None:
-            return NO_CONTEXTS
-
-        return ContextSet([create_from_access_path(self.evaluator, access)])
-
-    def py__getitem__(self, index_context_set, contextualized_node):
-        all_access_paths = self.access_handle.py__getitem__all_values()
-        if all_access_paths is None:
-            # This means basically that no __getitem__ has been defined on this
-            # object.
-            return super(CompiledObject, self).py__getitem__(index_context_set, contextualized_node)
-        return ContextSet(
-            create_from_access_path(self.evaluator, access)
-            for access in all_access_paths
-        )
-
-    def py__iter__(self, contextualized_node=None):
-        # Python iterators are a bit strange, because there's no need for
-        # the __iter__ function as long as __getitem__ is defined (it will
-        # just start with __getitem__(0). This is especially true for
-        # Python 2 strings, where `str.__iter__` is not even defined.
-        if not self.access_handle.has_iter():
-            for x in super(CompiledObject, self).py__iter__(contextualized_node):
-                yield x
-
-        access_path_list = self.access_handle.py__iter__list()
-        if access_path_list is None:
-            # There is no __iter__ method on this object.
-            return
-
-        for access in access_path_list:
-            yield LazyKnownContext(create_from_access_path(self.evaluator, access))
-
-    def py__name__(self):
-        return self.access_handle.py__name__()
-
-    @property
-    def name(self):
-        name = self.py__name__()
-        if name is None:
-            name = self.access_handle.get_repr()
-        return CompiledContextName(self, name)
-
-    def _execute_function(self, params):
-        from jedi.evaluate import docstrings
-        from jedi.evaluate.compiled import builtin_from_name
-        if self.api_type != 'function':
-            return
-
-        for name in self._parse_function_doc()[1].split():
-            try:
-                # TODO wtf is this? this is exactly the same as the thing
-                # below. It uses getattr as well.
-                self.evaluator.builtins_module.access_handle.getattr_paths(name)
-            except AttributeError:
-                continue
-            else:
-                bltn_obj = builtin_from_name(self.evaluator, name)
-                for result in self.evaluator.execute(bltn_obj, params):
-                    yield result
-        for type_ in docstrings.infer_return_types(self):
-            yield type_
-
-    def get_safe_value(self, default=_sentinel):
-        try:
-            return self.access_handle.get_safe_value()
-        except ValueError:
-            if default == _sentinel:
-                raise
-            return default
-
-    def execute_operation(self, other, operator):
-        return create_from_access_path(
-            self.evaluator,
-            self.access_handle.execute_operation(other.access_handle, operator)
-        )
-
-    def negate(self):
-        return create_from_access_path(self.evaluator, self.access_handle.negate())
-
-    def get_metaclasses(self):
-        return NO_CONTEXTS
-
-
-class CompiledName(AbstractNameDefinition):
-    def __init__(self, evaluator, parent_context, name):
-        self._evaluator = evaluator
-        self.parent_context = parent_context
-        self.string_name = name
-
-    def _get_qualified_names(self):
-        parent_qualified_names = self.parent_context.get_qualified_names()
-        return parent_qualified_names + (self.string_name,)
-
-    def __repr__(self):
-        try:
-            name = self.parent_context.name  # __name__ is not defined all the time
-        except AttributeError:
-            name = None
-        return '<%s: (%s).%s>' % (self.__class__.__name__, name, self.string_name)
-
-    @property
-    def api_type(self):
-        api = self.infer()
-        # If we can't find the type, assume it is an instance variable
-        if not api:
-            return "instance"
-        return next(iter(api)).api_type
-
-    @underscore_memoization
-    def infer(self):
-        return ContextSet([_create_from_name(
-            self._evaluator, self.parent_context, self.string_name
-        )])
-
-
-class SignatureParamName(ParamNameInterface, AbstractNameDefinition):
-    def __init__(self, compiled_obj, signature_param):
-        self.parent_context = compiled_obj.parent_context
-        self._signature_param = signature_param
-
-    @property
-    def string_name(self):
-        return self._signature_param.name
-
-    def to_string(self):
-        s = self._kind_string() + self.string_name
-        if self._signature_param.has_annotation:
-            s += ': ' + self._signature_param.annotation_string
-        if self._signature_param.has_default:
-            s += '=' + self._signature_param.default_string
-        return s
-
-    def get_kind(self):
-        return getattr(Parameter, self._signature_param.kind_name)
-
-    def infer(self):
-        p = self._signature_param
-        evaluator = self.parent_context.evaluator
-        contexts = NO_CONTEXTS
-        if p.has_default:
-            contexts = ContextSet([create_from_access_path(evaluator, p.default)])
-        if p.has_annotation:
-            annotation = create_from_access_path(evaluator, p.annotation)
-            contexts |= annotation.execute_evaluated()
-        return contexts
-
-
-class UnresolvableParamName(ParamNameInterface, AbstractNameDefinition):
-    def __init__(self, compiled_obj, name, default):
-        self.parent_context = compiled_obj.parent_context
-        self.string_name = name
-        self._default = default
-
-    def get_kind(self):
-        return Parameter.POSITIONAL_ONLY
-
-    def to_string(self):
-        string = self.string_name
-        if self._default:
-            string += '=' + self._default
-        return string
-
-    def infer(self):
-        return NO_CONTEXTS
-
-
-class CompiledContextName(ContextNameMixin, AbstractNameDefinition):
-    def __init__(self, context, name):
-        self.string_name = name
-        self._context = context
-        self.parent_context = context.parent_context
-
-
-class EmptyCompiledName(AbstractNameDefinition):
-    """
-    Accessing some names will raise an exception. To avoid not having any
-    completions, just give Jedi the option to return this object. It infers to
-    nothing.
-    """
-    def __init__(self, evaluator, name):
-        self.parent_context = evaluator.builtins_module
-        self.string_name = name
-
-    def infer(self):
-        return NO_CONTEXTS
-
-
-class CompiledObjectFilter(AbstractFilter):
-    name_class = CompiledName
-
-    def __init__(self, evaluator, compiled_object, is_instance=False):
-        self._evaluator = evaluator
-        self.compiled_object = compiled_object
-        self.is_instance = is_instance
-
-    def get(self, name):
-        return self._get(
-            name,
-            lambda: self.compiled_object.access_handle.is_allowed_getattr(name),
-            lambda: self.compiled_object.access_handle.dir(),
-            check_has_attribute=True
-        )
-
-    def _get(self, name, allowed_getattr_callback, dir_callback, check_has_attribute=False):
-        """
-        To remove quite a few access calls we introduced the callback here.
-        """
-        has_attribute, is_descriptor = allowed_getattr_callback()
-        if check_has_attribute and not has_attribute:
-            return []
-
-        # Always use unicode objects in Python 2 from here.
-        name = force_unicode(name)
-
-        if (is_descriptor and not self._evaluator.allow_descriptor_getattr) or not has_attribute:
-            return [self._get_cached_name(name, is_empty=True)]
-
-        if self.is_instance and name not in dir_callback():
-            return []
-        return [self._get_cached_name(name)]
-
-    @memoize_method
-    def _get_cached_name(self, name, is_empty=False):
-        if is_empty:
-            return EmptyCompiledName(self._evaluator, name)
-        else:
-            return self._create_name(name)
-
-    def values(self):
-        from jedi.evaluate.compiled import builtin_from_name
-        names = []
-        needs_type_completions, dir_infos = self.compiled_object.access_handle.get_dir_infos()
-        for name in dir_infos:
-            names += self._get(
-                name,
-                lambda: dir_infos[name],
-                lambda: dir_infos.keys(),
-            )
-
-        # ``dir`` doesn't include the type names.
-        if not self.is_instance and needs_type_completions:
-            for filter in builtin_from_name(self._evaluator, u'type').get_filters():
-                names += filter.values()
-        return names
-
-    def _create_name(self, name):
-        return self.name_class(self._evaluator, self.compiled_object, name)
-
-    def __repr__(self):
-        return "<%s: %s>" % (self.__class__.__name__, self.compiled_object)
-
-
-docstr_defaults = {
-    'floating point number': u'float',
-    'character': u'str',
-    'integer': u'int',
-    'dictionary': u'dict',
-    'string': u'str',
-}
-
-
-def _parse_function_doc(doc):
-    """
-    Takes a function and returns the params and return value as a tuple.
-    This is nothing more than a docstring parser.
-
-    TODO docstrings like utime(path, (atime, mtime)) and a(b [, b]) -> None
-    TODO docstrings like 'tuple of integers'
-    """
-    doc = force_unicode(doc)
-    # parse round parentheses: def func(a, (b,c))
-    try:
-        count = 0
-        start = doc.index('(')
-        for i, s in enumerate(doc[start:]):
-            if s == '(':
-                count += 1
-            elif s == ')':
-                count -= 1
-            if count == 0:
-                end = start + i
-                break
-        param_str = doc[start + 1:end]
-    except (ValueError, UnboundLocalError):
-        # ValueError for doc.index
-        # UnboundLocalError for undefined end in last line
-        debug.dbg('no brackets found - no param')
-        end = 0
-        param_str = u''
-    else:
-        # remove square brackets, that show an optional param ( = None)
-        def change_options(m):
-            args = m.group(1).split(',')
-            for i, a in enumerate(args):
-                if a and '=' not in a:
-                    args[i] += '=None'
-            return ','.join(args)
-
-        while True:
-            param_str, changes = re.subn(r' ?\[([^\[\]]+)\]',
-                                         change_options, param_str)
-            if changes == 0:
-                break
-    param_str = param_str.replace('-', '_')  # see: isinstance.__doc__
-
-    # parse return value
-    r = re.search(u'-[>-]* ', doc[end:end + 7])
-    if r is None:
-        ret = u''
-    else:
-        index = end + r.end()
-        # get result type, which can contain newlines
-        pattern = re.compile(r'(,\n|[^\n-])+')
-        ret_str = pattern.match(doc, index).group(0).strip()
-        # New object -> object()
-        ret_str = re.sub(r'[nN]ew (.*)', r'\1()', ret_str)
-
-        ret = docstr_defaults.get(ret_str, ret_str)
-
-    return param_str, ret
-
-
-def _create_from_name(evaluator, compiled_object, name):
-    access_paths = compiled_object.access_handle.getattr_paths(name, default=None)
-    parent_context = compiled_object
-    if parent_context.is_class():
-        parent_context = parent_context.parent_context
-
-    context = None
-    for access_path in access_paths:
-        context = create_cached_compiled_object(
-            evaluator, access_path, parent_context=context
-        )
-    return context
-
-
-def _normalize_create_args(func):
-    """The cache doesn't care about keyword vs. normal args."""
-    def wrapper(evaluator, obj, parent_context=None):
-        return func(evaluator, obj, parent_context)
-    return wrapper
-
-
-def create_from_access_path(evaluator, access_path):
-    parent_context = None
-    for name, access in access_path.accesses:
-        parent_context = create_cached_compiled_object(evaluator, access, parent_context)
-    return parent_context
-
-
-@_normalize_create_args
-@evaluator_function_cache()
-def create_cached_compiled_object(evaluator, access_handle, parent_context):
-    return CompiledObject(evaluator, access_handle, parent_context)

jedi/evaluate/compiled/mixed.py

@@ -1,291 +0,0 @@
-"""
-Used only for REPL Completion.
-"""
-
-import inspect
-import os
-import sys
-
-from jedi.parser_utils import get_cached_code_lines
-
-from jedi import settings
-from jedi.evaluate import compiled
-from jedi.cache import underscore_memoization
-from jedi.file_io import FileIO
-from jedi.evaluate.base_context import ContextSet, ContextWrapper
-from jedi.evaluate.helpers import SimpleGetItemNotFound
-from jedi.evaluate.context import ModuleContext
-from jedi.evaluate.cache import evaluator_function_cache
-from jedi.evaluate.compiled.getattr_static import getattr_static
-from jedi.evaluate.compiled.access import compiled_objects_cache, \
-    ALLOWED_GETITEM_TYPES, get_api_type
-from jedi.evaluate.compiled.context import create_cached_compiled_object
-from jedi.evaluate.gradual.conversion import to_stub
-
-_sentinel = object()
-
-
-class MixedObject(ContextWrapper):
-    """
-    A ``MixedObject`` is used in two ways:
-
-    1. It uses the default logic of ``parser.python.tree`` objects,
-    2. except for getattr calls. The names dicts are generated in a fashion
-       like ``CompiledObject``.
-
-    This combined logic makes it possible to provide more powerful REPL
-    completion. It allows side effects that are not noticable with the default
-    parser structure to still be completeable.
-
-    The biggest difference from CompiledObject to MixedObject is that we are
-    generally dealing with Python code and not with C code. This will generate
-    fewer special cases, because we in Python you don't have the same freedoms
-    to modify the runtime.
-    """
-    def __init__(self, compiled_object, tree_context):
-        super(MixedObject, self).__init__(tree_context)
-        self.compiled_object = compiled_object
-        self.access_handle = compiled_object.access_handle
-
-    def get_filters(self, *args, **kwargs):
-        yield MixedObjectFilter(self.evaluator, self)
-
-    def get_signatures(self):
-        # Prefer `inspect.signature` over somehow analyzing Python code. It
-        # should be very precise, especially for stuff like `partial`.
-        return self.compiled_object.get_signatures()
-
-    def py__call__(self, arguments):
-        return (to_stub(self._wrapped_context) or self._wrapped_context).py__call__(arguments)
-
-    def get_safe_value(self, default=_sentinel):
-        if default is _sentinel:
-            return self.compiled_object.get_safe_value()
-        else:
-            return self.compiled_object.get_safe_value(default)
-
-    def py__simple_getitem__(self, index):
-        python_object = self.compiled_object.access_handle.access._obj
-        if type(python_object) in ALLOWED_GETITEM_TYPES:
-            return self.compiled_object.py__simple_getitem__(index)
-        raise SimpleGetItemNotFound
-
-    def __repr__(self):
-        return '<%s: %s>' % (
-            type(self).__name__,
-            self.access_handle.get_repr()
-        )
-
-
-class MixedName(compiled.CompiledName):
-    """
-    The ``CompiledName._compiled_object`` is our MixedObject.
-    """
-    @property
-    def start_pos(self):
-        contexts = list(self.infer())
-        if not contexts:
-            # This means a start_pos that doesn't exist (compiled objects).
-            return 0, 0
-        return contexts[0].name.start_pos
-
-    @start_pos.setter
-    def start_pos(self, value):
-        # Ignore the __init__'s start_pos setter call.
-        pass
-
-    @underscore_memoization
-    def infer(self):
-        # TODO use logic from compiled.CompiledObjectFilter
-        access_paths = self.parent_context.access_handle.getattr_paths(
-            self.string_name,
-            default=None
-        )
-        assert len(access_paths)
-        contexts = [None]
-        for access in access_paths:
-            contexts = ContextSet.from_sets(
-                _create(self._evaluator, access, parent_context=c)
-                if c is None or isinstance(c, MixedObject)
-                else ContextSet({create_cached_compiled_object(c.evaluator, access, c)})
-                for c in contexts
-            )
-        return contexts
-
-    @property
-    def api_type(self):
-        return next(iter(self.infer())).api_type
-
-
-class MixedObjectFilter(compiled.CompiledObjectFilter):
-    name_class = MixedName
-
-
-@evaluator_function_cache()
-def _load_module(evaluator, path):
-    module_node = evaluator.parse(
-        path=path,
-        cache=True,
-        diff_cache=settings.fast_parser,
-        cache_path=settings.cache_directory
-    ).get_root_node()
-    # python_module = inspect.getmodule(python_object)
-    # TODO we should actually make something like this possible.
-    #evaluator.modules[python_module.__name__] = module_node
-    return module_node
-
-
-def _get_object_to_check(python_object):
-    """Check if inspect.getfile has a chance to find the source."""
-    if sys.version_info[0] > 2:
-        python_object = inspect.unwrap(python_object)
-
-    if (inspect.ismodule(python_object) or
-            inspect.isclass(python_object) or
-            inspect.ismethod(python_object) or
-            inspect.isfunction(python_object) or
-            inspect.istraceback(python_object) or
-            inspect.isframe(python_object) or
-            inspect.iscode(python_object)):
-        return python_object
-
-    try:
-        return python_object.__class__
-    except AttributeError:
-        raise TypeError  # Prevents computation of `repr` within inspect.
-
-
-def _find_syntax_node_name(evaluator, python_object):
-    original_object = python_object
-    try:
-        python_object = _get_object_to_check(python_object)
-        path = inspect.getsourcefile(python_object)
-    except TypeError:
-        # The type might not be known (e.g. class_with_dict.__weakref__)
-        return None
-    if path is None or not os.path.exists(path):
-        # The path might not exist or be e.g. <stdin>.
-        return None
-
-    file_io = FileIO(path)
-    module_node = _load_module(evaluator, path)
-
-    if inspect.ismodule(python_object):
-        # We don't need to check names for modules, because there's not really
-        # a way to write a module in a module in Python (and also __name__ can
-        # be something like ``email.utils``).
-        code_lines = get_cached_code_lines(evaluator.grammar, path)
-        return module_node, module_node, file_io, code_lines
-
-    try:
-        name_str = python_object.__name__
-    except AttributeError:
-        # Stuff like python_function.__code__.
-        return None
-
-    if name_str == '<lambda>':
-        return None  # It's too hard to find lambdas.
-
-    # Doesn't always work (e.g. os.stat_result)
-    names = module_node.get_used_names().get(name_str, [])
-    # Only functions and classes are relevant. If a name e.g. points to an
-    # import, it's probably a builtin (like collections.deque) and needs to be
-    # ignored.
-    names = [
-        n for n in names
-        if n.parent.type in ('funcdef', 'classdef') and n.parent.name == n
-    ]
-    if not names:
-        return None
-
-    try:
-        code = python_object.__code__
-        # By using the line number of a code object we make the lookup in a
-        # file pretty easy. There's still a possibility of people defining
-        # stuff like ``a = 3; foo(a); a = 4`` on the same line, but if people
-        # do so we just don't care.
-        line_nr = code.co_firstlineno
-    except AttributeError:
-        pass
-    else:
-        line_names = [name for name in names if name.start_pos[0] == line_nr]
-        # There's a chance that the object is not available anymore, because
-        # the code has changed in the background.
-        if line_names:
-            names = line_names
-
-    code_lines = get_cached_code_lines(evaluator.grammar, path)
-    # It's really hard to actually get the right definition, here as a last
-    # resort we just return the last one. This chance might lead to odd
-    # completions at some points but will lead to mostly correct type
-    # inference, because people tend to define a public name in a module only
-    # once.
-    tree_node = names[-1].parent
-    if tree_node.type == 'funcdef' and get_api_type(original_object) == 'instance':
-        # If an instance is given and we're landing on a function (e.g.
-        # partial in 3.5), something is completely wrong and we should not
-        # return that.
-        return None
-    return module_node, tree_node, file_io, code_lines
-
-
-@compiled_objects_cache('mixed_cache')
-def _create(evaluator, access_handle, parent_context, *args):
-    compiled_object = create_cached_compiled_object(
-        evaluator,
-        access_handle,
-        parent_context=parent_context and parent_context.compiled_object
-    )
-
-    # TODO accessing this is bad, but it probably doesn't matter that much,
-    # because we're working with interpreteters only here.
-    python_object = access_handle.access._obj
-    result = _find_syntax_node_name(evaluator, python_object)
-    if result is None:
-        # TODO Care about generics from stuff like `[1]` and don't return like this.
-        if type(python_object) in (dict, list, tuple):
-            return ContextSet({compiled_object})
-
-        tree_contexts = to_stub(compiled_object)
-        if not tree_contexts:
-            return ContextSet({compiled_object})
-    else:
-        module_node, tree_node, file_io, code_lines = result
-
-        if parent_context is None:
-            # TODO this __name__ is probably wrong.
-            name = compiled_object.get_root_context().py__name__()
-            string_names = tuple(name.split('.'))
-            module_context = ModuleContext(
-                evaluator, module_node,
-                file_io=file_io,
-                string_names=string_names,
-                code_lines=code_lines,
-                is_package=hasattr(compiled_object, 'py__path__'),
-            )
-            if name is not None:
-                evaluator.module_cache.add(string_names, ContextSet([module_context]))
-        else:
-            if parent_context.tree_node.get_root_node() != module_node:
-                # This happens e.g. when __module__ is wrong, or when using
-                # TypeVar('foo'), where Jedi uses 'foo' as the name and
-                # Python's TypeVar('foo').__module__ will be typing.
-                return ContextSet({compiled_object})
-            module_context = parent_context.get_root_context()
-
-        tree_contexts = ContextSet({
-            module_context.create_context(
-                tree_node,
-                node_is_context=True,
-                node_is_object=True
-            )
-        })
-        if tree_node.type == 'classdef':
-            if not access_handle.is_class():
-                # Is an instance, not a class.
-                tree_contexts = tree_contexts.execute_evaluated()
-
-    return ContextSet(
-        MixedObject(compiled_object, tree_context=tree_context)
-        for tree_context in tree_contexts
-    )

jedi/evaluate/compiled/subprocess/__init__.py

@@ -1,406 +0,0 @@
-"""
-Makes it possible to do the compiled analysis in a subprocess. This has two
-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.
-"""
-
-import os
-import sys
-import subprocess
-import socket
-import errno
-import traceback
-from functools import partial
-from threading import Thread
-try:
-    from queue import Queue, Empty
-except ImportError:
-    from Queue import Queue, Empty  # python 2.7
-
-from jedi._compatibility import queue, is_py3, force_unicode, \
-    pickle_dump, pickle_load, GeneralizedPopen, weakref
-from jedi import debug
-from jedi.cache import memoize_method
-from jedi.evaluate.compiled.subprocess import functions
-from jedi.evaluate.compiled.access import DirectObjectAccess, AccessPath, \
-    SignatureParam
-from jedi.api.exceptions import InternalError
-
-
-_MAIN_PATH = os.path.join(os.path.dirname(__file__), '__main__.py')
-
-
-def _enqueue_output(out, queue):
-    for line in iter(out.readline, b''):
-        queue.put(line)
-
-
-def _add_stderr_to_debug(stderr_queue):
-    while True:
-        # Try to do some error reporting from the subprocess and print its
-        # stderr contents.
-        try:
-            line = stderr_queue.get_nowait()
-            line = line.decode('utf-8', 'replace')
-            debug.warning('stderr output: %s' % line.rstrip('\n'))
-        except Empty:
-            break
-
-
-def _get_function(name):
-    return getattr(functions, name)
-
-
-def _cleanup_process(process, thread):
-    try:
-        process.kill()
-        process.wait()
-    except OSError:
-        # Raised if the process is already killed.
-        pass
-    thread.join()
-    for stream in [process.stdin, process.stdout, process.stderr]:
-        try:
-            stream.close()
-        except OSError:
-            # Raised if the stream is broken.
-            pass
-
-
-class _EvaluatorProcess(object):
-    def __init__(self, evaluator):
-        self._evaluator_weakref = weakref.ref(evaluator)
-        self._evaluator_id = id(evaluator)
-        self._handles = {}
-
-    def get_or_create_access_handle(self, obj):
-        id_ = id(obj)
-        try:
-            return self.get_access_handle(id_)
-        except KeyError:
-            access = DirectObjectAccess(self._evaluator_weakref(), obj)
-            handle = AccessHandle(self, access, id_)
-            self.set_access_handle(handle)
-            return handle
-
-    def get_access_handle(self, id_):
-        return self._handles[id_]
-
-    def set_access_handle(self, handle):
-        self._handles[handle.id] = handle
-
-
-class EvaluatorSameProcess(_EvaluatorProcess):
-    """
-    Basically just an easy access to functions.py. It has the same API
-    as EvaluatorSubprocess and does the same thing without using a subprocess.
-    This is necessary for the Interpreter process.
-    """
-    def __getattr__(self, name):
-        return partial(_get_function(name), self._evaluator_weakref())
-
-
-class EvaluatorSubprocess(_EvaluatorProcess):
-    def __init__(self, evaluator, compiled_subprocess):
-        super(EvaluatorSubprocess, self).__init__(evaluator)
-        self._used = False
-        self._compiled_subprocess = compiled_subprocess
-
-    def __getattr__(self, name):
-        func = _get_function(name)
-
-        def wrapper(*args, **kwargs):
-            self._used = True
-
-            result = self._compiled_subprocess.run(
-                self._evaluator_weakref(),
-                func,
-                args=args,
-                kwargs=kwargs,
-            )
-            # IMO it should be possible to create a hook in pickle.load to
-            # mess with the loaded objects. However it's extremely complicated
-            # to work around this so just do it with this call. ~ dave
-            return self._convert_access_handles(result)
-
-        return wrapper
-
-    def _convert_access_handles(self, obj):
-        if isinstance(obj, SignatureParam):
-            return SignatureParam(*self._convert_access_handles(tuple(obj)))
-        elif isinstance(obj, tuple):
-            return tuple(self._convert_access_handles(o) for o in obj)
-        elif isinstance(obj, list):
-            return [self._convert_access_handles(o) for o in obj]
-        elif isinstance(obj, AccessHandle):
-            try:
-                # Rewrite the access handle to one we're already having.
-                obj = self.get_access_handle(obj.id)
-            except KeyError:
-                obj.add_subprocess(self)
-                self.set_access_handle(obj)
-        elif isinstance(obj, AccessPath):
-            return AccessPath(self._convert_access_handles(obj.accesses))
-        return obj
-
-    def __del__(self):
-        if self._used and not self._compiled_subprocess.is_crashed:
-            self._compiled_subprocess.delete_evaluator(self._evaluator_id)
-
-
-class CompiledSubprocess(object):
-    is_crashed = False
-    # Start with 2, gets set after _get_info.
-    _pickle_protocol = 2
-
-    def __init__(self, executable):
-        self._executable = executable
-        self._evaluator_deletion_queue = queue.deque()
-        self._cleanup_callable = lambda: None
-
-    def __repr__(self):
-        pid = os.getpid()
-        return '<%s _executable=%r, _pickle_protocol=%r, is_crashed=%r, pid=%r>' % (
-            self.__class__.__name__,
-            self._executable,
-            self._pickle_protocol,
-            self.is_crashed,
-            pid,
-        )
-
-    @memoize_method
-    def _get_process(self):
-        debug.dbg('Start environment subprocess %s', self._executable)
-        parso_path = sys.modules['parso'].__file__
-        args = (
-            self._executable,
-            _MAIN_PATH,
-            os.path.dirname(os.path.dirname(parso_path)),
-            '.'.join(str(x) for x in sys.version_info[:3]),
-        )
-        process = GeneralizedPopen(
-            args,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            # Use system default buffering on Python 2 to improve performance
-            # (this is already the case on Python 3).
-            bufsize=-1
-        )
-        self._stderr_queue = Queue()
-        self._stderr_thread = t = Thread(
-            target=_enqueue_output,
-            args=(process.stderr, self._stderr_queue)
-        )
-        t.daemon = True
-        t.start()
-        # Ensure the subprocess is properly cleaned up when the object
-        # is garbage collected.
-        self._cleanup_callable = weakref.finalize(self,
-                                                  _cleanup_process,
-                                                  process,
-                                                  t)
-        return process
-
-    def run(self, evaluator, function, args=(), kwargs={}):
-        # Delete old evaluators.
-        while True:
-            try:
-                evaluator_id = self._evaluator_deletion_queue.pop()
-            except IndexError:
-                break
-            else:
-                self._send(evaluator_id, None)
-
-        assert callable(function)
-        return self._send(id(evaluator), function, args, kwargs)
-
-    def get_sys_path(self):
-        return self._send(None, functions.get_sys_path, (), {})
-
-    def _kill(self):
-        self.is_crashed = True
-        self._cleanup_callable()
-
-    def _send(self, evaluator_id, function, args=(), kwargs={}):
-        if self.is_crashed:
-            raise InternalError("The subprocess %s has crashed." % self._executable)
-
-        if not is_py3:
-            # Python 2 compatibility
-            kwargs = {force_unicode(key): value for key, value in kwargs.items()}
-
-        data = evaluator_id, function, args, kwargs
-        try:
-            pickle_dump(data, self._get_process().stdin, self._pickle_protocol)
-        except (socket.error, IOError) as e:
-            # Once Python2 will be removed we can just use `BrokenPipeError`.
-            # Also, somehow in windows it returns EINVAL instead of EPIPE if
-            # the subprocess dies.
-            if e.errno not in (errno.EPIPE, errno.EINVAL):
-                # Not a broken pipe
-                raise
-            self._kill()
-            raise InternalError("The subprocess %s was killed. Maybe out of memory?"
-                                % self._executable)
-
-        try:
-            is_exception, traceback, result = pickle_load(self._get_process().stdout)
-        except EOFError as eof_error:
-            try:
-                stderr = self._get_process().stderr.read().decode('utf-8', 'replace')
-            except Exception as exc:
-                stderr = '<empty/not available (%r)>' % exc
-            self._kill()
-            _add_stderr_to_debug(self._stderr_queue)
-            raise InternalError(
-                "The subprocess %s has crashed (%r, stderr=%s)." % (
-                    self._executable,
-                    eof_error,
-                    stderr,
-                ))
-
-        _add_stderr_to_debug(self._stderr_queue)
-
-        if is_exception:
-            # Replace the attribute error message with a the traceback. It's
-            # way more informative.
-            result.args = (traceback,)
-            raise result
-        return result
-
-    def delete_evaluator(self, evaluator_id):
-        """
-        Currently we are not deleting evalutors 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 evaluator shouldn't be that high.
-        """
-        # With an argument - the evaluator gets deleted.
-        self._evaluator_deletion_queue.append(evaluator_id)
-
-
-class Listener(object):
-    def __init__(self, pickle_protocol):
-        self._evaluators = {}
-        # TODO refactor so we don't need to process anymore just handle
-        # controlling.
-        self._process = _EvaluatorProcess(Listener)
-        self._pickle_protocol = pickle_protocol
-
-    def _get_evaluator(self, function, evaluator_id):
-        from jedi.evaluate import Evaluator
-
-        try:
-            evaluator = self._evaluators[evaluator_id]
-        except KeyError:
-            from jedi.api.environment import InterpreterEnvironment
-            evaluator = Evaluator(
-                # The project is not actually needed. Nothing should need to
-                # access it.
-                project=None,
-                environment=InterpreterEnvironment()
-            )
-            self._evaluators[evaluator_id] = evaluator
-        return evaluator
-
-    def _run(self, evaluator_id, function, args, kwargs):
-        if evaluator_id is None:
-            return function(*args, **kwargs)
-        elif function is None:
-            del self._evaluators[evaluator_id]
-        else:
-            evaluator = self._get_evaluator(function, evaluator_id)
-
-            # Exchange all handles
-            args = list(args)
-            for i, arg in enumerate(args):
-                if isinstance(arg, AccessHandle):
-                    args[i] = evaluator.compiled_subprocess.get_access_handle(arg.id)
-            for key, value in kwargs.items():
-                if isinstance(value, AccessHandle):
-                    kwargs[key] = evaluator.compiled_subprocess.get_access_handle(value.id)
-
-            return function(evaluator, *args, **kwargs)
-
-    def listen(self):
-        stdout = sys.stdout
-        # Mute stdout. Nobody should actually be able to write to it,
-        # because stdout is used for IPC.
-        sys.stdout = open(os.devnull, 'w')
-        stdin = sys.stdin
-        if sys.version_info[0] > 2:
-            stdout = stdout.buffer
-            stdin = stdin.buffer
-        # Python 2 opens streams in text mode on Windows. Set stdout and stdin
-        # to binary mode.
-        elif sys.platform == 'win32':
-            import msvcrt
-            msvcrt.setmode(stdout.fileno(), os.O_BINARY)
-            msvcrt.setmode(stdin.fileno(), os.O_BINARY)
-
-        while True:
-            try:
-                payload = pickle_load(stdin)
-            except EOFError:
-                # It looks like the parent process closed.
-                # Don't make a big fuss here and just exit.
-                exit(0)
-            try:
-                result = False, None, self._run(*payload)
-            except Exception as e:
-                result = True, traceback.format_exc(), e
-
-            pickle_dump(result, stdout, self._pickle_protocol)
-
-
-class AccessHandle(object):
-    def __init__(self, subprocess, access, id_):
-        self.access = access
-        self._subprocess = subprocess
-        self.id = id_
-
-    def add_subprocess(self, subprocess):
-        self._subprocess = subprocess
-
-    def __repr__(self):
-        try:
-            detail = self.access
-        except AttributeError:
-            detail = '#' + str(self.id)
-        return '<%s of %s>' % (self.__class__.__name__, detail)
-
-    def __getstate__(self):
-        return self.id
-
-    def __setstate__(self, state):
-        self.id = state
-
-    def __getattr__(self, name):
-        if name in ('id', 'access') or name.startswith('_'):
-            raise AttributeError("Something went wrong with unpickling")
-
-        #if not is_py3: print >> sys.stderr, name
-        #print('getattr', name, file=sys.stderr)
-        return partial(self._workaround, force_unicode(name))
-
-    def _workaround(self, name, *args, **kwargs):
-        """
-        TODO Currently we're passing slice objects around. This should not
-        happen. They are also the only unhashable objects that we're passing
-        around.
-        """
-        if args and isinstance(args[0], slice):
-            return self._subprocess.get_compiled_method_return(self.id, name, *args, **kwargs)
-        return self._cached_results(name, *args, **kwargs)
-
-    @memoize_method
-    def _cached_results(self, name, *args, **kwargs):
-        #if type(self._subprocess) == EvaluatorSubprocess:
-            #print(name, args, kwargs,
-                #self._subprocess.get_compiled_method_return(self.id, name, *args, **kwargs)
-            #)
-        return self._subprocess.get_compiled_method_return(self.id, name, *args, **kwargs)

jedi/evaluate/compiled/subprocess/__main__.py

@@ -1,55 +0,0 @@
-import os
-import sys
-
-
-def _get_paths():
-    # Get the path to jedi.
-    _d = os.path.dirname
-    _jedi_path = _d(_d(_d(_d(_d(__file__)))))
-    _parso_path = sys.argv[1]
-    # The paths are the directory that jedi and parso lie in.
-    return {'jedi': _jedi_path, 'parso': _parso_path}
-
-
-# Remove the first entry, because it's simply a directory entry that equals
-# this directory.
-del sys.path[0]
-
-if sys.version_info > (3, 4):
-    from importlib.machinery import PathFinder
-
-    class _ExactImporter(object):
-        def __init__(self, path_dct):
-            self._path_dct = path_dct
-
-        def find_module(self, fullname, path=None):
-            if path is None and fullname in self._path_dct:
-                p = self._path_dct[fullname]
-                loader = PathFinder.find_module(fullname, path=[p])
-                return loader
-            return None
-
-    # Try to import jedi/parso.
-    sys.meta_path.insert(0, _ExactImporter(_get_paths()))
-    from jedi.evaluate.compiled import subprocess  # NOQA
-    sys.meta_path.pop(0)
-else:
-    import imp
-
-    def load(name):
-        paths = list(_get_paths().values())
-        fp, pathname, description = imp.find_module(name, paths)
-        return imp.load_module(name, fp, pathname, description)
-
-    load('parso')
-    load('jedi')
-    from jedi.evaluate.compiled import subprocess  # NOQA
-
-from jedi._compatibility import highest_pickle_protocol  # noqa: E402
-
-
-# Retrieve the pickle protocol.
-host_sys_version = [int(x) for x in sys.argv[2].split('.')]
-pickle_protocol = highest_pickle_protocol([sys.version_info, host_sys_version])
-# And finally start the client.
-subprocess.Listener(pickle_protocol=pickle_protocol).listen()

jedi/evaluate/compiled/subprocess/functions.py

@@ -1,86 +0,0 @@
-from __future__ import print_function
-import sys
-import os
-
-from jedi._compatibility import find_module, cast_path, force_unicode, \
-    iter_modules, all_suffixes
-from jedi.evaluate.compiled import access
-from jedi import parser_utils
-
-
-def get_sys_path():
-    return list(map(cast_path, sys.path))
-
-
-def load_module(evaluator, **kwargs):
-    return access.load_module(evaluator, **kwargs)
-
-
-def get_compiled_method_return(evaluator, id, attribute, *args, **kwargs):
-    handle = evaluator.compiled_subprocess.get_access_handle(id)
-    return getattr(handle.access, attribute)(*args, **kwargs)
-
-
-def create_simple_object(evaluator, obj):
-    return access.create_access_path(evaluator, obj)
-
-
-def get_module_info(evaluator, sys_path=None, full_name=None, **kwargs):
-    """
-    Returns Tuple[Union[NamespaceInfo, FileIO, None], Optional[bool]]
-    """
-    if sys_path is not None:
-        sys.path, temp = sys_path, sys.path
-    try:
-        return find_module(full_name=full_name, **kwargs)
-    except ImportError:
-        return None, None
-    finally:
-        if sys_path is not None:
-            sys.path = temp
-
-
-def list_module_names(evaluator, search_path):
-    return [
-        force_unicode(name)
-        for module_loader, name, is_pkg in iter_modules(search_path)
-    ]
-
-
-def get_builtin_module_names(evaluator):
-    return list(map(force_unicode, sys.builtin_module_names))
-
-
-def _test_raise_error(evaluator, exception_type):
-    """
-    Raise an error to simulate certain problems for unit tests.
-    """
-    raise exception_type
-
-
-def _test_print(evaluator, stderr=None, stdout=None):
-    """
-    Force some prints in the subprocesses. This exists for unit tests.
-    """
-    if stderr is not None:
-        print(stderr, file=sys.stderr)
-        sys.stderr.flush()
-    if stdout is not None:
-        print(stdout)
-        sys.stdout.flush()
-
-
-def _get_init_path(directory_path):
-    """
-    The __init__ file can be searched in a directory. If found return it, else
-    None.
-    """
-    for suffix in all_suffixes():
-        path = os.path.join(directory_path, '__init__' + suffix)
-        if os.path.exists(path):
-            return path
-    return None
-
-
-def safe_literal_eval(evaluator, value):
-    return parser_utils.safe_literal_eval(value)

jedi/evaluate/context/__init__.py

@@ -1,6 +0,0 @@
-from jedi.evaluate.context.module import ModuleContext
-from jedi.evaluate.context.klass import ClassContext
-from jedi.evaluate.context.function import FunctionContext, \
-    MethodContext, FunctionExecutionContext
-from jedi.evaluate.context.instance import AnonymousInstance, BoundMethod, \
-    CompiledInstance, AbstractInstanceContext, TreeInstance

jedi/evaluate/context/decorator.py

@@ -1,15 +0,0 @@
-'''
-Decorators are not really contexts, however we need some wrappers to improve
-docstrings and other things around decorators.
-'''
-
-from jedi.evaluate.base_context import ContextWrapper
-
-
-class Decoratee(ContextWrapper):
-    def __init__(self, wrapped_context, original_context):
-        self._wrapped_context = wrapped_context
-        self._original_context = original_context
-
-    def py__doc__(self):
-        return self._original_context.py__doc__()

jedi/evaluate/context/function.py

@@ -1,444 +0,0 @@
-from parso.python import tree
-
-from jedi._compatibility import use_metaclass
-from jedi import debug
-from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass
-from jedi.evaluate import compiled
-from jedi.evaluate import recursion
-from jedi.evaluate import docstrings
-from jedi.evaluate import flow_analysis
-from jedi.evaluate import helpers
-from jedi.evaluate.signature import TreeSignature
-from jedi.evaluate.arguments import AnonymousArguments
-from jedi.evaluate.filters import ParserTreeFilter, FunctionExecutionFilter
-from jedi.evaluate.names import ContextName, AbstractNameDefinition, ParamName
-from jedi.evaluate.base_context import ContextualizedNode, NO_CONTEXTS, \
-    ContextSet, TreeContext, ContextWrapper
-from jedi.evaluate.lazy_context import LazyKnownContexts, LazyKnownContext, \
-    LazyTreeContext
-from jedi.evaluate.context import iterable
-from jedi import parser_utils
-from jedi.evaluate.parser_cache import get_yield_exprs
-from jedi.evaluate.helpers import contexts_from_qualified_names
-
-
-class LambdaName(AbstractNameDefinition):
-    string_name = '<lambda>'
-    api_type = u'function'
-
-    def __init__(self, lambda_context):
-        self._lambda_context = lambda_context
-        self.parent_context = lambda_context.parent_context
-
-    @property
-    def start_pos(self):
-        return self._lambda_context.tree_node.start_pos
-
-    def infer(self):
-        return ContextSet([self._lambda_context])
-
-
-class FunctionAndClassBase(TreeContext):
-    def get_qualified_names(self):
-        if self.parent_context.is_class():
-            n = self.parent_context.get_qualified_names()
-            if n is None:
-                # This means that the parent class lives within a function.
-                return None
-            return n + (self.py__name__(),)
-        elif self.parent_context.is_module():
-            return (self.py__name__(),)
-        else:
-            return None
-
-
-class FunctionMixin(object):
-    api_type = u'function'
-
-    def get_filters(self, search_global=False, until_position=None, origin_scope=None):
-        if search_global:
-            yield ParserTreeFilter(
-                self.evaluator,
-                context=self,
-                until_position=until_position,
-                origin_scope=origin_scope
-            )
-        else:
-            cls = self.py__class__()
-            for instance in cls.execute_evaluated():
-                for filter in instance.get_filters(search_global=False, origin_scope=origin_scope):
-                    yield filter
-
-    def py__get__(self, instance, class_context):
-        from jedi.evaluate.context.instance import BoundMethod
-        if instance is None:
-            # Calling the Foo.bar results in the original bar function.
-            return ContextSet([self])
-        return ContextSet([BoundMethod(instance, self)])
-
-    def get_param_names(self):
-        function_execution = self.get_function_execution()
-        return [ParamName(function_execution, param.name)
-                for param in self.tree_node.get_params()]
-
-    @property
-    def name(self):
-        if self.tree_node.type == 'lambdef':
-            return LambdaName(self)
-        return ContextName(self, self.tree_node.name)
-
-    def py__name__(self):
-        return self.name.string_name
-
-    def py__call__(self, arguments):
-        function_execution = self.get_function_execution(arguments)
-        return function_execution.infer()
-
-    def get_function_execution(self, arguments=None):
-        if arguments is None:
-            arguments = AnonymousArguments()
-
-        return FunctionExecutionContext(self.evaluator, self.parent_context, self, arguments)
-
-    def get_signatures(self):
-        return [TreeSignature(f) for f in self.get_signature_functions()]
-
-
-class FunctionContext(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndClassBase)):
-    """
-    Needed because of decorators. Decorators are evaluated here.
-    """
-    def is_function(self):
-        return True
-
-    @classmethod
-    def from_context(cls, context, tree_node):
-        def create(tree_node):
-            if context.is_class():
-                return MethodContext(
-                    context.evaluator,
-                    context,
-                    parent_context=parent_context,
-                    tree_node=tree_node
-                )
-            else:
-                return cls(
-                    context.evaluator,
-                    parent_context=parent_context,
-                    tree_node=tree_node
-                )
-
-        overloaded_funcs = list(_find_overload_functions(context, tree_node))
-
-        parent_context = context
-        while parent_context.is_class() or parent_context.is_instance():
-            parent_context = parent_context.parent_context
-
-        function = create(tree_node)
-
-        if overloaded_funcs:
-            return OverloadedFunctionContext(
-                function,
-                [create(f) for f in overloaded_funcs]
-            )
-        return function
-
-    def py__class__(self):
-        c, = contexts_from_qualified_names(self.evaluator, u'types', u'FunctionType')
-        return c
-
-    def get_default_param_context(self):
-        return self.parent_context
-
-    def get_signature_functions(self):
-        return [self]
-
-
-class MethodContext(FunctionContext):
-    def __init__(self, evaluator, class_context, *args, **kwargs):
-        super(MethodContext, self).__init__(evaluator, *args, **kwargs)
-        self.class_context = class_context
-
-    def get_default_param_context(self):
-        return self.class_context
-
-    def get_qualified_names(self):
-        # Need to implement this, because the parent context of a method
-        # context is not the class context but the module.
-        names = self.class_context.get_qualified_names()
-        if names is None:
-            return None
-        return names + (self.py__name__(),)
-
-
-class FunctionExecutionContext(TreeContext):
-    """
-    This class is used to evaluate functions and their returns.
-
-    This is the most complicated class, because it contains the logic to
-    transfer parameters. It is even more complicated, because there may be
-    multiple calls to functions and recursion has to be avoided. But this is
-    responsibility of the decorators.
-    """
-    function_execution_filter = FunctionExecutionFilter
-
-    def __init__(self, evaluator, parent_context, function_context, var_args):
-        super(FunctionExecutionContext, self).__init__(
-            evaluator,
-            parent_context,
-            function_context.tree_node,
-        )
-        self.function_context = function_context
-        self.var_args = var_args
-
-    @evaluator_method_cache(default=NO_CONTEXTS)
-    @recursion.execution_recursion_decorator()
-    def get_return_values(self, check_yields=False):
-        funcdef = self.tree_node
-        if funcdef.type == 'lambdef':
-            return self.eval_node(funcdef.children[-1])
-
-        if check_yields:
-            context_set = NO_CONTEXTS
-            returns = get_yield_exprs(self.evaluator, funcdef)
-        else:
-            returns = funcdef.iter_return_stmts()
-            from jedi.evaluate.gradual.annotation import infer_return_types
-            context_set = infer_return_types(self)
-            if context_set:
-                # If there are annotations, prefer them over anything else.
-                # This will make it faster.
-                return context_set
-            context_set |= docstrings.infer_return_types(self.function_context)
-
-        for r in returns:
-            check = flow_analysis.reachability_check(self, funcdef, r)
-            if check is flow_analysis.UNREACHABLE:
-                debug.dbg('Return unreachable: %s', r)
-            else:
-                if check_yields:
-                    context_set |= ContextSet.from_sets(
-                        lazy_context.infer()
-                        for lazy_context in self._get_yield_lazy_context(r)
-                    )
-                else:
-                    try:
-                        children = r.children
-                    except AttributeError:
-                        ctx = compiled.builtin_from_name(self.evaluator, u'None')
-                        context_set |= ContextSet([ctx])
-                    else:
-                        context_set |= self.eval_node(children[1])
-            if check is flow_analysis.REACHABLE:
-                debug.dbg('Return reachable: %s', r)
-                break
-        return context_set
-
-    def _get_yield_lazy_context(self, yield_expr):
-        if yield_expr.type == 'keyword':
-            # `yield` just yields None.
-            ctx = compiled.builtin_from_name(self.evaluator, u'None')
-            yield LazyKnownContext(ctx)
-            return
-
-        node = yield_expr.children[1]
-        if node.type == 'yield_arg':  # It must be a yield from.
-            cn = ContextualizedNode(self, node.children[1])
-            for lazy_context in cn.infer().iterate(cn):
-                yield lazy_context
-        else:
-            yield LazyTreeContext(self, node)
-
-    @recursion.execution_recursion_decorator(default=iter([]))
-    def get_yield_lazy_contexts(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',
-                                                'while_stmt', 'if_stmt'))
-                       for y in get_yield_exprs(self.evaluator, self.tree_node)]
-
-        # Calculate if the yields are placed within the same for loop.
-        yields_order = []
-        last_for_stmt = None
-        for yield_, for_stmt in for_parents:
-            # For really simple for loops we can predict the order. Otherwise
-            # we just ignore it.
-            parent = for_stmt.parent
-            if parent.type == 'suite':
-                parent = parent.parent
-            if for_stmt.type == 'for_stmt' and parent == self.tree_node \
-                    and parser_utils.for_stmt_defines_one_name(for_stmt):  # Simplicity for now.
-                if for_stmt == last_for_stmt:
-                    yields_order[-1][1].append(yield_)
-                else:
-                    yields_order.append((for_stmt, [yield_]))
-            elif for_stmt == self.tree_node:
-                yields_order.append((None, [yield_]))
-            else:
-                types = self.get_return_values(check_yields=True)
-                if types:
-                    yield LazyKnownContexts(types)
-                return
-            last_for_stmt = for_stmt
-
-        for for_stmt, yields in yields_order:
-            if for_stmt is None:
-                # No for_stmt, just normal yields.
-                for yield_ in yields:
-                    for result in self._get_yield_lazy_context(yield_):
-                        yield result
-            else:
-                input_node = for_stmt.get_testlist()
-                cn = ContextualizedNode(self, input_node)
-                ordered = cn.infer().iterate(cn)
-                ordered = list(ordered)
-                for lazy_context in ordered:
-                    dct = {str(for_stmt.children[1].value): lazy_context.infer()}
-                    with helpers.predefine_names(self, for_stmt, dct):
-                        for yield_in_same_for_stmt in yields:
-                            for result in self._get_yield_lazy_context(yield_in_same_for_stmt):
-                                yield result
-
-    def merge_yield_contexts(self, is_async=False):
-        return ContextSet.from_sets(
-            lazy_context.infer()
-            for lazy_context in self.get_yield_lazy_contexts()
-        )
-
-    def get_filters(self, search_global=False, until_position=None, origin_scope=None):
-        yield self.function_execution_filter(self.evaluator, self,
-                                             until_position=until_position,
-                                             origin_scope=origin_scope)
-
-    @evaluator_method_cache()
-    def get_executed_params_and_issues(self):
-        return self.var_args.get_executed_params_and_issues(self)
-
-    def matches_signature(self):
-        executed_params, issues = self.get_executed_params_and_issues()
-        if issues:
-            return False
-
-        matches = all(executed_param.matches_signature()
-                      for executed_param in executed_params)
-        if debug.enable_notice:
-            signature = parser_utils.get_call_signature(self.tree_node)
-            if matches:
-                debug.dbg("Overloading match: %s@%s (%s)",
-                          signature, self.tree_node.start_pos[0], self.var_args, color='BLUE')
-            else:
-                debug.dbg("Overloading no match: %s@%s (%s)",
-                          signature, self.tree_node.start_pos[0], self.var_args, color='BLUE')
-        return matches
-
-    def infer(self):
-        """
-        Created to be used by inheritance.
-        """
-        evaluator = self.evaluator
-        is_coroutine = self.tree_node.parent.type in ('async_stmt', 'async_funcdef')
-        is_generator = bool(get_yield_exprs(evaluator, self.tree_node))
-        from jedi.evaluate.gradual.typing import GenericClass
-
-        if is_coroutine:
-            if is_generator:
-                if evaluator.environment.version_info < (3, 6):
-                    return NO_CONTEXTS
-                async_generator_classes = evaluator.typing_module \
-                    .py__getattribute__('AsyncGenerator')
-
-                yield_contexts = self.merge_yield_contexts(is_async=True)
-                # The contravariant doesn't seem to be defined.
-                generics = (yield_contexts.py__class__(), NO_CONTEXTS)
-                return ContextSet(
-                    # In Python 3.6 AsyncGenerator is still a class.
-                    GenericClass(c, generics)
-                    for c in async_generator_classes
-                ).execute_annotation()
-            else:
-                if evaluator.environment.version_info < (3, 5):
-                    return NO_CONTEXTS
-                async_classes = evaluator.typing_module.py__getattribute__('Coroutine')
-                return_contexts = self.get_return_values()
-                # Only the first generic is relevant.
-                generics = (return_contexts.py__class__(), NO_CONTEXTS, NO_CONTEXTS)
-                return ContextSet(
-                    GenericClass(c, generics) for c in async_classes
-                ).execute_annotation()
-        else:
-            if is_generator:
-                return ContextSet([iterable.Generator(evaluator, self)])
-            else:
-                return self.get_return_values()
-
-
-class OverloadedFunctionContext(FunctionMixin, ContextWrapper):
-    def __init__(self, function, overloaded_functions):
-        super(OverloadedFunctionContext, self).__init__(function)
-        self._overloaded_functions = overloaded_functions
-
-    def py__call__(self, arguments):
-        debug.dbg("Execute overloaded function %s", self._wrapped_context, color='BLUE')
-        function_executions = []
-        context_set = NO_CONTEXTS
-        matched = False
-        for f in self._overloaded_functions:
-            function_execution = f.get_function_execution(arguments)
-            function_executions.append(function_execution)
-            if function_execution.matches_signature():
-                matched = True
-                return function_execution.infer()
-
-        if matched:
-            return context_set
-
-        if self.evaluator.is_analysis:
-            # In this case we want precision.
-            return NO_CONTEXTS
-        return ContextSet.from_sets(fe.infer() for fe in function_executions)
-
-    def get_signature_functions(self):
-        return self._overloaded_functions
-
-
-def _find_overload_functions(context, tree_node):
-    def _is_overload_decorated(funcdef):
-        if funcdef.parent.type == 'decorated':
-            decorators = funcdef.parent.children[0]
-            if decorators.type == 'decorator':
-                decorators = [decorators]
-            else:
-                decorators = decorators.children
-            for decorator in decorators:
-                dotted_name = decorator.children[1]
-                if dotted_name.type == 'name' and dotted_name.value == 'overload':
-                    # TODO check with contexts if it's the right overload
-                    return True
-        return False
-
-    if tree_node.type == 'lambdef':
-        return
-
-    if _is_overload_decorated(tree_node):
-        yield tree_node
-
-    while True:
-        filter = ParserTreeFilter(
-            context.evaluator,
-            context,
-            until_position=tree_node.start_pos
-        )
-        names = filter.get(tree_node.name.value)
-        assert isinstance(names, list)
-        if not names:
-            break
-
-        found = False
-        for name in names:
-            funcdef = name.tree_name.parent
-            if funcdef.type == 'funcdef' and _is_overload_decorated(funcdef):
-                tree_node = funcdef
-                found = True
-                yield funcdef
-
-        if not found:
-            break

jedi/evaluate/context/instance.py

@@ -1,531 +0,0 @@
-from abc import abstractproperty
-
-from jedi import debug
-from jedi import settings
-from jedi.evaluate import compiled
-from jedi.evaluate.compiled.context import CompiledObjectFilter
-from jedi.evaluate.helpers import contexts_from_qualified_names
-from jedi.evaluate.filters import AbstractFilter
-from jedi.evaluate.names import ContextName, TreeNameDefinition
-from jedi.evaluate.base_context import Context, NO_CONTEXTS, ContextSet, \
-    iterator_to_context_set, ContextWrapper
-from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.arguments import AnonymousArguments, \
-    ValuesArguments, TreeArgumentsWrapper
-from jedi.evaluate.context.function import \
-    FunctionContext, FunctionMixin, OverloadedFunctionContext
-from jedi.evaluate.context.klass import ClassContext, apply_py__get__, \
-    ClassFilter
-from jedi.evaluate.context import iterable
-from jedi.parser_utils import get_parent_scope
-
-
-class InstanceExecutedParam(object):
-    def __init__(self, instance, tree_param):
-        self._instance = instance
-        self._tree_param = tree_param
-        self.string_name = self._tree_param.name.value
-
-    def infer(self):
-        return ContextSet([self._instance])
-
-    def matches_signature(self):
-        return True
-
-
-class AnonymousInstanceArguments(AnonymousArguments):
-    def __init__(self, instance):
-        self._instance = instance
-
-    def get_executed_params_and_issues(self, execution_context):
-        from jedi.evaluate.dynamic import search_params
-        tree_params = execution_context.tree_node.get_params()
-        if not tree_params:
-            return [], []
-
-        self_param = InstanceExecutedParam(self._instance, tree_params[0])
-        if len(tree_params) == 1:
-            # If the only param is self, we don't need to try to find
-            # executions of this function, we have all the params already.
-            return [self_param], []
-        executed_params = list(search_params(
-            execution_context.evaluator,
-            execution_context,
-            execution_context.tree_node
-        ))
-        executed_params[0] = self_param
-        return executed_params, []
-
-
-class AbstractInstanceContext(Context):
-    """
-    This class is used to evaluate instances.
-    """
-    api_type = u'instance'
-
-    def __init__(self, evaluator, parent_context, class_context, var_args):
-        super(AbstractInstanceContext, self).__init__(evaluator, parent_context)
-        # Generated instances are classes that are just generated by self
-        # (No var_args) used.
-        self.class_context = class_context
-        self.var_args = var_args
-
-    def is_instance(self):
-        return True
-
-    def get_qualified_names(self):
-        return self.class_context.get_qualified_names()
-
-    def get_annotated_class_object(self):
-        return self.class_context  # This is the default.
-
-    def py__call__(self, arguments):
-        names = self.get_function_slot_names(u'__call__')
-        if not names:
-            # Means the Instance is not callable.
-            return super(AbstractInstanceContext, self).py__call__(arguments)
-
-        return ContextSet.from_sets(name.infer().execute(arguments) for name in names)
-
-    def py__class__(self):
-        return self.class_context
-
-    def py__bool__(self):
-        # Signalize that we don't know about the bool type.
-        return None
-
-    def get_function_slot_names(self, name):
-        # Python classes don't look at the dictionary of the instance when
-        # looking up `__call__`. This is something that has to do with Python's
-        # internal slot system (note: not __slots__, but C slots).
-        for filter in self.get_filters(include_self_names=False):
-            names = filter.get(name)
-            if names:
-                return names
-        return []
-
-    def execute_function_slots(self, names, *evaluated_args):
-        return ContextSet.from_sets(
-            name.infer().execute_evaluated(*evaluated_args)
-            for name in names
-        )
-
-    def py__get__(self, obj, class_context):
-        """
-        obj may be None.
-        """
-        # Arguments in __get__ descriptors are obj, class.
-        # `method` is the new parent of the array, don't know if that's good.
-        names = self.get_function_slot_names(u'__get__')
-        if names:
-            if obj is None:
-                obj = compiled.builtin_from_name(self.evaluator, u'None')
-            return self.execute_function_slots(names, obj, class_context)
-        else:
-            return ContextSet([self])
-
-    def get_filters(self, search_global=None, until_position=None,
-                    origin_scope=None, include_self_names=True):
-        class_context = self.get_annotated_class_object()
-        if include_self_names:
-            for cls in class_context.py__mro__():
-                if not isinstance(cls, compiled.CompiledObject) \
-                        or cls.tree_node is not None:
-                    # In this case we're excluding compiled objects that are
-                    # not fake objects. It doesn't make sense for normal
-                    # compiled objects to search for self variables.
-                    yield SelfAttributeFilter(self.evaluator, self, cls, origin_scope)
-
-        class_filters = class_context.get_filters(
-            search_global=False,
-            origin_scope=origin_scope,
-            is_instance=True,
-        )
-        for f in class_filters:
-            if isinstance(f, ClassFilter):
-                yield InstanceClassFilter(self.evaluator, self, f)
-            elif isinstance(f, CompiledObjectFilter):
-                yield CompiledInstanceClassFilter(self.evaluator, self, f)
-            else:
-                # Propably from the metaclass.
-                yield f
-
-    def py__getitem__(self, index_context_set, contextualized_node):
-        names = self.get_function_slot_names(u'__getitem__')
-        if not names:
-            return super(AbstractInstanceContext, self).py__getitem__(
-                index_context_set,
-                contextualized_node,
-            )
-
-        args = ValuesArguments([index_context_set])
-        return ContextSet.from_sets(name.infer().execute(args) for name in names)
-
-    def py__iter__(self, contextualized_node=None):
-        iter_slot_names = self.get_function_slot_names(u'__iter__')
-        if not iter_slot_names:
-            return super(AbstractInstanceContext, self).py__iter__(contextualized_node)
-
-        def iterate():
-            for generator in self.execute_function_slots(iter_slot_names):
-                if generator.is_instance() and not generator.is_compiled():
-                    # `__next__` logic.
-                    if self.evaluator.environment.version_info.major == 2:
-                        name = u'next'
-                    else:
-                        name = u'__next__'
-                    next_slot_names = generator.get_function_slot_names(name)
-                    if next_slot_names:
-                        yield LazyKnownContexts(
-                            generator.execute_function_slots(next_slot_names)
-                        )
-                    else:
-                        debug.warning('Instance has no __next__ function in %s.', generator)
-                else:
-                    for lazy_context in generator.py__iter__():
-                        yield lazy_context
-        return iterate()
-
-    @abstractproperty
-    def name(self):
-        pass
-
-    def create_init_executions(self):
-        for name in self.get_function_slot_names(u'__init__'):
-            # TODO is this correct? I think we need to check for functions.
-            if isinstance(name, LazyInstanceClassName):
-                function = FunctionContext.from_context(
-                    self.parent_context,
-                    name.tree_name.parent
-                )
-                bound_method = BoundMethod(self, function)
-                yield bound_method.get_function_execution(self.var_args)
-
-    @evaluator_method_cache()
-    def create_instance_context(self, class_context, node):
-        if node.parent.type in ('funcdef', 'classdef'):
-            node = node.parent
-        scope = get_parent_scope(node)
-        if scope == class_context.tree_node:
-            return class_context
-        else:
-            parent_context = self.create_instance_context(class_context, scope)
-            if scope.type == 'funcdef':
-                func = FunctionContext.from_context(
-                    parent_context,
-                    scope,
-                )
-                bound_method = BoundMethod(self, func)
-                if scope.name.value == '__init__' and parent_context == class_context:
-                    return bound_method.get_function_execution(self.var_args)
-                else:
-                    return bound_method.get_function_execution()
-            elif scope.type == 'classdef':
-                class_context = ClassContext(self.evaluator, parent_context, scope)
-                return class_context
-            elif scope.type in ('comp_for', 'sync_comp_for'):
-                # Comprehensions currently don't have a special scope in Jedi.
-                return self.create_instance_context(class_context, scope)
-            else:
-                raise NotImplementedError
-        return class_context
-
-    def get_signatures(self):
-        call_funcs = self.py__getattribute__('__call__').py__get__(self, self.class_context)
-        return [s.bind(self) for s in call_funcs.get_signatures()]
-
-    def __repr__(self):
-        return "<%s of %s(%s)>" % (self.__class__.__name__, self.class_context,
-                                   self.var_args)
-
-
-class CompiledInstance(AbstractInstanceContext):
-    def __init__(self, evaluator, parent_context, class_context, var_args):
-        self._original_var_args = var_args
-        super(CompiledInstance, self).__init__(evaluator, parent_context, class_context, var_args)
-
-    @property
-    def name(self):
-        return compiled.CompiledContextName(self, self.class_context.name.string_name)
-
-    def get_first_non_keyword_argument_contexts(self):
-        key, lazy_context = next(self._original_var_args.unpack(), ('', None))
-        if key is not None:
-            return NO_CONTEXTS
-
-        return lazy_context.infer()
-
-    def is_stub(self):
-        return False
-
-
-class TreeInstance(AbstractInstanceContext):
-    def __init__(self, evaluator, parent_context, class_context, var_args):
-        # I don't think that dynamic append lookups should happen here. That
-        # sounds more like something that should go to py__iter__.
-        if class_context.py__name__() in ['list', 'set'] \
-                and parent_context.get_root_context() == evaluator.builtins_module:
-            # compare the module path with the builtin name.
-            if settings.dynamic_array_additions:
-                var_args = iterable.get_dynamic_array_instance(self, var_args)
-
-        super(TreeInstance, self).__init__(evaluator, parent_context,
-                                           class_context, var_args)
-        self.tree_node = class_context.tree_node
-
-    @property
-    def name(self):
-        return ContextName(self, self.class_context.name.tree_name)
-
-    # This can recurse, if the initialization of the class includes a reference
-    # to itself.
-    @evaluator_method_cache(default=None)
-    def _get_annotated_class_object(self):
-        from jedi.evaluate.gradual.annotation import py__annotations__, \
-            infer_type_vars_for_execution
-
-        for func in self._get_annotation_init_functions():
-            # Just take the first result, it should always be one, because we
-            # control the typeshed code.
-            bound = BoundMethod(self, func)
-            execution = bound.get_function_execution(self.var_args)
-            if not execution.matches_signature():
-                # First check if the signature even matches, if not we don't
-                # need to infer anything.
-                continue
-
-            all_annotations = py__annotations__(execution.tree_node)
-            defined, = self.class_context.define_generics(
-                infer_type_vars_for_execution(execution, all_annotations),
-            )
-            debug.dbg('Inferred instance context as %s', defined, color='BLUE')
-            return defined
-        return None
-
-    def get_annotated_class_object(self):
-        return self._get_annotated_class_object() or self.class_context
-
-    def _get_annotation_init_functions(self):
-        filter = next(self.class_context.get_filters())
-        for init_name in filter.get('__init__'):
-            for init in init_name.infer():
-                if init.is_function():
-                    for signature in init.get_signatures():
-                        yield signature.context
-
-
-class AnonymousInstance(TreeInstance):
-    def __init__(self, evaluator, parent_context, class_context):
-        super(AnonymousInstance, self).__init__(
-            evaluator,
-            parent_context,
-            class_context,
-            var_args=AnonymousInstanceArguments(self),
-        )
-
-    def get_annotated_class_object(self):
-        return self.class_context  # This is the default.
-
-
-class CompiledInstanceName(compiled.CompiledName):
-
-    def __init__(self, evaluator, instance, klass, name):
-        super(CompiledInstanceName, self).__init__(
-            evaluator,
-            klass.parent_context,
-            name.string_name
-        )
-        self._instance = instance
-        self._class_member_name = name
-
-    @iterator_to_context_set
-    def infer(self):
-        for result_context in self._class_member_name.infer():
-            if result_context.api_type == 'function':
-                yield CompiledBoundMethod(result_context)
-            else:
-                yield result_context
-
-
-class CompiledInstanceClassFilter(AbstractFilter):
-    name_class = CompiledInstanceName
-
-    def __init__(self, evaluator, instance, f):
-        self._evaluator = evaluator
-        self._instance = instance
-        self._class_filter = f
-
-    def get(self, name):
-        return self._convert(self._class_filter.get(name))
-
-    def values(self):
-        return self._convert(self._class_filter.values())
-
-    def _convert(self, names):
-        klass = self._class_filter.compiled_object
-        return [
-            CompiledInstanceName(self._evaluator, self._instance, klass, n)
-            for n in names
-        ]
-
-
-class BoundMethod(FunctionMixin, ContextWrapper):
-    def __init__(self, instance, function):
-        super(BoundMethod, self).__init__(function)
-        self.instance = instance
-
-    def is_bound_method(self):
-        return True
-
-    def py__class__(self):
-        c, = contexts_from_qualified_names(self.evaluator, u'types', u'MethodType')
-        return c
-
-    def _get_arguments(self, arguments):
-        if arguments is None:
-            arguments = AnonymousInstanceArguments(self.instance)
-
-        return InstanceArguments(self.instance, arguments)
-
-    def get_function_execution(self, arguments=None):
-        arguments = self._get_arguments(arguments)
-        return super(BoundMethod, self).get_function_execution(arguments)
-
-    def py__call__(self, arguments):
-        if isinstance(self._wrapped_context, OverloadedFunctionContext):
-            return self._wrapped_context.py__call__(self._get_arguments(arguments))
-
-        function_execution = self.get_function_execution(arguments)
-        return function_execution.infer()
-
-    def get_signature_functions(self):
-        return [
-            BoundMethod(self.instance, f)
-            for f in self._wrapped_context.get_signature_functions()
-        ]
-
-    def get_signatures(self):
-        return [sig.bind(self) for sig in super(BoundMethod, self).get_signatures()]
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self._wrapped_context)
-
-
-class CompiledBoundMethod(ContextWrapper):
-    def is_bound_method(self):
-        return True
-
-    def get_signatures(self):
-        return [sig.bind(self) for sig in self._wrapped_context.get_signatures()]
-
-
-class SelfName(TreeNameDefinition):
-    """
-    This name calculates the parent_context lazily.
-    """
-    def __init__(self, instance, class_context, tree_name):
-        self._instance = instance
-        self.class_context = class_context
-        self.tree_name = tree_name
-
-    @property
-    def parent_context(self):
-        return self._instance.create_instance_context(self.class_context, self.tree_name)
-
-
-class LazyInstanceClassName(object):
-    def __init__(self, instance, class_context, class_member_name):
-        self._instance = instance
-        self.class_context = class_context
-        self._class_member_name = class_member_name
-
-    @iterator_to_context_set
-    def infer(self):
-        for result_context in self._class_member_name.infer():
-            for c in apply_py__get__(result_context, self._instance, self.class_context):
-                yield c
-
-    def __getattr__(self, name):
-        return getattr(self._class_member_name, name)
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self._class_member_name)
-
-
-class InstanceClassFilter(AbstractFilter):
-    """
-    This filter is special in that it uses the class filter and wraps the
-    resulting names in LazyINstanceClassName. The idea is that the class name
-    filtering can be very flexible and always be reflected in instances.
-    """
-    def __init__(self, evaluator, instance, class_filter):
-        self._instance = instance
-        self._class_filter = class_filter
-
-    def get(self, name):
-        return self._convert(self._class_filter.get(name, from_instance=True))
-
-    def values(self):
-        return self._convert(self._class_filter.values(from_instance=True))
-
-    def _convert(self, names):
-        return [LazyInstanceClassName(self._instance, self._class_filter.context, n) for n in names]
-
-    def __repr__(self):
-        return '<%s for %s>' % (self.__class__.__name__, self._class_filter.context)
-
-
-class SelfAttributeFilter(ClassFilter):
-    """
-    This class basically filters all the use cases where `self.*` was assigned.
-    """
-    name_class = SelfName
-
-    def __init__(self, evaluator, context, class_context, origin_scope):
-        super(SelfAttributeFilter, self).__init__(
-            evaluator=evaluator,
-            context=context,
-            node_context=class_context,
-            origin_scope=origin_scope,
-            is_instance=True,
-        )
-        self._class_context = class_context
-
-    def _filter(self, names):
-        names = self._filter_self_names(names)
-        start, end = self._parser_scope.start_pos, self._parser_scope.end_pos
-        return [n for n in names if start < n.start_pos < end]
-
-    def _filter_self_names(self, names):
-        for name in names:
-            trailer = name.parent
-            if trailer.type == 'trailer' \
-                    and len(trailer.parent.children) == 2 \
-                    and trailer.children[0] == '.':
-                if name.is_definition() and self._access_possible(name, from_instance=True):
-                    # TODO filter non-self assignments.
-                    yield name
-
-    def _convert_names(self, names):
-        return [self.name_class(self.context, self._class_context, name) for name in names]
-
-    def _check_flows(self, names):
-        return names
-
-
-class InstanceArguments(TreeArgumentsWrapper):
-    def __init__(self, instance, arguments):
-        super(InstanceArguments, self).__init__(arguments)
-        self.instance = instance
-
-    def unpack(self, func=None):
-        yield None, LazyKnownContext(self.instance)
-        for values in self._wrapped_arguments.unpack(func):
-            yield values
-
-    def get_executed_params_and_issues(self, execution_context):
-        if isinstance(self._wrapped_arguments, AnonymousInstanceArguments):
-            return self._wrapped_arguments.get_executed_params_and_issues(execution_context)
-
-        return super(InstanceArguments, self).get_executed_params_and_issues(execution_context)

jedi/evaluate/context/iterable.py

@@ -1,821 +0,0 @@
-"""
-Contains all classes and functions to deal with lists, dicts, generators and
-iterators in general.
-
-Array modifications
-*******************
-
-If the content of an array (``set``/``list``) is requested somewhere, the
-current module will be checked for appearances of ``arr.append``,
-``arr.insert``, etc.  If the ``arr`` name points to an actual array, the
-content will be added
-
-This can be really cpu intensive, as you can imagine. Because |jedi| has to
-follow **every** ``append`` and check wheter it's the right array. However this
-works pretty good, because in *slow* cases, the recursion detector and other
-settings will stop this process.
-
-It is important to note that:
-
-1. Array modfications work only in the current module.
-2. Jedi only checks Array additions; ``list.pop``, etc are ignored.
-"""
-import sys
-
-from jedi import debug
-from jedi import settings
-from jedi._compatibility import force_unicode, is_py3
-from jedi.evaluate import compiled
-from jedi.evaluate import analysis
-from jedi.evaluate import recursion
-from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \
-    LazyTreeContext
-from jedi.evaluate.helpers import get_int_or_none, is_string, \
-    predefine_names, evaluate_call_of_leaf, reraise_getitem_errors, \
-    SimpleGetItemNotFound
-from jedi.evaluate.utils import safe_property, to_list
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.filters import ParserTreeFilter, LazyAttributeOverwrite, \
-    publish_method
-from jedi.evaluate.base_context import ContextSet, Context, NO_CONTEXTS, \
-    TreeContext, ContextualizedNode, iterate_contexts, HelperContextMixin, _sentinel
-from jedi.parser_utils import get_sync_comp_fors
-
-
-class IterableMixin(object):
-    def py__stop_iteration_returns(self):
-        return ContextSet([compiled.builtin_from_name(self.evaluator, u'None')])
-
-    # At the moment, safe values are simple values like "foo", 1 and not
-    # lists/dicts. Therefore as a small speed optimization we can just do the
-    # default instead of resolving the lazy wrapped contexts, that are just
-    # doing this in the end as well.
-    # This mostly speeds up patterns like `sys.version_info >= (3, 0)` in
-    # typeshed.
-    if sys.version_info[0] == 2:
-        # Python 2...........
-        def get_safe_value(self, default=_sentinel):
-            if default is _sentinel:
-                raise ValueError("There exists no safe value for context %s" % self)
-            return default
-    else:
-        get_safe_value = Context.get_safe_value
-
-
-class GeneratorBase(LazyAttributeOverwrite, IterableMixin):
-    array_type = None
-
-    def _get_wrapped_context(self):
-        generator, = self.evaluator.typing_module \
-            .py__getattribute__('Generator') \
-            .execute_annotation()
-        return generator
-
-    def is_instance(self):
-        return False
-
-    def py__bool__(self):
-        return True
-
-    @publish_method('__iter__')
-    def py__iter__(self, contextualized_node=None):
-        return ContextSet([self])
-
-    @publish_method('send')
-    @publish_method('next', python_version_match=2)
-    @publish_method('__next__', python_version_match=3)
-    def py__next__(self):
-        return ContextSet.from_sets(lazy_context.infer() for lazy_context in self.py__iter__())
-
-    def py__stop_iteration_returns(self):
-        return ContextSet([compiled.builtin_from_name(self.evaluator, u'None')])
-
-    @property
-    def name(self):
-        return compiled.CompiledContextName(self, 'Generator')
-
-
-class Generator(GeneratorBase):
-    """Handling of `yield` functions."""
-    def __init__(self, evaluator, func_execution_context):
-        super(Generator, self).__init__(evaluator)
-        self._func_execution_context = func_execution_context
-
-    def py__iter__(self, contextualized_node=None):
-        return self._func_execution_context.get_yield_lazy_contexts()
-
-    def py__stop_iteration_returns(self):
-        return self._func_execution_context.get_return_values()
-
-    def __repr__(self):
-        return "<%s of %s>" % (type(self).__name__, self._func_execution_context)
-
-
-class CompForContext(TreeContext):
-    @classmethod
-    def from_comp_for(cls, parent_context, comp_for):
-        return cls(parent_context.evaluator, parent_context, comp_for)
-
-    def get_filters(self, search_global=False, until_position=None, origin_scope=None):
-        yield ParserTreeFilter(self.evaluator, self)
-
-
-def comprehension_from_atom(evaluator, context, atom):
-    bracket = atom.children[0]
-    test_list_comp = atom.children[1]
-
-    if bracket == '{':
-        if atom.children[1].children[1] == ':':
-            sync_comp_for = test_list_comp.children[3]
-            if sync_comp_for.type == 'comp_for':
-                sync_comp_for = sync_comp_for.children[1]
-
-            return DictComprehension(
-                evaluator,
-                context,
-                sync_comp_for_node=sync_comp_for,
-                key_node=test_list_comp.children[0],
-                value_node=test_list_comp.children[2],
-            )
-        else:
-            cls = SetComprehension
-    elif bracket == '(':
-        cls = GeneratorComprehension
-    elif bracket == '[':
-        cls = ListComprehension
-
-    sync_comp_for = test_list_comp.children[1]
-    if sync_comp_for.type == 'comp_for':
-        sync_comp_for = sync_comp_for.children[1]
-
-    return cls(
-        evaluator,
-        defining_context=context,
-        sync_comp_for_node=sync_comp_for,
-        entry_node=test_list_comp.children[0],
-    )
-
-
-class ComprehensionMixin(object):
-    @evaluator_method_cache()
-    def _get_comp_for_context(self, parent_context, comp_for):
-        return CompForContext.from_comp_for(parent_context, comp_for)
-
-    def _nested(self, comp_fors, parent_context=None):
-        comp_for = comp_fors[0]
-
-        is_async = comp_for.parent.type == 'comp_for'
-
-        input_node = comp_for.children[3]
-        parent_context = parent_context or self._defining_context
-        input_types = parent_context.eval_node(input_node)
-        # TODO: simulate await if self.is_async
-
-        cn = ContextualizedNode(parent_context, input_node)
-        iterated = input_types.iterate(cn, is_async=is_async)
-        exprlist = comp_for.children[1]
-        for i, lazy_context in enumerate(iterated):
-            types = lazy_context.infer()
-            dct = unpack_tuple_to_dict(parent_context, types, exprlist)
-            context_ = self._get_comp_for_context(
-                parent_context,
-                comp_for,
-            )
-            with predefine_names(context_, comp_for, dct):
-                try:
-                    for result in self._nested(comp_fors[1:], context_):
-                        yield result
-                except IndexError:
-                    iterated = context_.eval_node(self._entry_node)
-                    if self.array_type == 'dict':
-                        yield iterated, context_.eval_node(self._value_node)
-                    else:
-                        yield iterated
-
-    @evaluator_method_cache(default=[])
-    @to_list
-    def _iterate(self):
-        comp_fors = tuple(get_sync_comp_fors(self._sync_comp_for_node))
-        for result in self._nested(comp_fors):
-            yield result
-
-    def py__iter__(self, contextualized_node=None):
-        for set_ in self._iterate():
-            yield LazyKnownContexts(set_)
-
-    def __repr__(self):
-        return "<%s of %s>" % (type(self).__name__, self._sync_comp_for_node)
-
-
-class _DictMixin(object):
-    def _get_generics(self):
-        return tuple(c_set.py__class__() for c_set in self.get_mapping_item_contexts())
-
-
-class Sequence(LazyAttributeOverwrite, IterableMixin):
-    api_type = u'instance'
-
-    @property
-    def name(self):
-        return compiled.CompiledContextName(self, self.array_type)
-
-    def _get_generics(self):
-        return (self.merge_types_of_iterate().py__class__(),)
-
-    def _get_wrapped_context(self):
-        from jedi.evaluate.gradual.typing import GenericClass
-        klass = compiled.builtin_from_name(self.evaluator, self.array_type)
-        c, = GenericClass(klass, self._get_generics()).execute_annotation()
-        return c
-
-    def py__bool__(self):
-        return None  # We don't know the length, because of appends.
-
-    def py__class__(self):
-        return compiled.builtin_from_name(self.evaluator, self.array_type)
-
-    @safe_property
-    def parent(self):
-        return self.evaluator.builtins_module
-
-    def py__getitem__(self, index_context_set, contextualized_node):
-        if self.array_type == 'dict':
-            return self._dict_values()
-        return iterate_contexts(ContextSet([self]))
-
-
-class _BaseComprehension(ComprehensionMixin):
-    def __init__(self, evaluator, defining_context, sync_comp_for_node, entry_node):
-        assert sync_comp_for_node.type == 'sync_comp_for'
-        super(_BaseComprehension, self).__init__(evaluator)
-        self._defining_context = defining_context
-        self._sync_comp_for_node = sync_comp_for_node
-        self._entry_node = entry_node
-
-
-class ListComprehension(_BaseComprehension, Sequence):
-    array_type = u'list'
-
-    def py__simple_getitem__(self, index):
-        if isinstance(index, slice):
-            return ContextSet([self])
-
-        all_types = list(self.py__iter__())
-        with reraise_getitem_errors(IndexError, TypeError):
-            lazy_context = all_types[index]
-        return lazy_context.infer()
-
-
-class SetComprehension(_BaseComprehension, Sequence):
-    array_type = u'set'
-
-
-class GeneratorComprehension(_BaseComprehension, GeneratorBase):
-    pass
-
-
-class DictComprehension(ComprehensionMixin, Sequence):
-    array_type = u'dict'
-
-    def __init__(self, evaluator, defining_context, sync_comp_for_node, key_node, value_node):
-        assert sync_comp_for_node.type == 'sync_comp_for'
-        super(DictComprehension, self).__init__(evaluator)
-        self._defining_context = defining_context
-        self._sync_comp_for_node = sync_comp_for_node
-        self._entry_node = key_node
-        self._value_node = value_node
-
-    def py__iter__(self, contextualized_node=None):
-        for keys, values in self._iterate():
-            yield LazyKnownContexts(keys)
-
-    def py__simple_getitem__(self, index):
-        for keys, values in self._iterate():
-            for k in keys:
-                if isinstance(k, compiled.CompiledObject):
-                    # Be careful in the future if refactoring, index could be a
-                    # slice.
-                    if k.get_safe_value(default=object()) == index:
-                        return values
-        raise SimpleGetItemNotFound()
-
-    def _dict_keys(self):
-        return ContextSet.from_sets(keys for keys, values in self._iterate())
-
-    def _dict_values(self):
-        return ContextSet.from_sets(values for keys, values in self._iterate())
-
-    @publish_method('values')
-    def _imitate_values(self):
-        lazy_context = LazyKnownContexts(self._dict_values())
-        return ContextSet([FakeSequence(self.evaluator, u'list', [lazy_context])])
-
-    @publish_method('items')
-    def _imitate_items(self):
-        lazy_contexts = [
-            LazyKnownContext(
-                FakeSequence(
-                    self.evaluator,
-                    u'tuple',
-                    [LazyKnownContexts(key),
-                     LazyKnownContexts(value)]
-                )
-            )
-            for key, value in self._iterate()
-        ]
-
-        return ContextSet([FakeSequence(self.evaluator, u'list', lazy_contexts)])
-
-    def get_mapping_item_contexts(self):
-        return self._dict_keys(), self._dict_values()
-
-    def exact_key_items(self):
-        # NOTE: A smarter thing can probably done here to achieve better
-        # completions, but at least like this jedi doesn't crash
-        return []
-
-
-class SequenceLiteralContext(Sequence):
-    _TUPLE_LIKE = 'testlist_star_expr', 'testlist', 'subscriptlist'
-    mapping = {'(': u'tuple',
-               '[': u'list',
-               '{': u'set'}
-
-    def __init__(self, evaluator, defining_context, atom):
-        super(SequenceLiteralContext, self).__init__(evaluator)
-        self.atom = atom
-        self._defining_context = defining_context
-
-        if self.atom.type in self._TUPLE_LIKE:
-            self.array_type = u'tuple'
-        else:
-            self.array_type = SequenceLiteralContext.mapping[atom.children[0]]
-            """The builtin name of the array (list, set, tuple or dict)."""
-
-    def py__simple_getitem__(self, index):
-        """Here the index is an int/str. Raises IndexError/KeyError."""
-        if self.array_type == u'dict':
-            compiled_obj_index = compiled.create_simple_object(self.evaluator, index)
-            for key, value in self.get_tree_entries():
-                for k in self._defining_context.eval_node(key):
-                    try:
-                        method = k.execute_operation
-                    except AttributeError:
-                        pass
-                    else:
-                        if method(compiled_obj_index, u'==').get_safe_value():
-                            return self._defining_context.eval_node(value)
-            raise SimpleGetItemNotFound('No key found in dictionary %s.' % self)
-
-        if isinstance(index, slice):
-            return ContextSet([self])
-        else:
-            with reraise_getitem_errors(TypeError, KeyError, IndexError):
-                node = self.get_tree_entries()[index]
-            return self._defining_context.eval_node(node)
-
-    def py__iter__(self, contextualized_node=None):
-        """
-        While values returns the possible values for any array field, this
-        function returns the value for a certain index.
-        """
-        if self.array_type == u'dict':
-            # Get keys.
-            types = NO_CONTEXTS
-            for k, _ in self.get_tree_entries():
-                types |= self._defining_context.eval_node(k)
-            # We don't know which dict index comes first, therefore always
-            # yield all the types.
-            for _ in types:
-                yield LazyKnownContexts(types)
-        else:
-            for node in self.get_tree_entries():
-                if node == ':' or node.type == 'subscript':
-                    # TODO this should probably use at least part of the code
-                    #      of eval_subscript_list.
-                    yield LazyKnownContext(Slice(self._defining_context, None, None, None))
-                else:
-                    yield LazyTreeContext(self._defining_context, node)
-            for addition in check_array_additions(self._defining_context, self):
-                yield addition
-
-    def py__len__(self):
-        # This function is not really used often. It's more of a try.
-        return len(self.get_tree_entries())
-
-    def _dict_values(self):
-        return ContextSet.from_sets(
-            self._defining_context.eval_node(v)
-            for k, v in self.get_tree_entries()
-        )
-
-    def get_tree_entries(self):
-        c = self.atom.children
-
-        if self.atom.type in self._TUPLE_LIKE:
-            return c[::2]
-
-        array_node = c[1]
-        if array_node in (']', '}', ')'):
-            return []  # Direct closing bracket, doesn't contain items.
-
-        if array_node.type == 'testlist_comp':
-            # filter out (for now) pep 448 single-star unpacking
-            return [value for value in array_node.children[::2]
-                    if value.type != "star_expr"]
-        elif array_node.type == 'dictorsetmaker':
-            kv = []
-            iterator = iter(array_node.children)
-            for key in iterator:
-                if key == "**":
-                    # dict with pep 448 double-star unpacking
-                    # for now ignoring the values imported by **
-                    next(iterator)
-                    next(iterator, None)  # Possible comma.
-                else:
-                    op = next(iterator, None)
-                    if op is None or op == ',':
-                        if key.type == "star_expr":
-                            # pep 448 single-star unpacking
-                            # for now ignoring values imported by *
-                            pass
-                        else:
-                            kv.append(key)  # A set.
-                    else:
-                        assert op == ':'  # A dict.
-                        kv.append((key, next(iterator)))
-                        next(iterator, None)  # Possible comma.
-            return kv
-        else:
-            if array_node.type == "star_expr":
-                # pep 448 single-star unpacking
-                # for now ignoring values imported by *
-                return []
-            else:
-                return [array_node]
-
-    def exact_key_items(self):
-        """
-        Returns a generator of tuples like dict.items(), where the key is
-        resolved (as a string) and the values are still lazy contexts.
-        """
-        for key_node, value in self.get_tree_entries():
-            for key in self._defining_context.eval_node(key_node):
-                if is_string(key):
-                    yield key.get_safe_value(), LazyTreeContext(self._defining_context, value)
-
-    def __repr__(self):
-        return "<%s of %s>" % (self.__class__.__name__, self.atom)
-
-
-class DictLiteralContext(_DictMixin, SequenceLiteralContext):
-    array_type = u'dict'
-
-    def __init__(self, evaluator, defining_context, atom):
-        super(SequenceLiteralContext, self).__init__(evaluator)
-        self._defining_context = defining_context
-        self.atom = atom
-
-    @publish_method('values')
-    def _imitate_values(self):
-        lazy_context = LazyKnownContexts(self._dict_values())
-        return ContextSet([FakeSequence(self.evaluator, u'list', [lazy_context])])
-
-    @publish_method('items')
-    def _imitate_items(self):
-        lazy_contexts = [
-            LazyKnownContext(FakeSequence(
-                self.evaluator, u'tuple',
-                (LazyTreeContext(self._defining_context, key_node),
-                 LazyTreeContext(self._defining_context, value_node))
-            )) for key_node, value_node in self.get_tree_entries()
-        ]
-
-        return ContextSet([FakeSequence(self.evaluator, u'list', lazy_contexts)])
-
-    def _dict_keys(self):
-        return ContextSet.from_sets(
-            self._defining_context.eval_node(k)
-            for k, v in self.get_tree_entries()
-        )
-
-    def get_mapping_item_contexts(self):
-        return self._dict_keys(), self._dict_values()
-
-
-class _FakeArray(SequenceLiteralContext):
-    def __init__(self, evaluator, container, type):
-        super(SequenceLiteralContext, self).__init__(evaluator)
-        self.array_type = type
-        self.atom = container
-        # TODO is this class really needed?
-
-
-class FakeSequence(_FakeArray):
-    def __init__(self, evaluator, array_type, lazy_context_list):
-        """
-        type should be one of "tuple", "list"
-        """
-        super(FakeSequence, self).__init__(evaluator, None, array_type)
-        self._lazy_context_list = lazy_context_list
-
-    def py__simple_getitem__(self, index):
-        if isinstance(index, slice):
-            return ContextSet([self])
-
-        with reraise_getitem_errors(IndexError, TypeError):
-            lazy_context = self._lazy_context_list[index]
-        return lazy_context.infer()
-
-    def py__iter__(self, contextualized_node=None):
-        return self._lazy_context_list
-
-    def py__bool__(self):
-        return bool(len(self._lazy_context_list))
-
-    def __repr__(self):
-        return "<%s of %s>" % (type(self).__name__, self._lazy_context_list)
-
-
-class FakeDict(_DictMixin, _FakeArray):
-    def __init__(self, evaluator, dct):
-        super(FakeDict, self).__init__(evaluator, dct, u'dict')
-        self._dct = dct
-
-    def py__iter__(self, contextualized_node=None):
-        for key in self._dct:
-            yield LazyKnownContext(compiled.create_simple_object(self.evaluator, key))
-
-    def py__simple_getitem__(self, index):
-        if is_py3 and self.evaluator.environment.version_info.major == 2:
-            # In Python 2 bytes and unicode compare.
-            if isinstance(index, bytes):
-                index_unicode = force_unicode(index)
-                try:
-                    return self._dct[index_unicode].infer()
-                except KeyError:
-                    pass
-            elif isinstance(index, str):
-                index_bytes = index.encode('utf-8')
-                try:
-                    return self._dct[index_bytes].infer()
-                except KeyError:
-                    pass
-
-        with reraise_getitem_errors(KeyError, TypeError):
-            lazy_context = self._dct[index]
-        return lazy_context.infer()
-
-    @publish_method('values')
-    def _values(self):
-        return ContextSet([FakeSequence(
-            self.evaluator, u'tuple',
-            [LazyKnownContexts(self._dict_values())]
-        )])
-
-    def _dict_values(self):
-        return ContextSet.from_sets(lazy_context.infer() for lazy_context in self._dct.values())
-
-    def _dict_keys(self):
-        return ContextSet.from_sets(lazy_context.infer() for lazy_context in self.py__iter__())
-
-    def get_mapping_item_contexts(self):
-        return self._dict_keys(), self._dict_values()
-
-    def exact_key_items(self):
-        return self._dct.items()
-
-
-class MergedArray(_FakeArray):
-    def __init__(self, evaluator, arrays):
-        super(MergedArray, self).__init__(evaluator, arrays, arrays[-1].array_type)
-        self._arrays = arrays
-
-    def py__iter__(self, contextualized_node=None):
-        for array in self._arrays:
-            for lazy_context in array.py__iter__():
-                yield lazy_context
-
-    def py__simple_getitem__(self, index):
-        return ContextSet.from_sets(lazy_context.infer() for lazy_context in self.py__iter__())
-
-    def get_tree_entries(self):
-        for array in self._arrays:
-            for a in array.get_tree_entries():
-                yield a
-
-    def __len__(self):
-        return sum(len(a) for a in self._arrays)
-
-
-def unpack_tuple_to_dict(context, types, exprlist):
-    """
-    Unpacking tuple assignments in for statements and expr_stmts.
-    """
-    if exprlist.type == 'name':
-        return {exprlist.value: types}
-    elif exprlist.type == 'atom' and exprlist.children[0] in ('(', '['):
-        return unpack_tuple_to_dict(context, types, exprlist.children[1])
-    elif exprlist.type in ('testlist', 'testlist_comp', 'exprlist',
-                           'testlist_star_expr'):
-        dct = {}
-        parts = iter(exprlist.children[::2])
-        n = 0
-        for lazy_context in types.iterate(exprlist):
-            n += 1
-            try:
-                part = next(parts)
-            except StopIteration:
-                # TODO this context is probably not right.
-                analysis.add(context, 'value-error-too-many-values', part,
-                             message="ValueError: too many values to unpack (expected %s)" % n)
-            else:
-                dct.update(unpack_tuple_to_dict(context, lazy_context.infer(), part))
-        has_parts = next(parts, None)
-        if types and has_parts is not None:
-            # TODO this context is probably not right.
-            analysis.add(context, 'value-error-too-few-values', has_parts,
-                         message="ValueError: need more than %s values to unpack" % n)
-        return dct
-    elif exprlist.type == 'power' or exprlist.type == 'atom_expr':
-        # Something like ``arr[x], var = ...``.
-        # This is something that is not yet supported, would also be difficult
-        # to write into a dict.
-        return {}
-    elif exprlist.type == 'star_expr':  # `a, *b, c = x` type unpackings
-        # Currently we're not supporting them.
-        return {}
-    raise NotImplementedError
-
-
-def check_array_additions(context, sequence):
-    """ Just a mapper function for the internal _check_array_additions """
-    if sequence.array_type not in ('list', 'set'):
-        # TODO also check for dict updates
-        return NO_CONTEXTS
-
-    return _check_array_additions(context, sequence)
-
-
-@evaluator_method_cache(default=NO_CONTEXTS)
-@debug.increase_indent
-def _check_array_additions(context, sequence):
-    """
-    Checks if a `Array` has "add" (append, insert, extend) statements:
-
-    >>> a = [""]
-    >>> a.append(1)
-    """
-    from jedi.evaluate import arguments
-
-    debug.dbg('Dynamic array search for %s' % sequence, color='MAGENTA')
-    module_context = context.get_root_context()
-    if not settings.dynamic_array_additions or isinstance(module_context, compiled.CompiledObject):
-        debug.dbg('Dynamic array search aborted.', color='MAGENTA')
-        return NO_CONTEXTS
-
-    def find_additions(context, arglist, add_name):
-        params = list(arguments.TreeArguments(context.evaluator, context, arglist).unpack())
-        result = set()
-        if add_name in ['insert']:
-            params = params[1:]
-        if add_name in ['append', 'add', 'insert']:
-            for key, lazy_context in params:
-                result.add(lazy_context)
-        elif add_name in ['extend', 'update']:
-            for key, lazy_context in params:
-                result |= set(lazy_context.infer().iterate())
-        return result
-
-    temp_param_add, settings.dynamic_params_for_other_modules = \
-        settings.dynamic_params_for_other_modules, False
-
-    is_list = sequence.name.string_name == 'list'
-    search_names = (['append', 'extend', 'insert'] if is_list else ['add', 'update'])
-
-    added_types = set()
-    for add_name in search_names:
-        try:
-            possible_names = module_context.tree_node.get_used_names()[add_name]
-        except KeyError:
-            continue
-        else:
-            for name in possible_names:
-                context_node = context.tree_node
-                if not (context_node.start_pos < name.start_pos < context_node.end_pos):
-                    continue
-                trailer = name.parent
-                power = trailer.parent
-                trailer_pos = power.children.index(trailer)
-                try:
-                    execution_trailer = power.children[trailer_pos + 1]
-                except IndexError:
-                    continue
-                else:
-                    if execution_trailer.type != 'trailer' \
-                            or execution_trailer.children[0] != '(' \
-                            or execution_trailer.children[1] == ')':
-                        continue
-
-                random_context = context.create_context(name)
-
-                with recursion.execution_allowed(context.evaluator, power) as allowed:
-                    if allowed:
-                        found = evaluate_call_of_leaf(
-                            random_context,
-                            name,
-                            cut_own_trailer=True
-                        )
-                        if sequence in found:
-                            # The arrays match. Now add the results
-                            added_types |= find_additions(
-                                random_context,
-                                execution_trailer.children[1],
-                                add_name
-                            )
-
-    # reset settings
-    settings.dynamic_params_for_other_modules = temp_param_add
-    debug.dbg('Dynamic array result %s' % added_types, color='MAGENTA')
-    return added_types
-
-
-def get_dynamic_array_instance(instance, arguments):
-    """Used for set() and list() instances."""
-    ai = _ArrayInstance(instance, arguments)
-    from jedi.evaluate import arguments
-    return arguments.ValuesArguments([ContextSet([ai])])
-
-
-class _ArrayInstance(HelperContextMixin):
-    """
-    Used for the usage of set() and list().
-    This is definitely a hack, but a good one :-)
-    It makes it possible to use set/list conversions.
-    """
-    def __init__(self, instance, var_args):
-        self.instance = instance
-        self.var_args = var_args
-
-    def py__class__(self):
-        tuple_, = self.instance.evaluator.builtins_module.py__getattribute__('tuple')
-        return tuple_
-
-    def py__iter__(self, contextualized_node=None):
-        var_args = self.var_args
-        try:
-            _, lazy_context = next(var_args.unpack())
-        except StopIteration:
-            pass
-        else:
-            for lazy in lazy_context.infer().iterate():
-                yield lazy
-
-        from jedi.evaluate import arguments
-        if isinstance(var_args, arguments.TreeArguments):
-            additions = _check_array_additions(var_args.context, self.instance)
-            for addition in additions:
-                yield addition
-
-    def iterate(self, contextualized_node=None, is_async=False):
-        return self.py__iter__(contextualized_node)
-
-
-class Slice(object):
-    def __init__(self, context, start, stop, step):
-        self._context = context
-        self._slice_object = None
-        # All of them are either a Precedence or None.
-        self._start = start
-        self._stop = stop
-        self._step = step
-
-    def __getattr__(self, name):
-        if self._slice_object is None:
-            context = compiled.builtin_from_name(self._context.evaluator, 'slice')
-            self._slice_object, = context.execute_evaluated()
-        return getattr(self._slice_object, name)
-
-    @property
-    def obj(self):
-        """
-        Imitate CompiledObject.obj behavior and return a ``builtin.slice()``
-        object.
-        """
-        def get(element):
-            if element is None:
-                return None
-
-            result = self._context.eval_node(element)
-            if len(result) != 1:
-                # For simplicity, we want slices to be clear defined with just
-                # one type.  Otherwise we will return an empty slice object.
-                raise IndexError
-
-            context, = result
-            return get_int_or_none(context)
-
-        try:
-            return slice(get(self._start), get(self._stop), get(self._step))
-        except IndexError:
-            return slice(None, None, None)

jedi/evaluate/context/klass.py

@@ -1,344 +0,0 @@
-"""
-Like described in the :mod:`parso.python.tree` module,
-there's a need for an ast like module to represent the states of parsed
-modules.
-
-But now there are also structures in Python that need a little bit more than
-that. An ``Instance`` for example is only a ``Class`` before it is
-instantiated. This class represents these cases.
-
-So, why is there also a ``Class`` class here? Well, there are decorators and
-they change classes in Python 3.
-
-Representation modules also define "magic methods". Those methods look like
-``py__foo__`` and are typically mappable to the Python equivalents ``__call__``
-and others. Here's a list:
-
-====================================== ========================================
-**Method**                             **Description**
--------------------------------------- ----------------------------------------
-py__call__(arguments: Array)           On callable objects, returns types.
-py__bool__()                           Returns True/False/None; None means that
-                                       there's no certainty.
-py__bases__()                          Returns a list of base classes.
-py__iter__()                           Returns a generator of a set of types.
-py__class__()                          Returns the class of an instance.
-py__simple_getitem__(index: int/str)   Returns a a set of types of the index.
-                                       Can raise an IndexError/KeyError.
-py__getitem__(indexes: ContextSet)     Returns a a set of types of the index.
-py__file__()                           Only on modules. Returns None if does
-                                       not exist.
-py__package__() -> List[str]           Only on modules. For the import system.
-py__path__()                           Only on modules. For the import system.
-py__get__(call_object)                 Only on instances. Simulates
-                                       descriptors.
-py__doc__()                            Returns the docstring for a context.
-====================================== ========================================
-
-"""
-from jedi import debug
-from jedi._compatibility import use_metaclass
-from jedi.parser_utils import get_cached_parent_scope
-from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass, \
-    evaluator_method_generator_cache
-from jedi.evaluate import compiled
-from jedi.evaluate.lazy_context import LazyKnownContexts
-from jedi.evaluate.filters import ParserTreeFilter
-from jedi.evaluate.names import TreeNameDefinition, ContextName
-from jedi.evaluate.arguments import unpack_arglist, ValuesArguments
-from jedi.evaluate.base_context import ContextSet, iterator_to_context_set, \
-    NO_CONTEXTS
-from jedi.evaluate.context.function import FunctionAndClassBase
-from jedi.plugins import plugin_manager
-
-
-def apply_py__get__(context, instance, class_context):
-    try:
-        method = context.py__get__
-    except AttributeError:
-        yield context
-    else:
-        for descriptor_context in method(instance, class_context):
-            yield descriptor_context
-
-
-class ClassName(TreeNameDefinition):
-    def __init__(self, parent_context, tree_name, name_context, apply_decorators):
-        super(ClassName, self).__init__(parent_context, tree_name)
-        self._name_context = name_context
-        self._apply_decorators = apply_decorators
-
-    @iterator_to_context_set
-    def infer(self):
-        # We're using a different context to infer, so we cannot call super().
-        from jedi.evaluate.syntax_tree import tree_name_to_contexts
-        inferred = tree_name_to_contexts(
-            self.parent_context.evaluator, self._name_context, self.tree_name)
-
-        for result_context in inferred:
-            if self._apply_decorators:
-                for c in apply_py__get__(result_context,
-                                         instance=None,
-                                         class_context=self.parent_context):
-                    yield c
-            else:
-                yield result_context
-
-
-class ClassFilter(ParserTreeFilter):
-    name_class = ClassName
-
-    def __init__(self, *args, **kwargs):
-        self._is_instance = kwargs.pop('is_instance')  # Python 2 :/
-        super(ClassFilter, self).__init__(*args, **kwargs)
-
-    def _convert_names(self, names):
-        return [
-            self.name_class(
-                parent_context=self.context,
-                tree_name=name,
-                name_context=self._node_context,
-                apply_decorators=not self._is_instance,
-            ) for name in names
-        ]
-
-    def _equals_origin_scope(self):
-        node = self._origin_scope
-        while node is not None:
-            if node == self._parser_scope or node == self.context:
-                return True
-            node = get_cached_parent_scope(self._used_names, node)
-        return False
-
-    def _access_possible(self, name, from_instance=False):
-        # Filter for ClassVar variables
-        # TODO this is not properly done, yet. It just checks for the string
-        # ClassVar in the annotation, which can be quite imprecise. If we
-        # wanted to do this correct, we would have to resolve the ClassVar.
-        if not from_instance:
-            expr_stmt = name.get_definition()
-            if expr_stmt is not None and expr_stmt.type == 'expr_stmt':
-                annassign = expr_stmt.children[1]
-                if annassign.type == 'annassign':
-                    # TODO this is not proper matching
-                    if 'ClassVar' not in annassign.children[1].get_code():
-                        return False
-
-        # Filter for name mangling of private variables like __foo
-        return not name.value.startswith('__') or name.value.endswith('__') \
-            or self._equals_origin_scope()
-
-    def _filter(self, names, from_instance=False):
-        names = super(ClassFilter, self)._filter(names)
-        return [name for name in names if self._access_possible(name, from_instance)]
-
-
-class ClassMixin(object):
-    def is_class(self):
-        return True
-
-    def py__call__(self, arguments=None):
-        from jedi.evaluate.context import TreeInstance
-        if arguments is None:
-            arguments = ValuesArguments([])
-        return ContextSet([TreeInstance(self.evaluator, self.parent_context, self, arguments)])
-
-    def py__class__(self):
-        return compiled.builtin_from_name(self.evaluator, u'type')
-
-    @property
-    def name(self):
-        return ContextName(self, self.tree_node.name)
-
-    def py__name__(self):
-        return self.name.string_name
-
-    def get_param_names(self):
-        for context_ in self.py__getattribute__(u'__init__'):
-            if context_.is_function():
-                return list(context_.get_param_names())[1:]
-        return []
-
-    @evaluator_method_generator_cache()
-    def py__mro__(self):
-        mro = [self]
-        yield self
-        # TODO Do a proper mro resolution. Currently we are just listing
-        # classes. However, it's a complicated algorithm.
-        for lazy_cls in self.py__bases__():
-            # TODO there's multiple different mro paths possible if this yields
-            # multiple possibilities. Could be changed to be more correct.
-            for cls in lazy_cls.infer():
-                # TODO detect for TypeError: duplicate base class str,
-                # e.g.  `class X(str, str): pass`
-                try:
-                    mro_method = cls.py__mro__
-                except AttributeError:
-                    # TODO add a TypeError like:
-                    """
-                    >>> class Y(lambda: test): pass
-                    Traceback (most recent call last):
-                      File "<stdin>", line 1, in <module>
-                    TypeError: function() argument 1 must be code, not str
-                    >>> class Y(1): pass
-                    Traceback (most recent call last):
-                      File "<stdin>", line 1, in <module>
-                    TypeError: int() takes at most 2 arguments (3 given)
-                    """
-                    debug.warning('Super class of %s is not a class: %s', self, cls)
-                else:
-                    for cls_new in mro_method():
-                        if cls_new not in mro:
-                            mro.append(cls_new)
-                            yield cls_new
-
-    def get_filters(self, search_global=False, until_position=None,
-                    origin_scope=None, is_instance=False):
-        metaclasses = self.get_metaclasses()
-        if metaclasses:
-            for f in self.get_metaclass_filters(metaclasses):
-                yield f
-
-        if search_global:
-            yield self.get_global_filter(until_position, origin_scope)
-        else:
-            for cls in self.py__mro__():
-                if isinstance(cls, compiled.CompiledObject):
-                    for filter in cls.get_filters(is_instance=is_instance):
-                        yield filter
-                else:
-                    yield ClassFilter(
-                        self.evaluator, self, node_context=cls,
-                        origin_scope=origin_scope,
-                        is_instance=is_instance
-                    )
-        if not is_instance:
-            from jedi.evaluate.compiled import builtin_from_name
-            type_ = builtin_from_name(self.evaluator, u'type')
-            assert isinstance(type_, ClassContext)
-            if type_ != self:
-                for instance in type_.py__call__():
-                    instance_filters = instance.get_filters()
-                    # Filter out self filters
-                    next(instance_filters)
-                    next(instance_filters)
-                    yield next(instance_filters)
-
-    def get_signatures(self):
-        init_funcs = self.py__call__().py__getattribute__('__init__')
-        return [sig.bind(self) for sig in init_funcs.get_signatures()]
-
-    def get_global_filter(self, until_position=None, origin_scope=None):
-        return ParserTreeFilter(
-            self.evaluator,
-            context=self,
-            until_position=until_position,
-            origin_scope=origin_scope
-        )
-
-
-class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase)):
-    """
-    This class is not only important to extend `tree.Class`, it is also a
-    important for descriptors (if the descriptor methods are evaluated or not).
-    """
-    api_type = u'class'
-
-    @evaluator_method_cache()
-    def list_type_vars(self):
-        found = []
-        arglist = self.tree_node.get_super_arglist()
-        if arglist is None:
-            return []
-
-        for stars, node in unpack_arglist(arglist):
-            if stars:
-                continue  # These are not relevant for this search.
-
-            from jedi.evaluate.gradual.annotation import find_unknown_type_vars
-            for type_var in find_unknown_type_vars(self.parent_context, node):
-                if type_var not in found:
-                    # The order matters and it's therefore a list.
-                    found.append(type_var)
-        return found
-
-    def _get_bases_arguments(self):
-        arglist = self.tree_node.get_super_arglist()
-        if arglist:
-            from jedi.evaluate import arguments
-            return arguments.TreeArguments(self.evaluator, self.parent_context, arglist)
-        return None
-
-    @evaluator_method_cache(default=())
-    def py__bases__(self):
-        args = self._get_bases_arguments()
-        if args is not None:
-            lst = [value for key, value in args.unpack() if key is None]
-            if lst:
-                return lst
-
-        if self.py__name__() == 'object' \
-                and self.parent_context == self.evaluator.builtins_module:
-            return []
-        return [LazyKnownContexts(
-            self.evaluator.builtins_module.py__getattribute__('object')
-        )]
-
-    def py__getitem__(self, index_context_set, contextualized_node):
-        from jedi.evaluate.gradual.typing import LazyGenericClass
-        if not index_context_set:
-            return ContextSet([self])
-        return ContextSet(
-            LazyGenericClass(
-                self,
-                index_context,
-                context_of_index=contextualized_node.context,
-            )
-            for index_context in index_context_set
-        )
-
-    def define_generics(self, type_var_dict):
-        from jedi.evaluate.gradual.typing import GenericClass
-
-        def remap_type_vars():
-            """
-            The TypeVars in the resulting classes have sometimes different names
-            and we need to check for that, e.g. a signature can be:
-
-            def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
-
-            However, the iterator is defined as Iterator[_T_co], which means it has
-            a different type var name.
-            """
-            for type_var in self.list_type_vars():
-                yield type_var_dict.get(type_var.py__name__(), NO_CONTEXTS)
-
-        if type_var_dict:
-            return ContextSet([GenericClass(
-                self,
-                generics=tuple(remap_type_vars())
-            )])
-        return ContextSet({self})
-
-    @plugin_manager.decorate()
-    def get_metaclass_filters(self, metaclass):
-        debug.dbg('Unprocessed metaclass %s', metaclass)
-        return []
-
-    @evaluator_method_cache(default=NO_CONTEXTS)
-    def get_metaclasses(self):
-        args = self._get_bases_arguments()
-        if args is not None:
-            m = [value for key, value in args.unpack() if key == 'metaclass']
-            metaclasses = ContextSet.from_sets(lazy_context.infer() for lazy_context in m)
-            metaclasses = ContextSet(m for m in metaclasses if m.is_class())
-            if metaclasses:
-                return metaclasses
-
-        for lazy_base in self.py__bases__():
-            for context in lazy_base.infer():
-                if context.is_class():
-                    contexts = context.get_metaclasses()
-                    if contexts:
-                        return contexts
-        return NO_CONTEXTS

jedi/evaluate/context/module.py

@@ -1,283 +0,0 @@
-import re
-import os
-
-from jedi import debug
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.names import ContextNameMixin, AbstractNameDefinition
-from jedi.evaluate.filters import GlobalNameFilter, ParserTreeFilter, DictFilter, MergedFilter
-from jedi.evaluate import compiled
-from jedi.evaluate.base_context import TreeContext
-from jedi.evaluate.names import SubModuleName
-from jedi.evaluate.helpers import contexts_from_qualified_names
-from jedi.evaluate.compiled import create_simple_object
-from jedi.evaluate.base_context import ContextSet
-
-
-class _ModuleAttributeName(AbstractNameDefinition):
-    """
-    For module attributes like __file__, __str__ and so on.
-    """
-    api_type = u'instance'
-
-    def __init__(self, parent_module, string_name, string_value=None):
-        self.parent_context = parent_module
-        self.string_name = string_name
-        self._string_value = string_value
-
-    def infer(self):
-        if self._string_value is not None:
-            s = self._string_value
-            if self.parent_context.evaluator.environment.version_info.major == 2 \
-                    and not isinstance(s, bytes):
-                s = s.encode('utf-8')
-            return ContextSet([
-                create_simple_object(self.parent_context.evaluator, s)
-            ])
-        return compiled.get_string_context_set(self.parent_context.evaluator)
-
-
-class ModuleName(ContextNameMixin, AbstractNameDefinition):
-    start_pos = 1, 0
-
-    def __init__(self, context, name):
-        self._context = context
-        self._name = name
-
-    @property
-    def string_name(self):
-        return self._name
-
-
-def iter_module_names(evaluator, paths):
-    # Python modules/packages
-    for n in evaluator.compiled_subprocess.list_module_names(paths):
-        yield n
-
-    for path in paths:
-        try:
-            dirs = os.listdir(path)
-        except OSError:
-            # The file might not exist or reading it might lead to an error.
-            debug.warning("Not possible to list directory: %s", path)
-            continue
-        for name in dirs:
-            # Namespaces
-            if os.path.isdir(os.path.join(path, name)):
-                # pycache is obviously not an interestin namespace. Also the
-                # name must be a valid identifier.
-                # TODO use str.isidentifier, once Python 2 is removed
-                if name != '__pycache__' and not re.search(r'\W|^\d', name):
-                    yield name
-            # Stub files
-            if name.endswith('.pyi'):
-                if name != '__init__.pyi':
-                    yield name[:-4]
-
-
-class SubModuleDictMixin(object):
-    @evaluator_method_cache()
-    def sub_modules_dict(self):
-        """
-        Lists modules in the directory of this module (if this module is a
-        package).
-        """
-        names = {}
-        try:
-            method = self.py__path__
-        except AttributeError:
-            pass
-        else:
-            mods = iter_module_names(self.evaluator, method())
-            for name in mods:
-                # It's obviously a relative import to the current module.
-                names[name] = SubModuleName(self, name)
-
-        # In the case of an import like `from x.` we don't need to
-        # add all the variables, this is only about submodules.
-        return names
-
-
-class ModuleMixin(SubModuleDictMixin):
-    def get_filters(self, search_global=False, until_position=None, origin_scope=None):
-        yield MergedFilter(
-            ParserTreeFilter(
-                self.evaluator,
-                context=self,
-                until_position=until_position,
-                origin_scope=origin_scope
-            ),
-            GlobalNameFilter(self, self.tree_node),
-        )
-        yield DictFilter(self.sub_modules_dict())
-        yield DictFilter(self._module_attributes_dict())
-        for star_filter in self.iter_star_filters():
-            yield star_filter
-
-    def py__class__(self):
-        c, = contexts_from_qualified_names(self.evaluator, u'types', u'ModuleType')
-        return c
-
-    def is_module(self):
-        return True
-
-    def is_stub(self):
-        return False
-
-    @property
-    @evaluator_method_cache()
-    def name(self):
-        return ModuleName(self, self._string_name)
-
-    @property
-    def _string_name(self):
-        """ This is used for the goto functions. """
-        # TODO It's ugly that we even use this, the name is usually well known
-        # ahead so just pass it when create a ModuleContext.
-        if self._path is None:
-            return ''  # no path -> empty name
-        else:
-            sep = (re.escape(os.path.sep),) * 2
-            r = re.search(r'([^%s]*?)(%s__init__)?(\.pyi?|\.so)?$' % sep, self._path)
-            # Remove PEP 3149 names
-            return re.sub(r'\.[a-z]+-\d{2}[mud]{0,3}$', '', r.group(1))
-
-    @evaluator_method_cache()
-    def _module_attributes_dict(self):
-        names = ['__package__', '__doc__', '__name__']
-        # All the additional module attributes are strings.
-        dct = dict((n, _ModuleAttributeName(self, n)) for n in names)
-        file = self.py__file__()
-        if file is not None:
-            dct['__file__'] = _ModuleAttributeName(self, '__file__', file)
-        return dct
-
-    def iter_star_filters(self, search_global=False):
-        for star_module in self.star_imports():
-            yield next(star_module.get_filters(search_global))
-
-    # I'm not sure if the star import cache is really that effective anymore
-    # with all the other really fast import caches. Recheck. Also we would need
-    # to push the star imports into Evaluator.module_cache, if we reenable this.
-    @evaluator_method_cache([])
-    def star_imports(self):
-        from jedi.evaluate.imports import Importer
-
-        modules = []
-        for i in self.tree_node.iter_imports():
-            if i.is_star_import():
-                new = Importer(
-                    self.evaluator,
-                    import_path=i.get_paths()[-1],
-                    module_context=self,
-                    level=i.level
-                ).follow()
-
-                for module in new:
-                    if isinstance(module, ModuleContext):
-                        modules += module.star_imports()
-                modules += new
-        return modules
-
-    def get_qualified_names(self):
-        """
-        A module doesn't have a qualified name, but it's important to note that
-        it's reachable and not `None`. With this information we can add
-        qualified names on top for all context children.
-        """
-        return ()
-
-
-class ModuleContext(ModuleMixin, TreeContext):
-    api_type = u'module'
-    parent_context = None
-
-    def __init__(self, evaluator, module_node, file_io, string_names, code_lines, is_package=False):
-        super(ModuleContext, self).__init__(
-            evaluator,
-            parent_context=None,
-            tree_node=module_node
-        )
-        self.file_io = file_io
-        if file_io is None:
-            self._path = None
-        else:
-            self._path = file_io.path
-        self.string_names = string_names  # Optional[Tuple[str, ...]]
-        self.code_lines = code_lines
-        self.is_package = is_package
-
-    def is_stub(self):
-        if self._path is not None and self._path.endswith('.pyi'):
-            # Currently this is the way how we identify stubs when e.g. goto is
-            # used in them. This could be changed if stubs would be identified
-            # sooner and used as StubModuleContext.
-            return True
-        return super(ModuleContext, self).is_stub()
-
-    def py__name__(self):
-        if self.string_names is None:
-            return None
-        return '.'.join(self.string_names)
-
-    def py__file__(self):
-        """
-        In contrast to Python's __file__ can be None.
-        """
-        if self._path is None:
-            return None
-
-        return os.path.abspath(self._path)
-
-    def py__package__(self):
-        if self.is_package:
-            return self.string_names
-        return self.string_names[:-1]
-
-    def _py__path__(self):
-        # A namespace package is typically auto generated and ~10 lines long.
-        first_few_lines = ''.join(self.code_lines[:50])
-        # these are strings that need to be used for namespace packages,
-        # the first one is ``pkgutil``, the second ``pkg_resources``.
-        options = ('declare_namespace(__name__)', 'extend_path(__path__')
-        if options[0] in first_few_lines or options[1] in first_few_lines:
-            # It is a namespace, now try to find the rest of the
-            # modules on sys_path or whatever the search_path is.
-            paths = set()
-            for s in self.evaluator.get_sys_path():
-                other = os.path.join(s, self.name.string_name)
-                if os.path.isdir(other):
-                    paths.add(other)
-            if paths:
-                return list(paths)
-            # Nested namespace packages will not be supported. Nobody ever
-            # asked for it and in Python 3 they are there without using all the
-            # crap above.
-
-        # Default to the of this file.
-        file = self.py__file__()
-        assert file is not None  # Shouldn't be a package in the first place.
-        return [os.path.dirname(file)]
-
-    @property
-    def py__path__(self):
-        """
-        Not seen here, since it's a property. The callback actually uses a
-        variable, so use it like::
-
-            foo.py__path__(sys_path)
-
-        In case of a package, this returns Python's __path__ attribute, which
-        is a list of paths (strings).
-        Raises an AttributeError if the module is not a package.
-        """
-        if self.is_package:
-            return self._py__path__
-        else:
-            raise AttributeError('Only packages have __path__ attributes.')
-
-    def __repr__(self):
-        return "<%s: %s@%s-%s is_stub=%s>" % (
-            self.__class__.__name__, self._string_name,
-            self.tree_node.start_pos[0], self.tree_node.end_pos[0],
-            self.is_stub()
-        )

jedi/evaluate/context/namespace.py

@@ -1,64 +0,0 @@
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.filters import DictFilter
-from jedi.evaluate.names import ContextNameMixin, AbstractNameDefinition
-from jedi.evaluate.base_context import Context
-from jedi.evaluate.context.module import SubModuleDictMixin
-
-
-class ImplicitNSName(ContextNameMixin, AbstractNameDefinition):
-    """
-    Accessing names for implicit namespace packages should infer to nothing.
-    This object will prevent Jedi from raising exceptions
-    """
-    def __init__(self, implicit_ns_context, string_name):
-        self._context = implicit_ns_context
-        self.string_name = string_name
-
-
-class ImplicitNamespaceContext(Context, SubModuleDictMixin):
-    """
-    Provides support for implicit namespace packages
-    """
-    # Is a module like every other module, because if you import an empty
-    # folder foobar it will be available as an object:
-    # <module 'foobar' (namespace)>.
-    api_type = u'module'
-    parent_context = None
-
-    def __init__(self, evaluator, fullname, paths):
-        super(ImplicitNamespaceContext, self).__init__(evaluator, parent_context=None)
-        self.evaluator = evaluator
-        self._fullname = fullname
-        self._paths = paths
-
-    def get_filters(self, search_global=False, until_position=None, origin_scope=None):
-        yield DictFilter(self.sub_modules_dict())
-
-    @property
-    @evaluator_method_cache()
-    def name(self):
-        string_name = self.py__package__()[-1]
-        return ImplicitNSName(self, string_name)
-
-    def py__file__(self):
-        return None
-
-    def py__package__(self):
-        """Return the fullname
-        """
-        return self._fullname.split('.')
-
-    def py__path__(self):
-        return self._paths
-
-    def py__name__(self):
-        return self._fullname
-
-    def is_namespace(self):
-        return True
-
-    def is_stub(self):
-        return False
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self._fullname)

jedi/evaluate/dynamic.py

@@ -1,231 +0,0 @@
-"""
-One of the really important features of |jedi| is to have an option to
-understand code like this::
-
-    def foo(bar):
-        bar. # completion here
-    foo(1)
-
-There's no doubt wheter bar is an ``int`` or not, but if there's also a call
-like ``foo('str')``, what would happen? Well, we'll just show both. Because
-that's what a human would expect.
-
-It works as follows:
-
-- |Jedi| sees a param
-- search for function calls named ``foo``
-- execute these calls and check the input.
-"""
-
-from jedi import settings
-from jedi import debug
-from jedi.evaluate.cache import evaluator_function_cache
-from jedi.evaluate import imports
-from jedi.evaluate.arguments import TreeArguments
-from jedi.evaluate.param import create_default_params
-from jedi.evaluate.helpers import is_stdlib_path
-from jedi.evaluate.utils import to_list
-from jedi.parser_utils import get_parent_scope
-from jedi.evaluate.context import ModuleContext, instance
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate import recursion
-
-
-MAX_PARAM_SEARCHES = 20
-
-
-class DynamicExecutedParams(object):
-    """
-    Simulates being a parameter while actually just being multiple params.
-    """
-
-    def __init__(self, evaluator, executed_params):
-        self.evaluator = evaluator
-        self._executed_params = executed_params
-
-    def infer(self):
-        with recursion.execution_allowed(self.evaluator, self) as allowed:
-            # We need to catch recursions that may occur, because an
-            # anonymous functions can create an anonymous parameter that is
-            # more or less self referencing.
-            if allowed:
-                return ContextSet.from_sets(p.infer() for p in self._executed_params)
-            return NO_CONTEXTS
-
-
-@debug.increase_indent
-def search_params(evaluator, execution_context, funcdef):
-    """
-    A dynamic search for param values. If you try to complete a type:
-
-    >>> def func(foo):
-    ...     foo
-    >>> func(1)
-    >>> func("")
-
-    It is not known what the type ``foo`` without analysing the whole code. You
-    have to look for all calls to ``func`` to find out what ``foo`` possibly
-    is.
-    """
-    if not settings.dynamic_params:
-        return create_default_params(execution_context, funcdef)
-
-    evaluator.dynamic_params_depth += 1
-    try:
-        path = execution_context.get_root_context().py__file__()
-        if path is not None and is_stdlib_path(path):
-            # We don't want to search for usages in the stdlib. Usually people
-            # don't work with it (except if you are a core maintainer, sorry).
-            # This makes everything slower. Just disable it and run the tests,
-            # you will see the slowdown, especially in 3.6.
-            return create_default_params(execution_context, funcdef)
-
-        if funcdef.type == 'lambdef':
-            string_name = _get_lambda_name(funcdef)
-            if string_name is None:
-                return create_default_params(execution_context, funcdef)
-        else:
-            string_name = funcdef.name.value
-        debug.dbg('Dynamic param search in %s.', string_name, color='MAGENTA')
-
-        try:
-            module_context = execution_context.get_root_context()
-            function_executions = _search_function_executions(
-                evaluator,
-                module_context,
-                funcdef,
-                string_name=string_name,
-            )
-            if function_executions:
-                zipped_params = zip(*list(
-                    function_execution.get_executed_params_and_issues()[0]
-                    for function_execution in function_executions
-                ))
-                params = [DynamicExecutedParams(evaluator, executed_params)
-                          for executed_params in zipped_params]
-                # Evaluate the ExecutedParams to types.
-            else:
-                return create_default_params(execution_context, funcdef)
-        finally:
-            debug.dbg('Dynamic param result finished', color='MAGENTA')
-        return params
-    finally:
-        evaluator.dynamic_params_depth -= 1
-
-
-@evaluator_function_cache(default=None)
-@to_list
-def _search_function_executions(evaluator, module_context, funcdef, string_name):
-    """
-    Returns a list of param names.
-    """
-    compare_node = funcdef
-    if string_name == '__init__':
-        cls = get_parent_scope(funcdef)
-        if cls.type == 'classdef':
-            string_name = cls.name.value
-            compare_node = cls
-
-    found_executions = False
-    i = 0
-    for for_mod_context in imports.get_modules_containing_name(
-            evaluator, [module_context], string_name):
-        if not isinstance(module_context, ModuleContext):
-            return
-        for name, trailer in _get_possible_nodes(for_mod_context, string_name):
-            i += 1
-
-            # This is a simple way to stop Jedi's dynamic param recursion
-            # from going wild: The deeper Jedi's in the recursion, the less
-            # code should be evaluated.
-            if i * evaluator.dynamic_params_depth > MAX_PARAM_SEARCHES:
-                return
-
-            random_context = evaluator.create_context(for_mod_context, name)
-            for function_execution in _check_name_for_execution(
-                    evaluator, random_context, compare_node, name, trailer):
-                found_executions = True
-                yield function_execution
-
-        # If there are results after processing a module, we're probably
-        # good to process. This is a speed optimization.
-        if found_executions:
-            return
-
-
-def _get_lambda_name(node):
-    stmt = node.parent
-    if stmt.type == 'expr_stmt':
-        first_operator = next(stmt.yield_operators(), None)
-        if first_operator == '=':
-            first = stmt.children[0]
-            if first.type == 'name':
-                return first.value
-
-    return None
-
-
-def _get_possible_nodes(module_context, func_string_name):
-    try:
-        names = module_context.tree_node.get_used_names()[func_string_name]
-    except KeyError:
-        return
-
-    for name in names:
-        bracket = name.get_next_leaf()
-        trailer = bracket.parent
-        if trailer.type == 'trailer' and bracket == '(':
-            yield name, trailer
-
-
-def _check_name_for_execution(evaluator, context, compare_node, name, trailer):
-    from jedi.evaluate.context.function import FunctionExecutionContext
-
-    def create_func_excs():
-        arglist = trailer.children[1]
-        if arglist == ')':
-            arglist = None
-        args = TreeArguments(evaluator, context, arglist, trailer)
-        if value_node.type == 'classdef':
-            created_instance = instance.TreeInstance(
-                evaluator,
-                value.parent_context,
-                value,
-                args
-            )
-            for execution in created_instance.create_init_executions():
-                yield execution
-        else:
-            yield value.get_function_execution(args)
-
-    for value in evaluator.goto_definitions(context, name):
-        value_node = value.tree_node
-        if compare_node == value_node:
-            for func_execution in create_func_excs():
-                yield func_execution
-        elif isinstance(value.parent_context, FunctionExecutionContext) and \
-                compare_node.type == 'funcdef':
-            # 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.
-            params, _ = value.parent_context.get_executed_params_and_issues()
-            if len(params) != 1:
-                continue
-            values = params[0].infer()
-            nodes = [v.tree_node for v in values]
-            if nodes == [compare_node]:
-                # Found a decorator.
-                module_context = context.get_root_context()
-                execution_context = next(create_func_excs())
-                for name, trailer in _get_possible_nodes(module_context, params[0].string_name):
-                    if value_node.start_pos < name.start_pos < value_node.end_pos:
-                        random_context = evaluator.create_context(execution_context, name)
-                        iterator = _check_name_for_execution(
-                            evaluator,
-                            random_context,
-                            compare_node,
-                            name,
-                            trailer
-                        )
-                        for function_execution in iterator:
-                            yield function_execution

jedi/evaluate/filters.py

@@ -1,412 +0,0 @@
-"""
-Filters are objects that you can use to filter names in different scopes. They
-are needed for name resolution.
-"""
-from abc import abstractmethod
-import weakref
-
-from parso.tree import search_ancestor
-
-from jedi._compatibility import use_metaclass
-from jedi.evaluate import flow_analysis
-from jedi.evaluate.base_context import ContextSet, Context, ContextWrapper, \
-    LazyContextWrapper
-from jedi.parser_utils import get_cached_parent_scope
-from jedi.evaluate.utils import to_list
-from jedi.evaluate.names import TreeNameDefinition, ParamName, AbstractNameDefinition
-
-_definition_name_cache = weakref.WeakKeyDictionary()
-
-
-class AbstractFilter(object):
-    _until_position = None
-
-    def _filter(self, names):
-        if self._until_position is not None:
-            return [n for n in names if n.start_pos < self._until_position]
-        return names
-
-    @abstractmethod
-    def get(self, name):
-        raise NotImplementedError
-
-    @abstractmethod
-    def values(self):
-        raise NotImplementedError
-
-
-class FilterWrapper(object):
-    name_wrapper_class = None
-
-    def __init__(self, wrapped_filter):
-        self._wrapped_filter = wrapped_filter
-
-    def wrap_names(self, names):
-        return [self.name_wrapper_class(name) for name in names]
-
-    def get(self, name):
-        return self.wrap_names(self._wrapped_filter.get(name))
-
-    def values(self):
-        return self.wrap_names(self._wrapped_filter.values())
-
-
-def _get_definition_names(used_names, name_key):
-    try:
-        for_module = _definition_name_cache[used_names]
-    except KeyError:
-        for_module = _definition_name_cache[used_names] = {}
-
-    try:
-        return for_module[name_key]
-    except KeyError:
-        names = used_names.get(name_key, ())
-        result = for_module[name_key] = tuple(name for name in names if name.is_definition())
-        return result
-
-
-class AbstractUsedNamesFilter(AbstractFilter):
-    name_class = TreeNameDefinition
-
-    def __init__(self, context, parser_scope):
-        self._parser_scope = parser_scope
-        self._module_node = self._parser_scope.get_root_node()
-        self._used_names = self._module_node.get_used_names()
-        self.context = context
-
-    def get(self, name, **filter_kwargs):
-        return self._convert_names(self._filter(
-            _get_definition_names(self._used_names, name),
-            **filter_kwargs
-        ))
-
-    def _convert_names(self, names):
-        return [self.name_class(self.context, name) for name in names]
-
-    def values(self, **filter_kwargs):
-        return self._convert_names(
-            name
-            for name_key in self._used_names
-            for name in self._filter(
-                _get_definition_names(self._used_names, name_key),
-                **filter_kwargs
-            )
-        )
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self.context)
-
-
-class ParserTreeFilter(AbstractUsedNamesFilter):
-    # TODO remove evaluator as an argument, it's not used.
-    def __init__(self, evaluator, context, node_context=None, until_position=None,
-                 origin_scope=None):
-        """
-        node_context is an option to specify a second context for use cases
-        like the class mro where the parent class of a new name would be the
-        context, but for some type inference it's important to have a local
-        context of the other classes.
-        """
-        if node_context is None:
-            node_context = context
-        super(ParserTreeFilter, self).__init__(context, node_context.tree_node)
-        self._node_context = node_context
-        self._origin_scope = origin_scope
-        self._until_position = until_position
-
-    def _filter(self, names):
-        names = super(ParserTreeFilter, self)._filter(names)
-        names = [n for n in names if self._is_name_reachable(n)]
-        return list(self._check_flows(names))
-
-    def _is_name_reachable(self, name):
-        parent = name.parent
-        if parent.type == 'trailer':
-            return False
-        base_node = parent if parent.type in ('classdef', 'funcdef') else name
-        return get_cached_parent_scope(self._used_names, base_node) == self._parser_scope
-
-    def _check_flows(self, names):
-        for name in sorted(names, key=lambda name: name.start_pos, reverse=True):
-            check = flow_analysis.reachability_check(
-                context=self._node_context,
-                context_scope=self._parser_scope,
-                node=name,
-                origin_scope=self._origin_scope
-            )
-            if check is not flow_analysis.UNREACHABLE:
-                yield name
-
-            if check is flow_analysis.REACHABLE:
-                break
-
-
-class FunctionExecutionFilter(ParserTreeFilter):
-    param_name = ParamName
-
-    def __init__(self, evaluator, context, node_context=None,
-                 until_position=None, origin_scope=None):
-        super(FunctionExecutionFilter, self).__init__(
-            evaluator,
-            context,
-            node_context,
-            until_position,
-            origin_scope
-        )
-
-    @to_list
-    def _convert_names(self, names):
-        for name in names:
-            param = search_ancestor(name, 'param')
-            if param:
-                yield self.param_name(self.context, name)
-            else:
-                yield TreeNameDefinition(self.context, name)
-
-
-class GlobalNameFilter(AbstractUsedNamesFilter):
-    def __init__(self, context, parser_scope):
-        super(GlobalNameFilter, self).__init__(context, parser_scope)
-
-    def get(self, name):
-        try:
-            names = self._used_names[name]
-        except KeyError:
-            return []
-        return self._convert_names(self._filter(names))
-
-    @to_list
-    def _filter(self, names):
-        for name in names:
-            if name.parent.type == 'global_stmt':
-                yield name
-
-    def values(self):
-        return self._convert_names(
-            name for name_list in self._used_names.values()
-            for name in self._filter(name_list)
-        )
-
-
-class DictFilter(AbstractFilter):
-    def __init__(self, dct):
-        self._dct = dct
-
-    def get(self, name):
-        try:
-            value = self._convert(name, self._dct[name])
-        except KeyError:
-            return []
-        else:
-            return list(self._filter([value]))
-
-    def values(self):
-        def yielder():
-            for item in self._dct.items():
-                try:
-                    yield self._convert(*item)
-                except KeyError:
-                    pass
-        return self._filter(yielder())
-
-    def _convert(self, name, value):
-        return value
-
-    def __repr__(self):
-        keys = ', '.join(self._dct.keys())
-        return '<%s: for {%s}>' % (self.__class__.__name__, keys)
-
-
-class MergedFilter(object):
-    def __init__(self, *filters):
-        self._filters = filters
-
-    def get(self, name):
-        return [n for filter in self._filters for n in filter.get(name)]
-
-    def values(self):
-        return [n for filter in self._filters for n in filter.values()]
-
-    def __repr__(self):
-        return '%s(%s)' % (self.__class__.__name__, ', '.join(str(f) for f in self._filters))
-
-
-class _BuiltinMappedMethod(Context):
-    """``Generator.__next__`` ``dict.values`` methods and so on."""
-    api_type = u'function'
-
-    def __init__(self, builtin_context, method, builtin_func):
-        super(_BuiltinMappedMethod, self).__init__(
-            builtin_context.evaluator,
-            parent_context=builtin_context
-        )
-        self._method = method
-        self._builtin_func = builtin_func
-
-    def py__call__(self, arguments):
-        # TODO add TypeError if params are given/or not correct.
-        return self._method(self.parent_context)
-
-    def __getattr__(self, name):
-        return getattr(self._builtin_func, name)
-
-
-class SpecialMethodFilter(DictFilter):
-    """
-    A filter for methods that are defined in this module on the corresponding
-    classes like Generator (for __next__, etc).
-    """
-    class SpecialMethodName(AbstractNameDefinition):
-        api_type = u'function'
-
-        def __init__(self, parent_context, string_name, value, builtin_context):
-            callable_, python_version = value
-            if python_version is not None and \
-                    python_version != parent_context.evaluator.environment.version_info.major:
-                raise KeyError
-
-            self.parent_context = parent_context
-            self.string_name = string_name
-            self._callable = callable_
-            self._builtin_context = builtin_context
-
-        def infer(self):
-            for filter in self._builtin_context.get_filters():
-                # We can take the first index, because on builtin methods there's
-                # always only going to be one name. The same is true for the
-                # inferred values.
-                for name in filter.get(self.string_name):
-                    builtin_func = next(iter(name.infer()))
-                    break
-                else:
-                    continue
-                break
-            return ContextSet([
-                _BuiltinMappedMethod(self.parent_context, self._callable, builtin_func)
-            ])
-
-    def __init__(self, context, dct, builtin_context):
-        super(SpecialMethodFilter, self).__init__(dct)
-        self.context = context
-        self._builtin_context = builtin_context
-        """
-        This context is what will be used to introspect the name, where as the
-        other context will be used to execute the function.
-
-        We distinguish, because we have to.
-        """
-
-    def _convert(self, name, value):
-        return self.SpecialMethodName(self.context, name, value, self._builtin_context)
-
-
-class _OverwriteMeta(type):
-    def __init__(cls, name, bases, dct):
-        super(_OverwriteMeta, cls).__init__(name, bases, dct)
-
-        base_dct = {}
-        for base_cls in reversed(cls.__bases__):
-            try:
-                base_dct.update(base_cls.overwritten_methods)
-            except AttributeError:
-                pass
-
-        for func in cls.__dict__.values():
-            try:
-                base_dct.update(func.registered_overwritten_methods)
-            except AttributeError:
-                pass
-        cls.overwritten_methods = base_dct
-
-
-class _AttributeOverwriteMixin(object):
-    def get_filters(self, search_global=False, *args, **kwargs):
-        yield SpecialMethodFilter(self, self.overwritten_methods, self._wrapped_context)
-
-        for filter in self._wrapped_context.get_filters(search_global):
-            yield filter
-
-
-class LazyAttributeOverwrite(use_metaclass(_OverwriteMeta, _AttributeOverwriteMixin,
-                                           LazyContextWrapper)):
-    def __init__(self, evaluator):
-        self.evaluator = evaluator
-
-
-class AttributeOverwrite(use_metaclass(_OverwriteMeta, _AttributeOverwriteMixin,
-                                       ContextWrapper)):
-    pass
-
-
-def publish_method(method_name, python_version_match=None):
-    def decorator(func):
-        dct = func.__dict__.setdefault('registered_overwritten_methods', {})
-        dct[method_name] = func, python_version_match
-        return func
-    return decorator
-
-
-def get_global_filters(evaluator, context, until_position, origin_scope):
-    """
-    Returns all filters in order of priority for name resolution.
-
-    For global name lookups. The filters will handle name resolution
-    themselves, but here we gather possible filters downwards.
-
-    >>> from jedi._compatibility import u, no_unicode_pprint
-    >>> from jedi import Script
-    >>> script = Script(u('''
-    ... x = ['a', 'b', 'c']
-    ... def func():
-    ...     y = None
-    ... '''))
-    >>> module_node = script._module_node
-    >>> scope = next(module_node.iter_funcdefs())
-    >>> scope
-    <Function: func@3-5>
-    >>> context = script._get_module().create_context(scope)
-    >>> filters = list(get_global_filters(context.evaluator, context, (4, 0), None))
-
-    First we get the names from the function scope.
-
-    >>> no_unicode_pprint(filters[0])  # doctest: +ELLIPSIS
-    MergedFilter(<ParserTreeFilter: ...>, <GlobalNameFilter: ...>)
-    >>> sorted(str(n) for n in filters[0].values())  # doctest: +NORMALIZE_WHITESPACE
-    ['<TreeNameDefinition: string_name=func start_pos=(3, 4)>',
-     '<TreeNameDefinition: string_name=x start_pos=(2, 0)>']
-    >>> filters[0]._filters[0]._until_position
-    (4, 0)
-    >>> filters[0]._filters[1]._until_position
-
-    Then it yields the names from one level "lower". In this example, this is
-    the module scope (including globals).
-    As a side note, you can see, that the position in the filter is None on the
-    globals filter, because there the whole module is searched.
-
-    >>> list(filters[1].values())  # package modules -> Also empty.
-    []
-    >>> sorted(name.string_name for name in filters[2].values())  # Module attributes
-    ['__doc__', '__name__', '__package__']
-
-    Finally, it yields the builtin filter, if `include_builtin` is
-    true (default).
-
-    >>> list(filters[3].values())  # doctest: +ELLIPSIS
-    [...]
-    """
-    from jedi.evaluate.context.function import FunctionExecutionContext
-    while context is not None:
-        # Names in methods cannot be resolved within the class.
-        for filter in context.get_filters(
-                search_global=True,
-                until_position=until_position,
-                origin_scope=origin_scope):
-            yield filter
-        if isinstance(context, FunctionExecutionContext):
-            # The position should be reset if the current scope is a function.
-            until_position = None
-
-        context = context.parent_context
-
-    # Add builtins to the global scope.
-    yield next(evaluator.builtins_module.get_filters())

jedi/evaluate/finder.py

@@ -1,290 +0,0 @@
-"""
-Searching for names with given scope and name. This is very central in Jedi and
-Python. The name resolution is quite complicated with descripter,
-``__getattribute__``, ``__getattr__``, ``global``, etc.
-
-If you want to understand name resolution, please read the first few chapters
-in http://blog.ionelmc.ro/2015/02/09/understanding-python-metaclasses/.
-
-Flow checks
-+++++++++++
-
-Flow checks are not really mature. There's only a check for ``isinstance``.  It
-would check whether a flow has the form of ``if isinstance(a, type_or_tuple)``.
-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.python import tree
-from parso.tree import search_ancestor
-from jedi import debug
-from jedi import settings
-from jedi.evaluate import compiled
-from jedi.evaluate import analysis
-from jedi.evaluate import flow_analysis
-from jedi.evaluate.arguments import TreeArguments
-from jedi.evaluate import helpers
-from jedi.evaluate.context import iterable
-from jedi.evaluate.filters import get_global_filters
-from jedi.evaluate.names import TreeNameDefinition
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-from jedi.parser_utils import is_scope, get_parent_scope
-from jedi.evaluate.gradual.conversion import convert_contexts
-
-
-class NameFinder(object):
-    def __init__(self, evaluator, context, name_context, name_or_str,
-                 position=None, analysis_errors=True):
-        self._evaluator = evaluator
-        # Make sure that it's not just a syntax tree node.
-        self._context = context
-        self._name_context = name_context
-        self._name = name_or_str
-        if isinstance(name_or_str, tree.Name):
-            self._string_name = name_or_str.value
-        else:
-            self._string_name = name_or_str
-        self._position = position
-        self._found_predefined_types = None
-        self._analysis_errors = analysis_errors
-
-    def find(self, filters, attribute_lookup):
-        """
-        :params bool attribute_lookup: Tell to logic if we're accessing the
-            attribute or the contents of e.g. a function.
-        """
-        names = self.filter_name(filters)
-        if self._found_predefined_types is not None and names:
-            check = flow_analysis.reachability_check(
-                context=self._context,
-                context_scope=self._context.tree_node,
-                node=self._name,
-            )
-            if check is flow_analysis.UNREACHABLE:
-                return NO_CONTEXTS
-            return self._found_predefined_types
-
-        types = self._names_to_types(names, attribute_lookup)
-
-        if not names and self._analysis_errors and not types \
-                and not (isinstance(self._name, tree.Name) and
-                         isinstance(self._name.parent.parent, tree.Param)):
-            if isinstance(self._name, tree.Name):
-                if attribute_lookup:
-                    analysis.add_attribute_error(
-                        self._name_context, self._context, self._name)
-                else:
-                    message = ("NameError: name '%s' is not defined."
-                               % self._string_name)
-                    analysis.add(self._name_context, 'name-error', self._name, message)
-
-        return types
-
-    def _get_origin_scope(self):
-        if isinstance(self._name, tree.Name):
-            scope = self._name
-            while scope.parent is not None:
-                # TODO why if classes?
-                if not isinstance(scope, tree.Scope):
-                    break
-                scope = scope.parent
-            return scope
-        else:
-            return None
-
-    def get_filters(self, search_global=False):
-        origin_scope = self._get_origin_scope()
-        if search_global:
-            position = self._position
-
-            # For functions and classes the defaults don't belong to the
-            # function and get evaluated in the context before the function. So
-            # make sure to exclude the function/class name.
-            if origin_scope is not None:
-                ancestor = search_ancestor(origin_scope, 'funcdef', 'classdef', 'lambdef')
-                lambdef = None
-                if ancestor == 'lambdef':
-                    # For lambdas it's even more complicated since parts will
-                    # be evaluated later.
-                    lambdef = ancestor
-                    ancestor = search_ancestor(origin_scope, 'funcdef', 'classdef')
-                if ancestor is not None:
-                    colon = ancestor.children[-2]
-                    if position is not None and position < colon.start_pos:
-                        if lambdef is None or position < lambdef.children[-2].start_pos:
-                            position = ancestor.start_pos
-
-            return get_global_filters(self._evaluator, self._context, position, origin_scope)
-        else:
-            return self._get_context_filters(origin_scope)
-
-    def _get_context_filters(self, origin_scope):
-        for f in self._context.get_filters(False, self._position, origin_scope=origin_scope):
-            yield f
-        # This covers the case where a stub files are incomplete.
-        if self._context.is_stub():
-            for c in convert_contexts(ContextSet({self._context})):
-                for f in c.get_filters():
-                    yield f
-
-    def filter_name(self, filters):
-        """
-        Searches names that are defined in a scope (the different
-        ``filters``), until a name fits.
-        """
-        names = []
-        # This paragraph is currently needed for proper branch evaluation
-        # (static analysis).
-        if self._context.predefined_names and isinstance(self._name, tree.Name):
-            node = self._name
-            while node is not None and not is_scope(node):
-                node = node.parent
-                if node.type in ("if_stmt", "for_stmt", "comp_for", 'sync_comp_for'):
-                    try:
-                        name_dict = self._context.predefined_names[node]
-                        types = name_dict[self._string_name]
-                    except KeyError:
-                        continue
-                    else:
-                        self._found_predefined_types = types
-                        break
-
-        for filter in filters:
-            names = filter.get(self._string_name)
-            if names:
-                if len(names) == 1:
-                    n, = names
-                    if isinstance(n, TreeNameDefinition):
-                        # Something somewhere went terribly wrong. This
-                        # typically happens when using goto on an import in an
-                        # __init__ file. I think we need a better solution, but
-                        # it's kind of hard, because for Jedi it's not clear
-                        # that that name has not been defined, yet.
-                        if n.tree_name == self._name:
-                            def_ = self._name.get_definition()
-                            if def_ is not None and def_.type == 'import_from':
-                                continue
-                break
-
-        debug.dbg('finder.filter_name %s in (%s): %s@%s',
-                  self._string_name, self._context, names, self._position)
-        return list(names)
-
-    def _check_getattr(self, inst):
-        """Checks for both __getattr__ and __getattribute__ methods"""
-        # str is important, because it shouldn't be `Name`!
-        name = compiled.create_simple_object(self._evaluator, self._string_name)
-
-        # This is a little bit special. `__getattribute__` is in Python
-        # executed before `__getattr__`. But: I know no use case, where
-        # this could be practical and where Jedi would return wrong types.
-        # If you ever find something, let me know!
-        # We are inversing this, because a hand-crafted `__getattribute__`
-        # could still call another hand-crafted `__getattr__`, but not the
-        # other way around.
-        names = (inst.get_function_slot_names(u'__getattr__') or
-                 inst.get_function_slot_names(u'__getattribute__'))
-        return inst.execute_function_slots(names, name)
-
-    def _names_to_types(self, names, attribute_lookup):
-        contexts = ContextSet.from_sets(name.infer() for name in names)
-
-        debug.dbg('finder._names_to_types: %s -> %s', names, contexts)
-        if not names and self._context.is_instance() and not self._context.is_compiled():
-            # handling __getattr__ / __getattribute__
-            return self._check_getattr(self._context)
-
-        # Add isinstance and other if/assert knowledge.
-        if not contexts and isinstance(self._name, tree.Name) and \
-                not self._name_context.is_instance() and not self._context.is_compiled():
-            flow_scope = self._name
-            base_nodes = [self._name_context.tree_node]
-
-            if any(b.type in ('comp_for', 'sync_comp_for') for b in base_nodes):
-                return contexts
-            while True:
-                flow_scope = get_parent_scope(flow_scope, include_flows=True)
-                n = _check_flow_information(self._name_context, flow_scope,
-                                            self._name, self._position)
-                if n is not None:
-                    return n
-                if flow_scope in base_nodes:
-                    break
-        return contexts
-
-
-def _check_flow_information(context, flow, search_name, pos):
-    """ Try to find out the type of a variable just with the information that
-    is given by the flows: e.g. It is also responsible for assert checks.::
-
-        if isinstance(k, str):
-            k.  # <- completion here
-
-    ensures that `k` is a string.
-    """
-    if not settings.dynamic_flow_information:
-        return None
-
-    result = None
-    if is_scope(flow):
-        # Check for asserts.
-        module_node = flow.get_root_node()
-        try:
-            names = module_node.get_used_names()[search_name.value]
-        except KeyError:
-            return None
-        names = reversed([
-            n for n in names
-            if flow.start_pos <= n.start_pos < (pos or flow.end_pos)
-        ])
-
-        for name in names:
-            ass = search_ancestor(name, 'assert_stmt')
-            if ass is not None:
-                result = _check_isinstance_type(context, ass.assertion, search_name)
-                if result is not None:
-                    return result
-
-    if flow.type in ('if_stmt', 'while_stmt'):
-        potential_ifs = [c for c in flow.children[1::4] if c != ':']
-        for if_test in reversed(potential_ifs):
-            if search_name.start_pos > if_test.end_pos:
-                return _check_isinstance_type(context, if_test, search_name)
-    return result
-
-
-def _check_isinstance_type(context, element, search_name):
-    try:
-        assert element.type in ('power', 'atom_expr')
-        # this might be removed if we analyze and, etc
-        assert len(element.children) == 2
-        first, trailer = element.children
-        assert first.type == 'name' and first.value == 'isinstance'
-        assert trailer.type == 'trailer' and trailer.children[0] == '('
-        assert len(trailer.children) == 3
-
-        # arglist stuff
-        arglist = trailer.children[1]
-        args = TreeArguments(context.evaluator, context, arglist, trailer)
-        param_list = list(args.unpack())
-        # Disallow keyword arguments
-        assert len(param_list) == 2
-        (key1, lazy_context_object), (key2, lazy_context_cls) = param_list
-        assert key1 is None and key2 is None
-        call = helpers.call_of_leaf(search_name)
-        is_instance_call = helpers.call_of_leaf(lazy_context_object.data)
-        # Do a simple get_code comparison. They should just have the same code,
-        # and everything will be all right.
-        normalize = context.evaluator.grammar._normalize
-        assert normalize(is_instance_call) == normalize(call)
-    except AssertionError:
-        return None
-
-    context_set = NO_CONTEXTS
-    for cls_or_tup in lazy_context_cls.infer():
-        if isinstance(cls_or_tup, iterable.Sequence) and cls_or_tup.array_type == 'tuple':
-            for lazy_context in cls_or_tup.py__iter__():
-                context_set |= lazy_context.infer().execute_evaluated()
-        else:
-            context_set |= cls_or_tup.execute_evaluated()
-    return context_set

jedi/evaluate/gradual/annotation.py

@@ -1,405 +0,0 @@
-"""
-PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints
-through function annotations. There is a strong suggestion in this document
-that only the type of type hinting defined in PEP0484 should be allowed
-as annotations in future python versions.
-"""
-
-import re
-
-from parso import ParserSyntaxError, parse
-
-from jedi._compatibility import force_unicode
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate.gradual.typing import TypeVar, LazyGenericClass, \
-    AbstractAnnotatedClass
-from jedi.evaluate.gradual.typing import GenericClass
-from jedi.evaluate.helpers import is_string
-from jedi.evaluate.compiled import builtin_from_name
-from jedi import debug
-from jedi import parser_utils
-
-
-def eval_annotation(context, annotation):
-    """
-    Evaluates an annotation node. This means that it evaluates the part of
-    `int` here:
-
-        foo: int = 3
-
-    Also checks for forward references (strings)
-    """
-    context_set = context.eval_node(annotation)
-    if len(context_set) != 1:
-        debug.warning("Eval'ed typing index %s should lead to 1 object, "
-                      " not %s" % (annotation, context_set))
-        return context_set
-
-    evaled_context = list(context_set)[0]
-    if is_string(evaled_context):
-        result = _get_forward_reference_node(context, evaled_context.get_safe_value())
-        if result is not None:
-            return context.eval_node(result)
-    return context_set
-
-
-def _evaluate_annotation_string(context, string, index=None):
-    node = _get_forward_reference_node(context, string)
-    if node is None:
-        return NO_CONTEXTS
-
-    context_set = context.eval_node(node)
-    if index is not None:
-        context_set = context_set.filter(
-            lambda context: context.array_type == u'tuple'  # noqa
-                            and len(list(context.py__iter__())) >= index
-        ).py__simple_getitem__(index)
-    return context_set
-
-
-def _get_forward_reference_node(context, string):
-    try:
-        new_node = context.evaluator.grammar.parse(
-            force_unicode(string),
-            start_symbol='eval_input',
-            error_recovery=False
-        )
-    except ParserSyntaxError:
-        debug.warning('Annotation not parsed: %s' % string)
-        return None
-    else:
-        module = context.tree_node.get_root_node()
-        parser_utils.move(new_node, module.end_pos[0])
-        new_node.parent = context.tree_node
-        return new_node
-
-
-def _split_comment_param_declaration(decl_text):
-    """
-    Split decl_text on commas, but group generic expressions
-    together.
-
-    For example, given "foo, Bar[baz, biz]" we return
-    ['foo', 'Bar[baz, biz]'].
-
-    """
-    try:
-        node = parse(decl_text, error_recovery=False).children[0]
-    except ParserSyntaxError:
-        debug.warning('Comment annotation is not valid Python: %s' % decl_text)
-        return []
-
-    if node.type == 'name':
-        return [node.get_code().strip()]
-
-    params = []
-    try:
-        children = node.children
-    except AttributeError:
-        return []
-    else:
-        for child in children:
-            if child.type in ['name', 'atom_expr', 'power']:
-                params.append(child.get_code().strip())
-
-    return params
-
-
-@evaluator_method_cache()
-def infer_param(execution_context, param):
-    contexts = _infer_param(execution_context, param)
-    evaluator = execution_context.evaluator
-    if param.star_count == 1:
-        tuple_ = builtin_from_name(evaluator, 'tuple')
-        return ContextSet([GenericClass(
-            tuple_,
-            generics=(contexts,),
-        ) for c in contexts])
-    elif param.star_count == 2:
-        dct = builtin_from_name(evaluator, 'dict')
-        return ContextSet([GenericClass(
-            dct,
-            generics=(ContextSet([builtin_from_name(evaluator, 'str')]), contexts),
-        ) for c in contexts])
-        pass
-    return contexts
-
-
-def _infer_param(execution_context, param):
-    """
-    Infers the type of a function parameter, using type annotations.
-    """
-    annotation = param.annotation
-    if annotation is None:
-        # If no Python 3-style annotation, look for a Python 2-style comment
-        # annotation.
-        # Identify parameters to function in the same sequence as they would
-        # appear in a type comment.
-        all_params = [child for child in param.parent.children
-                      if child.type == 'param']
-
-        node = param.parent.parent
-        comment = parser_utils.get_following_comment_same_line(node)
-        if comment is None:
-            return NO_CONTEXTS
-
-        match = re.match(r"^#\s*type:\s*\(([^#]*)\)\s*->", comment)
-        if not match:
-            return NO_CONTEXTS
-        params_comments = _split_comment_param_declaration(match.group(1))
-
-        # Find the specific param being investigated
-        index = all_params.index(param)
-        # If the number of parameters doesn't match length of type comment,
-        # ignore first parameter (assume it's self).
-        if len(params_comments) != len(all_params):
-            debug.warning(
-                "Comments length != Params length %s %s",
-                params_comments, all_params
-            )
-        from jedi.evaluate.context.instance import InstanceArguments
-        if isinstance(execution_context.var_args, InstanceArguments):
-            if index == 0:
-                # Assume it's self, which is already handled
-                return NO_CONTEXTS
-            index -= 1
-        if index >= len(params_comments):
-            return NO_CONTEXTS
-
-        param_comment = params_comments[index]
-        return _evaluate_annotation_string(
-            execution_context.function_context.get_default_param_context(),
-            param_comment
-        )
-    # Annotations are like default params and resolve in the same way.
-    context = execution_context.function_context.get_default_param_context()
-    return eval_annotation(context, annotation)
-
-
-def py__annotations__(funcdef):
-    dct = {}
-    for function_param in funcdef.get_params():
-        param_annotation = function_param.annotation
-        if param_annotation is not None:
-            dct[function_param.name.value] = param_annotation
-
-    return_annotation = funcdef.annotation
-    if return_annotation:
-        dct['return'] = return_annotation
-    return dct
-
-
-@evaluator_method_cache()
-def infer_return_types(function_execution_context):
-    """
-    Infers the type of a function's return value,
-    according to type annotations.
-    """
-    all_annotations = py__annotations__(function_execution_context.tree_node)
-    annotation = all_annotations.get("return", None)
-    if annotation is None:
-        # If there is no Python 3-type annotation, look for a Python 2-type annotation
-        node = function_execution_context.tree_node
-        comment = parser_utils.get_following_comment_same_line(node)
-        if comment is None:
-            return NO_CONTEXTS
-
-        match = re.match(r"^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)", comment)
-        if not match:
-            return NO_CONTEXTS
-
-        return _evaluate_annotation_string(
-            function_execution_context.function_context.get_default_param_context(),
-            match.group(1).strip()
-        ).execute_annotation()
-        if annotation is None:
-            return NO_CONTEXTS
-
-    context = function_execution_context.function_context.get_default_param_context()
-    unknown_type_vars = list(find_unknown_type_vars(context, annotation))
-    annotation_contexts = eval_annotation(context, annotation)
-    if not unknown_type_vars:
-        return annotation_contexts.execute_annotation()
-
-    type_var_dict = infer_type_vars_for_execution(function_execution_context, all_annotations)
-
-    return ContextSet.from_sets(
-        ann.define_generics(type_var_dict)
-        if isinstance(ann, (AbstractAnnotatedClass, TypeVar)) else ContextSet({ann})
-        for ann in annotation_contexts
-    ).execute_annotation()
-
-
-def infer_type_vars_for_execution(execution_context, annotation_dict):
-    """
-    Some functions use type vars that are not defined by the class, but rather
-    only defined in the function. See for example `iter`. In those cases we
-    want to:
-
-    1. Search for undefined type vars.
-    2. Infer type vars with the execution state we have.
-    3. Return the union of all type vars that have been found.
-    """
-    context = execution_context.function_context.get_default_param_context()
-
-    annotation_variable_results = {}
-    executed_params, _ = execution_context.get_executed_params_and_issues()
-    for executed_param in executed_params:
-        try:
-            annotation_node = annotation_dict[executed_param.string_name]
-        except KeyError:
-            continue
-
-        annotation_variables = find_unknown_type_vars(context, annotation_node)
-        if annotation_variables:
-            # Infer unknown type var
-            annotation_context_set = context.eval_node(annotation_node)
-            star_count = executed_param._param_node.star_count
-            actual_context_set = executed_param.infer(use_hints=False)
-            if star_count == 1:
-                actual_context_set = actual_context_set.merge_types_of_iterate()
-            elif star_count == 2:
-                # TODO _dict_values is not public.
-                actual_context_set = actual_context_set.try_merge('_dict_values')
-            for ann in annotation_context_set:
-                _merge_type_var_dicts(
-                    annotation_variable_results,
-                    _infer_type_vars(ann, actual_context_set),
-                )
-
-    return annotation_variable_results
-
-
-def _merge_type_var_dicts(base_dict, new_dict):
-    for type_var_name, contexts in new_dict.items():
-        try:
-            base_dict[type_var_name] |= contexts
-        except KeyError:
-            base_dict[type_var_name] = contexts
-
-
-def _infer_type_vars(annotation_context, context_set):
-    """
-    This function tries to find information about undefined type vars and
-    returns a dict from type var name to context set.
-
-    This is for example important to understand what `iter([1])` returns.
-    According to typeshed, `iter` returns an `Iterator[_T]`:
-
-        def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
-
-    This functions would generate `int` for `_T` in this case, because it
-    unpacks the `Iterable`.
-    """
-    type_var_dict = {}
-    if isinstance(annotation_context, TypeVar):
-        return {annotation_context.py__name__(): context_set.py__class__()}
-    elif isinstance(annotation_context, LazyGenericClass):
-        name = annotation_context.py__name__()
-        if name == 'Iterable':
-            given = annotation_context.get_generics()
-            if given:
-                for nested_annotation_context in given[0]:
-                    _merge_type_var_dicts(
-                        type_var_dict,
-                        _infer_type_vars(
-                            nested_annotation_context,
-                            context_set.merge_types_of_iterate()
-                        )
-                    )
-        elif name == 'Mapping':
-            given = annotation_context.get_generics()
-            if len(given) == 2:
-                for context in context_set:
-                    try:
-                        method = context.get_mapping_item_contexts
-                    except AttributeError:
-                        continue
-                    key_contexts, value_contexts = method()
-
-                    for nested_annotation_context in given[0]:
-                        _merge_type_var_dicts(
-                            type_var_dict,
-                            _infer_type_vars(
-                                nested_annotation_context,
-                                key_contexts,
-                            )
-                        )
-                    for nested_annotation_context in given[1]:
-                        _merge_type_var_dicts(
-                            type_var_dict,
-                            _infer_type_vars(
-                                nested_annotation_context,
-                                value_contexts,
-                            )
-                        )
-    return type_var_dict
-
-
-def find_type_from_comment_hint_for(context, node, name):
-    return _find_type_from_comment_hint(context, node, node.children[1], name)
-
-
-def find_type_from_comment_hint_with(context, node, name):
-    assert len(node.children[1].children) == 3, \
-        "Can only be here when children[1] is 'foo() as f'"
-    varlist = node.children[1].children[2]
-    return _find_type_from_comment_hint(context, node, varlist, name)
-
-
-def find_type_from_comment_hint_assign(context, node, name):
-    return _find_type_from_comment_hint(context, node, node.children[0], name)
-
-
-def _find_type_from_comment_hint(context, node, varlist, name):
-    index = None
-    if varlist.type in ("testlist_star_expr", "exprlist", "testlist"):
-        # something like "a, b = 1, 2"
-        index = 0
-        for child in varlist.children:
-            if child == name:
-                break
-            if child.type == "operator":
-                continue
-            index += 1
-        else:
-            return []
-
-    comment = parser_utils.get_following_comment_same_line(node)
-    if comment is None:
-        return []
-    match = re.match(r"^#\s*type:\s*([^#]*)", comment)
-    if match is None:
-        return []
-    return _evaluate_annotation_string(
-        context, match.group(1).strip(), index
-    ).execute_annotation()
-
-
-def find_unknown_type_vars(context, node):
-    def check_node(node):
-        if node.type in ('atom_expr', 'power'):
-            trailer = node.children[-1]
-            if trailer.type == 'trailer' and trailer.children[0] == '[':
-                for subscript_node in _unpack_subscriptlist(trailer.children[1]):
-                    check_node(subscript_node)
-        else:
-            type_var_set = context.eval_node(node)
-            for type_var in type_var_set:
-                if isinstance(type_var, TypeVar) and type_var not in found:
-                    found.append(type_var)
-
-    found = []  # We're not using a set, because the order matters.
-    check_node(node)
-    return found
-
-
-def _unpack_subscriptlist(subscriptlist):
-    if subscriptlist.type == 'subscriptlist':
-        for subscript in subscriptlist.children[::2]:
-            if subscript.type != 'subscript':
-                yield subscript
-    else:
-        if subscriptlist.type != 'subscript':
-            yield subscriptlist

jedi/evaluate/gradual/conversion.py

@@ -1,199 +0,0 @@
-from jedi import debug
-from jedi.evaluate.base_context import ContextSet, \
-    NO_CONTEXTS
-from jedi.evaluate.utils import to_list
-from jedi.evaluate.gradual.stub_context import StubModuleContext
-
-
-def _stub_to_python_context_set(stub_context, ignore_compiled=False):
-    stub_module = stub_context.get_root_context()
-    if not stub_module.is_stub():
-        return ContextSet([stub_context])
-
-    was_instance = stub_context.is_instance()
-    if was_instance:
-        stub_context = stub_context.py__class__()
-
-    qualified_names = stub_context.get_qualified_names()
-    if qualified_names is None:
-        return NO_CONTEXTS
-
-    was_bound_method = stub_context.is_bound_method()
-    if was_bound_method:
-        # Infer the object first. We can infer the method later.
-        method_name = qualified_names[-1]
-        qualified_names = qualified_names[:-1]
-        was_instance = True
-
-    contexts = _infer_from_stub(stub_module, qualified_names, ignore_compiled)
-    if was_instance:
-        contexts = ContextSet.from_sets(
-            c.execute_evaluated()
-            for c in contexts
-            if c.is_class()
-        )
-    if was_bound_method:
-        # Now that the instance has been properly created, we can simply get
-        # the method.
-        contexts = contexts.py__getattribute__(method_name)
-    return contexts
-
-
-def _infer_from_stub(stub_module, qualified_names, ignore_compiled):
-    from jedi.evaluate.compiled.mixed import MixedObject
-    assert isinstance(stub_module, (StubModuleContext, MixedObject)), stub_module
-    non_stubs = stub_module.non_stub_context_set
-    if ignore_compiled:
-        non_stubs = non_stubs.filter(lambda c: not c.is_compiled())
-    for name in qualified_names:
-        non_stubs = non_stubs.py__getattribute__(name)
-    return non_stubs
-
-
-@to_list
-def _try_stub_to_python_names(names, prefer_stub_to_compiled=False):
-    for name in names:
-        module = name.get_root_context()
-        if not module.is_stub():
-            yield name
-            continue
-
-        name_list = name.get_qualified_names()
-        if name_list is None:
-            contexts = NO_CONTEXTS
-        else:
-            contexts = _infer_from_stub(
-                module,
-                name_list[:-1],
-                ignore_compiled=prefer_stub_to_compiled,
-            )
-        if contexts and name_list:
-            new_names = contexts.py__getattribute__(name_list[-1], is_goto=True)
-            for new_name in new_names:
-                yield new_name
-            if new_names:
-                continue
-        elif contexts:
-            for c in contexts:
-                yield c.name
-            continue
-        # This is the part where if we haven't found anything, just return the
-        # stub name.
-        yield name
-
-
-def _load_stub_module(module):
-    if module.is_stub():
-        return module
-    from jedi.evaluate.gradual.typeshed import _try_to_load_stub_cached
-    return _try_to_load_stub_cached(
-        module.evaluator,
-        import_names=module.string_names,
-        python_context_set=ContextSet([module]),
-        parent_module_context=None,
-        sys_path=module.evaluator.get_sys_path(),
-    )
-
-
-@to_list
-def _python_to_stub_names(names, fallback_to_python=False):
-    for name in names:
-        module = name.get_root_context()
-        if module.is_stub():
-            yield name
-            continue
-
-        if name.is_import():
-            for new_name in name.goto():
-                # Imports don't need to be converted, because they are already
-                # stubs if possible.
-                if fallback_to_python or new_name.is_stub():
-                    yield new_name
-            continue
-
-        name_list = name.get_qualified_names()
-        stubs = NO_CONTEXTS
-        if name_list is not None:
-            stub_module = _load_stub_module(module)
-            if stub_module is not None:
-                stubs = ContextSet({stub_module})
-                for name in name_list[:-1]:
-                    stubs = stubs.py__getattribute__(name)
-        if stubs and name_list:
-            new_names = stubs.py__getattribute__(name_list[-1], is_goto=True)
-            for new_name in new_names:
-                yield new_name
-            if new_names:
-                continue
-        elif stubs:
-            for c in stubs:
-                yield c.name
-            continue
-        if fallback_to_python:
-            # This is the part where if we haven't found anything, just return
-            # the stub name.
-            yield name
-
-
-def convert_names(names, only_stubs=False, prefer_stubs=False):
-    assert not (only_stubs and prefer_stubs)
-    with debug.increase_indent_cm('convert names'):
-        if only_stubs or prefer_stubs:
-            return _python_to_stub_names(names, fallback_to_python=prefer_stubs)
-        else:
-            return _try_stub_to_python_names(names, prefer_stub_to_compiled=True)
-
-
-def convert_contexts(contexts, only_stubs=False, prefer_stubs=False, ignore_compiled=True):
-    assert not (only_stubs and prefer_stubs)
-    with debug.increase_indent_cm('convert contexts'):
-        if only_stubs or prefer_stubs:
-            return ContextSet.from_sets(
-                to_stub(context)
-                or (ContextSet({context}) if prefer_stubs else NO_CONTEXTS)
-                for context in contexts
-            )
-        else:
-            return ContextSet.from_sets(
-                _stub_to_python_context_set(stub_context, ignore_compiled=ignore_compiled)
-                or ContextSet({stub_context})
-                for stub_context in contexts
-            )
-
-
-# TODO merge with _python_to_stub_names?
-def to_stub(context):
-    if context.is_stub():
-        return ContextSet([context])
-
-    was_instance = context.is_instance()
-    if was_instance:
-        context = context.py__class__()
-
-    qualified_names = context.get_qualified_names()
-    stub_module = _load_stub_module(context.get_root_context())
-    if stub_module is None or qualified_names is None:
-        return NO_CONTEXTS
-
-    was_bound_method = context.is_bound_method()
-    if was_bound_method:
-        # Infer the object first. We can infer the method later.
-        method_name = qualified_names[-1]
-        qualified_names = qualified_names[:-1]
-        was_instance = True
-
-    stub_contexts = ContextSet([stub_module])
-    for name in qualified_names:
-        stub_contexts = stub_contexts.py__getattribute__(name)
-
-    if was_instance:
-        stub_contexts = ContextSet.from_sets(
-            c.execute_evaluated()
-            for c in stub_contexts
-            if c.is_class()
-        )
-    if was_bound_method:
-        # Now that the instance has been properly created, we can simply get
-        # the method.
-        stub_contexts = stub_contexts.py__getattribute__(method_name)
-    return stub_contexts

jedi/evaluate/gradual/stub_context.py

@@ -1,105 +0,0 @@
-from jedi.evaluate.base_context import ContextWrapper
-from jedi.evaluate.context.module import ModuleContext
-from jedi.evaluate.filters import ParserTreeFilter, \
-    TreeNameDefinition
-from jedi.evaluate.gradual.typing import TypingModuleFilterWrapper
-
-
-class StubModuleContext(ModuleContext):
-    def __init__(self, non_stub_context_set, *args, **kwargs):
-        super(StubModuleContext, self).__init__(*args, **kwargs)
-        self.non_stub_context_set = non_stub_context_set
-
-    def is_stub(self):
-        return True
-
-    def sub_modules_dict(self):
-        """
-        We have to overwrite this, because it's possible to have stubs that
-        don't have code for all the child modules. At the time of writing this
-        there are for example no stubs for `json.tool`.
-        """
-        names = {}
-        for context in self.non_stub_context_set:
-            try:
-                method = context.sub_modules_dict
-            except AttributeError:
-                pass
-            else:
-                names.update(method())
-        names.update(super(StubModuleContext, self).sub_modules_dict())
-        return names
-
-    def _get_first_non_stub_filters(self):
-        for context in self.non_stub_context_set:
-            yield next(context.get_filters(search_global=False))
-
-    def _get_stub_filters(self, search_global, **filter_kwargs):
-        return [StubFilter(
-            self.evaluator,
-            context=self,
-            search_global=search_global,
-            **filter_kwargs
-        )] + list(self.iter_star_filters(search_global=search_global))
-
-    def get_filters(self, search_global=False, until_position=None,
-                    origin_scope=None, **kwargs):
-        filters = super(StubModuleContext, self).get_filters(
-            search_global, until_position, origin_scope, **kwargs
-        )
-        next(filters)  # Ignore the first filter and replace it with our own
-        stub_filters = self._get_stub_filters(
-            search_global=search_global,
-            until_position=until_position,
-            origin_scope=origin_scope,
-        )
-        for f in stub_filters:
-            yield f
-
-        for f in filters:
-            yield f
-
-
-class TypingModuleWrapper(StubModuleContext):
-    def get_filters(self, *args, **kwargs):
-        filters = super(TypingModuleWrapper, self).get_filters(*args, **kwargs)
-        yield TypingModuleFilterWrapper(next(filters))
-        for f in filters:
-            yield f
-
-
-# From here on down we make looking up the sys.version_info fast.
-class _StubName(TreeNameDefinition):
-    def infer(self):
-        inferred = super(_StubName, self).infer()
-        if self.string_name == 'version_info' and self.get_root_context().py__name__() == 'sys':
-            return [VersionInfo(c) for c in inferred]
-        return inferred
-
-
-class StubFilter(ParserTreeFilter):
-    name_class = _StubName
-
-    def __init__(self, *args, **kwargs):
-        self._search_global = kwargs.pop('search_global')  # Python 2 :/
-        super(StubFilter, self).__init__(*args, **kwargs)
-
-    def _is_name_reachable(self, name):
-        if not super(StubFilter, self)._is_name_reachable(name):
-            return False
-
-        if not self._search_global:
-            # Imports in stub files are only public if they have an "as"
-            # export.
-            definition = name.get_definition()
-            if definition.type in ('import_from', 'import_name'):
-                if name.parent.type not in ('import_as_name', 'dotted_as_name'):
-                    return False
-            n = name.value
-            if n.startswith('_') and not (n.startswith('__') and n.endswith('__')):
-                return False
-        return True
-
-
-class VersionInfo(ContextWrapper):
-    pass

jedi/evaluate/gradual/typeshed.py

@@ -1,289 +0,0 @@
-import os
-import re
-from functools import wraps
-
-from jedi.file_io import FileIO
-from jedi._compatibility import FileNotFoundError, cast_path
-from jedi.parser_utils import get_cached_code_lines
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate.gradual.stub_context import TypingModuleWrapper, StubModuleContext
-
-_jedi_path = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-TYPESHED_PATH = os.path.join(_jedi_path, 'third_party', 'typeshed')
-
-_IMPORT_MAP = dict(
-    _collections='collections',
-    _socket='socket',
-)
-
-
-def _merge_create_stub_map(directories):
-    map_ = {}
-    for directory in directories:
-        map_.update(_create_stub_map(directory))
-    return map_
-
-
-def _create_stub_map(directory):
-    """
-    Create a mapping of an importable name in Python to a stub file.
-    """
-    def generate():
-        try:
-            listed = os.listdir(directory)
-        except (FileNotFoundError, OSError):
-            # OSError is Python 2
-            return
-
-        for entry in listed:
-            entry = cast_path(entry)
-            path = os.path.join(directory, entry)
-            if os.path.isdir(path):
-                init = os.path.join(path, '__init__.pyi')
-                if os.path.isfile(init):
-                    yield entry, init
-            elif entry.endswith('.pyi') and os.path.isfile(path):
-                name = entry.rstrip('.pyi')
-                if name != '__init__':
-                    yield name, path
-
-    # Create a dictionary from the tuple generator.
-    return dict(generate())
-
-
-def _get_typeshed_directories(version_info):
-    check_version_list = ['2and3', str(version_info.major)]
-    for base in ['stdlib', 'third_party']:
-        base = os.path.join(TYPESHED_PATH, base)
-        base_list = os.listdir(base)
-        for base_list_entry in base_list:
-            match = re.match(r'(\d+)\.(\d+)$', base_list_entry)
-            if match is not None:
-                if int(match.group(1)) == version_info.major \
-                        and int(match.group(2)) <= version_info.minor:
-                    check_version_list.append(base_list_entry)
-
-        for check_version in check_version_list:
-            yield os.path.join(base, check_version)
-
-
-_version_cache = {}
-
-
-def _cache_stub_file_map(version_info):
-    """
-    Returns a map of an importable name in Python to a stub file.
-    """
-    # TODO this caches the stub files indefinitely, maybe use a time cache
-    # for that?
-    version = version_info[:2]
-    try:
-        return _version_cache[version]
-    except KeyError:
-        pass
-
-    _version_cache[version] = file_set = \
-        _merge_create_stub_map(_get_typeshed_directories(version_info))
-    return file_set
-
-
-def import_module_decorator(func):
-    @wraps(func)
-    def wrapper(evaluator, import_names, parent_module_context, sys_path, prefer_stubs):
-        try:
-            python_context_set = evaluator.module_cache.get(import_names)
-        except KeyError:
-            if parent_module_context is not None and parent_module_context.is_stub():
-                parent_module_contexts = parent_module_context.non_stub_context_set
-            else:
-                parent_module_contexts = [parent_module_context]
-            if import_names == ('os', 'path'):
-                # This is a huge exception, we follow a nested import
-                # ``os.path``, because it's a very important one in Python
-                # that is being achieved by messing with ``sys.modules`` in
-                # ``os``.
-                python_parent = next(iter(parent_module_contexts))
-                if python_parent is None:
-                    python_parent, = evaluator.import_module(('os',), prefer_stubs=False)
-                python_context_set = python_parent.py__getattribute__('path')
-            else:
-                python_context_set = ContextSet.from_sets(
-                    func(evaluator, import_names, p, sys_path,)
-                    for p in parent_module_contexts
-                )
-            evaluator.module_cache.add(import_names, python_context_set)
-
-        if not prefer_stubs:
-            return python_context_set
-
-        stub = _try_to_load_stub_cached(evaluator, import_names, python_context_set,
-                                        parent_module_context, sys_path)
-        if stub is not None:
-            return ContextSet([stub])
-        return python_context_set
-
-    return wrapper
-
-
-def _try_to_load_stub_cached(evaluator, import_names, *args, **kwargs):
-    try:
-        return evaluator.stub_module_cache[import_names]
-    except KeyError:
-        pass
-
-    # TODO is this needed? where are the exceptions coming from that make this
-    # necessary? Just remove this line.
-    evaluator.stub_module_cache[import_names] = None
-    evaluator.stub_module_cache[import_names] = result = \
-        _try_to_load_stub(evaluator, import_names, *args, **kwargs)
-    return result
-
-
-def _try_to_load_stub(evaluator, import_names, python_context_set,
-                      parent_module_context, sys_path):
-    """
-    Trying to load a stub for a set of import_names.
-
-    This is modelled to work like "PEP 561 -- Distributing and Packaging Type
-    Information", see https://www.python.org/dev/peps/pep-0561.
-    """
-    if parent_module_context is None and len(import_names) > 1:
-        try:
-            parent_module_context = _try_to_load_stub_cached(
-                evaluator, import_names[:-1], NO_CONTEXTS,
-                parent_module_context=None, sys_path=sys_path)
-        except KeyError:
-            pass
-
-    # 1. Try to load foo-stubs folders on path for import name foo.
-    if len(import_names) == 1:
-        # foo-stubs
-        for p in sys_path:
-            init = os.path.join(p, *import_names) + '-stubs' + os.path.sep + '__init__.pyi'
-            m = _try_to_load_stub_from_file(
-                evaluator,
-                python_context_set,
-                file_io=FileIO(init),
-                import_names=import_names,
-            )
-            if m is not None:
-                return m
-
-    # 2. Try to load pyi files next to py files.
-    for c in python_context_set:
-        try:
-            method = c.py__file__
-        except AttributeError:
-            pass
-        else:
-            file_path = method()
-            file_paths = []
-            if c.is_namespace():
-                file_paths = [os.path.join(p, '__init__.pyi') for p in c.py__path__()]
-            elif file_path is not None and file_path.endswith('.py'):
-                file_paths = [file_path + 'i']
-
-            for file_path in file_paths:
-                m = _try_to_load_stub_from_file(
-                    evaluator,
-                    python_context_set,
-                    # The file path should end with .pyi
-                    file_io=FileIO(file_path),
-                    import_names=import_names,
-                )
-                if m is not None:
-                    return m
-
-    # 3. Try to load typeshed
-    m = _load_from_typeshed(evaluator, python_context_set, parent_module_context, import_names)
-    if m is not None:
-        return m
-
-    # 4. Try to load pyi file somewhere if python_context_set was not defined.
-    if not python_context_set:
-        if parent_module_context is not None:
-            try:
-                method = parent_module_context.py__path__
-            except AttributeError:
-                check_path = []
-            else:
-                check_path = method()
-            # In case import_names
-            names_for_path = (import_names[-1],)
-        else:
-            check_path = sys_path
-            names_for_path = import_names
-
-        for p in check_path:
-            m = _try_to_load_stub_from_file(
-                evaluator,
-                python_context_set,
-                file_io=FileIO(os.path.join(p, *names_for_path) + '.pyi'),
-                import_names=import_names,
-            )
-            if m is not None:
-                return m
-
-    # If no stub is found, that's fine, the calling function has to deal with
-    # it.
-    return None
-
-
-def _load_from_typeshed(evaluator, python_context_set, parent_module_context, import_names):
-    import_name = import_names[-1]
-    map_ = None
-    if len(import_names) == 1:
-        map_ = _cache_stub_file_map(evaluator.grammar.version_info)
-        import_name = _IMPORT_MAP.get(import_name, import_name)
-    elif isinstance(parent_module_context, StubModuleContext):
-        if not parent_module_context.is_package:
-            # Only if it's a package (= a folder) something can be
-            # imported.
-            return None
-        path = parent_module_context.py__path__()
-        map_ = _merge_create_stub_map(path)
-
-    if map_ is not None:
-        path = map_.get(import_name)
-        if path is not None:
-            return _try_to_load_stub_from_file(
-                evaluator,
-                python_context_set,
-                file_io=FileIO(path),
-                import_names=import_names,
-            )
-
-
-def _try_to_load_stub_from_file(evaluator, python_context_set, file_io, import_names):
-    try:
-        stub_module_node = evaluator.parse(
-            file_io=file_io,
-            cache=True,
-            use_latest_grammar=True
-        )
-    except (OSError, IOError):  # IOError is Python 2 only
-        # The file that you're looking for doesn't exist (anymore).
-        return None
-    else:
-        return create_stub_module(
-            evaluator, python_context_set, stub_module_node, file_io,
-            import_names
-        )
-
-
-def create_stub_module(evaluator, python_context_set, stub_module_node, file_io, import_names):
-    if import_names == ('typing',):
-        module_cls = TypingModuleWrapper
-    else:
-        module_cls = StubModuleContext
-    file_name = os.path.basename(file_io.path)
-    stub_module_context = module_cls(
-        python_context_set, evaluator, stub_module_node,
-        file_io=file_io,
-        string_names=import_names,
-        # The code was loaded with latest_grammar, so use
-        # that.
-        code_lines=get_cached_code_lines(evaluator.latest_grammar, file_io.path),
-        is_package=file_name == '__init__.pyi',
-    )
-    return stub_module_context

jedi/evaluate/gradual/typing.py

@@ -1,707 +0,0 @@
-"""
-We need to somehow work with the typing objects. Since the typing objects are
-pretty bare we need to add all the Jedi customizations to make them work as
-contexts.
-
-This file deals with all the typing.py cases.
-"""
-from jedi._compatibility import unicode, force_unicode
-from jedi import debug
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.compiled import builtin_from_name
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, Context, \
-    iterator_to_context_set, ContextWrapper, LazyContextWrapper
-from jedi.evaluate.lazy_context import LazyKnownContexts
-from jedi.evaluate.context.iterable import SequenceLiteralContext
-from jedi.evaluate.arguments import repack_with_argument_clinic
-from jedi.evaluate.utils import to_list
-from jedi.evaluate.filters import FilterWrapper
-from jedi.evaluate.names import NameWrapper, AbstractTreeName, \
-    AbstractNameDefinition, ContextName
-from jedi.evaluate.helpers import is_string
-from jedi.evaluate.context.klass import ClassMixin, ClassFilter
-
-_PROXY_CLASS_TYPES = 'Tuple Generic Protocol Callable Type'.split()
-_TYPE_ALIAS_TYPES = {
-    'List': 'builtins.list',
-    'Dict': 'builtins.dict',
-    'Set': 'builtins.set',
-    'FrozenSet': 'builtins.frozenset',
-    'ChainMap': 'collections.ChainMap',
-    'Counter': 'collections.Counter',
-    'DefaultDict': 'collections.defaultdict',
-    'Deque': 'collections.deque',
-}
-_PROXY_TYPES = 'Optional Union ClassVar'.split()
-
-
-class TypingName(AbstractTreeName):
-    def __init__(self, context, other_name):
-        super(TypingName, self).__init__(context.parent_context, other_name.tree_name)
-        self._context = context
-
-    def infer(self):
-        return ContextSet([self._context])
-
-
-class _BaseTypingContext(Context):
-    def __init__(self, evaluator, parent_context, tree_name):
-        super(_BaseTypingContext, self).__init__(evaluator, parent_context)
-        self._tree_name = tree_name
-
-    @property
-    def tree_node(self):
-        return self._tree_name
-
-    def get_filters(self, *args, **kwargs):
-        # TODO this is obviously wrong. Is it though?
-        class EmptyFilter(ClassFilter):
-            def __init__(self):
-                pass
-
-            def get(self, name, **kwargs):
-                return []
-
-            def values(self, **kwargs):
-                return []
-
-        yield EmptyFilter()
-
-    def py__class__(self):
-        # TODO this is obviously not correct, but at least gives us a class if
-        # we have none. Some of these objects don't really have a base class in
-        # typeshed.
-        return builtin_from_name(self.evaluator, u'object')
-
-    @property
-    def name(self):
-        return ContextName(self, self._tree_name)
-
-    def __repr__(self):
-        return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)
-
-
-class TypingModuleName(NameWrapper):
-    def infer(self):
-        return ContextSet(self._remap())
-
-    def _remap(self):
-        name = self.string_name
-        evaluator = self.parent_context.evaluator
-        try:
-            actual = _TYPE_ALIAS_TYPES[name]
-        except KeyError:
-            pass
-        else:
-            yield TypeAlias.create_cached(evaluator, self.parent_context, self.tree_name, actual)
-            return
-
-        if name in _PROXY_CLASS_TYPES:
-            yield TypingClassContext.create_cached(evaluator, self.parent_context, self.tree_name)
-        elif name in _PROXY_TYPES:
-            yield TypingContext.create_cached(evaluator, self.parent_context, self.tree_name)
-        elif name == 'runtime':
-            # We don't want anything here, not sure what this function is
-            # supposed to do, since it just appears in the stubs and shouldn't
-            # have any effects there (because it's never executed).
-            return
-        elif name == 'TypeVar':
-            yield TypeVarClass.create_cached(evaluator, self.parent_context, self.tree_name)
-        elif name == 'Any':
-            yield Any.create_cached(evaluator, self.parent_context, self.tree_name)
-        elif name == 'TYPE_CHECKING':
-            # This is needed for e.g. imports that are only available for type
-            # checking or are in cycles. The user can then check this variable.
-            yield builtin_from_name(evaluator, u'True')
-        elif name == 'overload':
-            yield OverloadFunction.create_cached(evaluator, self.parent_context, self.tree_name)
-        elif name == 'NewType':
-            yield NewTypeFunction.create_cached(evaluator, self.parent_context, self.tree_name)
-        elif name == 'cast':
-            # TODO implement cast
-            yield CastFunction.create_cached(evaluator, self.parent_context, self.tree_name)
-        elif name == 'TypedDict':
-            # TODO doesn't even exist in typeshed/typing.py, yet. But will be
-            # added soon.
-            pass
-        elif name in ('no_type_check', 'no_type_check_decorator'):
-            # This is not necessary, as long as we are not doing type checking.
-            for c in self._wrapped_name.infer():  # Fuck my life Python 2
-                yield c
-        else:
-            # Everything else shouldn't be relevant for type checking.
-            for c in self._wrapped_name.infer():  # Fuck my life Python 2
-                yield c
-
-
-class TypingModuleFilterWrapper(FilterWrapper):
-    name_wrapper_class = TypingModuleName
-
-
-class _WithIndexBase(_BaseTypingContext):
-    def __init__(self, evaluator, parent_context, name, index_context, context_of_index):
-        super(_WithIndexBase, self).__init__(evaluator, parent_context, name)
-        self._index_context = index_context
-        self._context_of_index = context_of_index
-
-    def __repr__(self):
-        return '<%s: %s[%s]>' % (
-            self.__class__.__name__,
-            self._tree_name.value,
-            self._index_context,
-        )
-
-
-class TypingContextWithIndex(_WithIndexBase):
-    def execute_annotation(self):
-        string_name = self._tree_name.value
-
-        if string_name == 'Union':
-            # This is kind of a special case, because we have Unions (in Jedi
-            # ContextSets).
-            return self.gather_annotation_classes().execute_annotation()
-        elif string_name == 'Optional':
-            # Optional is basically just saying it's either None or the actual
-            # type.
-            return self.gather_annotation_classes().execute_annotation() \
-                | ContextSet([builtin_from_name(self.evaluator, u'None')])
-        elif string_name == 'Type':
-            # The type is actually already given in the index_context
-            return ContextSet([self._index_context])
-        elif string_name == 'ClassVar':
-            # For now don't do anything here, ClassVars are always used.
-            return self._index_context.execute_annotation()
-
-        cls = globals()[string_name]
-        return ContextSet([cls(
-            self.evaluator,
-            self.parent_context,
-            self._tree_name,
-            self._index_context,
-            self._context_of_index
-        )])
-
-    def gather_annotation_classes(self):
-        return ContextSet.from_sets(
-            _iter_over_arguments(self._index_context, self._context_of_index)
-        )
-
-
-class TypingContext(_BaseTypingContext):
-    index_class = TypingContextWithIndex
-    py__simple_getitem__ = None
-
-    def py__getitem__(self, index_context_set, contextualized_node):
-        return ContextSet(
-            self.index_class.create_cached(
-                self.evaluator,
-                self.parent_context,
-                self._tree_name,
-                index_context,
-                context_of_index=contextualized_node.context)
-            for index_context in index_context_set
-        )
-
-
-class _TypingClassMixin(object):
-    def py__bases__(self):
-        return [LazyKnownContexts(
-            self.evaluator.builtins_module.py__getattribute__('object')
-        )]
-
-    def get_metaclasses(self):
-        return []
-
-
-class TypingClassContextWithIndex(_TypingClassMixin, TypingContextWithIndex, ClassMixin):
-    pass
-
-
-class TypingClassContext(_TypingClassMixin, TypingContext, ClassMixin):
-    index_class = TypingClassContextWithIndex
-
-
-def _iter_over_arguments(maybe_tuple_context, defining_context):
-    def iterate():
-        if isinstance(maybe_tuple_context, SequenceLiteralContext):
-            for lazy_context in maybe_tuple_context.py__iter__(contextualized_node=None):
-                yield lazy_context.infer()
-        else:
-            yield ContextSet([maybe_tuple_context])
-
-    def resolve_forward_references(context_set):
-        for context in context_set:
-            if is_string(context):
-                from jedi.evaluate.gradual.annotation import _get_forward_reference_node
-                node = _get_forward_reference_node(defining_context, context.get_safe_value())
-                if node is not None:
-                    for c in defining_context.eval_node(node):
-                        yield c
-            else:
-                yield context
-
-    for context_set in iterate():
-        yield ContextSet(resolve_forward_references(context_set))
-
-
-class TypeAlias(LazyContextWrapper):
-    def __init__(self, parent_context, origin_tree_name, actual):
-        self.evaluator = parent_context.evaluator
-        self.parent_context = parent_context
-        self._origin_tree_name = origin_tree_name
-        self._actual = actual  # e.g. builtins.list
-
-    @property
-    def name(self):
-        return ContextName(self, self._origin_tree_name)
-
-    def py__name__(self):
-        return self.name.string_name
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self._actual)
-
-    def _get_wrapped_context(self):
-        module_name, class_name = self._actual.split('.')
-        if self.evaluator.environment.version_info.major == 2 and module_name == 'builtins':
-            module_name = '__builtin__'
-
-        # TODO use evaluator.import_module?
-        from jedi.evaluate.imports import Importer
-        module, = Importer(
-            self.evaluator, [module_name], self.evaluator.builtins_module
-        ).follow()
-        classes = module.py__getattribute__(class_name)
-        # There should only be one, because it's code that we control.
-        assert len(classes) == 1, classes
-        cls = next(iter(classes))
-        return cls
-
-
-class _ContainerBase(_WithIndexBase):
-    def _get_getitem_contexts(self, index):
-        args = _iter_over_arguments(self._index_context, self._context_of_index)
-        for i, contexts in enumerate(args):
-            if i == index:
-                return contexts
-
-        debug.warning('No param #%s found for annotation %s', index, self._index_context)
-        return NO_CONTEXTS
-
-
-class Callable(_ContainerBase):
-    def py__call__(self, arguments):
-        # The 0th index are the arguments.
-        return self._get_getitem_contexts(1).execute_annotation()
-
-
-class Tuple(_ContainerBase):
-    def _is_homogenous(self):
-        # To specify a variable-length tuple of homogeneous type, Tuple[T, ...]
-        # is used.
-        if isinstance(self._index_context, SequenceLiteralContext):
-            entries = self._index_context.get_tree_entries()
-            if len(entries) == 2 and entries[1] == '...':
-                return True
-        return False
-
-    def py__simple_getitem__(self, index):
-        if self._is_homogenous():
-            return self._get_getitem_contexts(0).execute_annotation()
-        else:
-            if isinstance(index, int):
-                return self._get_getitem_contexts(index).execute_annotation()
-
-            debug.dbg('The getitem type on Tuple was %s' % index)
-            return NO_CONTEXTS
-
-    def py__iter__(self, contextualized_node=None):
-        if self._is_homogenous():
-            yield LazyKnownContexts(self._get_getitem_contexts(0).execute_annotation())
-        else:
-            if isinstance(self._index_context, SequenceLiteralContext):
-                for i in range(self._index_context.py__len__()):
-                    yield LazyKnownContexts(self._get_getitem_contexts(i).execute_annotation())
-
-    def py__getitem__(self, index_context_set, contextualized_node):
-        if self._is_homogenous():
-            return self._get_getitem_contexts(0).execute_annotation()
-
-        return ContextSet.from_sets(
-            _iter_over_arguments(self._index_context, self._context_of_index)
-        ).execute_annotation()
-
-
-class Generic(_ContainerBase):
-    pass
-
-
-class Protocol(_ContainerBase):
-    pass
-
-
-class Any(_BaseTypingContext):
-    def execute_annotation(self):
-        debug.warning('Used Any - returned no results')
-        return NO_CONTEXTS
-
-
-class TypeVarClass(_BaseTypingContext):
-    def py__call__(self, arguments):
-        unpacked = arguments.unpack()
-
-        key, lazy_context = next(unpacked, (None, None))
-        var_name = self._find_string_name(lazy_context)
-        # The name must be given, otherwise it's useless.
-        if var_name is None or key is not None:
-            debug.warning('Found a variable without a name %s', arguments)
-            return NO_CONTEXTS
-
-        return ContextSet([TypeVar.create_cached(
-            self.evaluator,
-            self.parent_context,
-            self._tree_name,
-            var_name,
-            unpacked
-        )])
-
-    def _find_string_name(self, lazy_context):
-        if lazy_context is None:
-            return None
-
-        context_set = lazy_context.infer()
-        if not context_set:
-            return None
-        if len(context_set) > 1:
-            debug.warning('Found multiple contexts for a type variable: %s', context_set)
-
-        name_context = next(iter(context_set))
-        try:
-            method = name_context.get_safe_value
-        except AttributeError:
-            return None
-        else:
-            safe_value = method(default=None)
-            if self.evaluator.environment.version_info.major == 2:
-                if isinstance(safe_value, bytes):
-                    return force_unicode(safe_value)
-            if isinstance(safe_value, (str, unicode)):
-                return safe_value
-            return None
-
-
-class TypeVar(_BaseTypingContext):
-    def __init__(self, evaluator, parent_context, tree_name, var_name, unpacked_args):
-        super(TypeVar, self).__init__(evaluator, parent_context, tree_name)
-        self._var_name = var_name
-
-        self._constraints_lazy_contexts = []
-        self._bound_lazy_context = None
-        self._covariant_lazy_context = None
-        self._contravariant_lazy_context = None
-        for key, lazy_context in unpacked_args:
-            if key is None:
-                self._constraints_lazy_contexts.append(lazy_context)
-            else:
-                if key == 'bound':
-                    self._bound_lazy_context = lazy_context
-                elif key == 'covariant':
-                    self._covariant_lazy_context = lazy_context
-                elif key == 'contravariant':
-                    self._contra_variant_lazy_context = lazy_context
-                else:
-                    debug.warning('Invalid TypeVar param name %s', key)
-
-    def py__name__(self):
-        return self._var_name
-
-    def get_filters(self, *args, **kwargs):
-        return iter([])
-
-    def _get_classes(self):
-        if self._bound_lazy_context is not None:
-            return self._bound_lazy_context.infer()
-        if self._constraints_lazy_contexts:
-            return self.constraints
-        debug.warning('Tried to infer the TypeVar %s without a given type', self._var_name)
-        return NO_CONTEXTS
-
-    def is_same_class(self, other):
-        # Everything can match an undefined type var.
-        return True
-
-    @property
-    def constraints(self):
-        return ContextSet.from_sets(
-            lazy.infer() for lazy in self._constraints_lazy_contexts
-        )
-
-    def define_generics(self, type_var_dict):
-        try:
-            found = type_var_dict[self.py__name__()]
-        except KeyError:
-            pass
-        else:
-            if found:
-                return found
-        return self._get_classes() or ContextSet({self})
-
-    def execute_annotation(self):
-        return self._get_classes().execute_annotation()
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self.py__name__())
-
-
-class OverloadFunction(_BaseTypingContext):
-    @repack_with_argument_clinic('func, /')
-    def py__call__(self, func_context_set):
-        # Just pass arguments through.
-        return func_context_set
-
-
-class NewTypeFunction(_BaseTypingContext):
-    def py__call__(self, arguments):
-        ordered_args = arguments.unpack()
-        next(ordered_args, (None, None))
-        _, second_arg = next(ordered_args, (None, None))
-        if second_arg is None:
-            return NO_CONTEXTS
-        return ContextSet(
-            NewType(
-                self.evaluator,
-                contextualized_node.context,
-                contextualized_node.node,
-                second_arg.infer(),
-            ) for contextualized_node in arguments.get_calling_nodes())
-
-
-class NewType(Context):
-    def __init__(self, evaluator, parent_context, tree_node, type_context_set):
-        super(NewType, self).__init__(evaluator, parent_context)
-        self._type_context_set = type_context_set
-        self.tree_node = tree_node
-
-    def py__call__(self, arguments):
-        return self._type_context_set.execute_annotation()
-
-
-class CastFunction(_BaseTypingContext):
-    @repack_with_argument_clinic('type, object, /')
-    def py__call__(self, type_context_set, object_context_set):
-        return type_context_set.execute_annotation()
-
-
-class BoundTypeVarName(AbstractNameDefinition):
-    """
-    This type var was bound to a certain type, e.g. int.
-    """
-    def __init__(self, type_var, context_set):
-        self._type_var = type_var
-        self.parent_context = type_var.parent_context
-        self._context_set = context_set
-
-    def infer(self):
-        def iter_():
-            for context in self._context_set:
-                # Replace any with the constraints if they are there.
-                if isinstance(context, Any):
-                    for constraint in self._type_var.constraints:
-                        yield constraint
-                else:
-                    yield context
-        return ContextSet(iter_())
-
-    def py__name__(self):
-        return self._type_var.py__name__()
-
-    def __repr__(self):
-        return '<%s %s -> %s>' % (self.__class__.__name__, self.py__name__(), self._context_set)
-
-
-class TypeVarFilter(object):
-    """
-    A filter for all given variables in a class.
-
-        A = TypeVar('A')
-        B = TypeVar('B')
-        class Foo(Mapping[A, B]):
-            ...
-
-    In this example we would have two type vars given: A and B
-    """
-    def __init__(self, generics, type_vars):
-        self._generics = generics
-        self._type_vars = type_vars
-
-    def get(self, name):
-        for i, type_var in enumerate(self._type_vars):
-            if type_var.py__name__() == name:
-                try:
-                    return [BoundTypeVarName(type_var, self._generics[i])]
-                except IndexError:
-                    return [type_var.name]
-        return []
-
-    def values(self):
-        # The values are not relevant. If it's not searched exactly, the type
-        # vars are just global and should be looked up as that.
-        return []
-
-
-class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
-    def get_type_var_filter(self):
-        return TypeVarFilter(self.get_generics(), self.list_type_vars())
-
-    def get_filters(self, search_global=False, *args, **kwargs):
-        filters = super(AbstractAnnotatedClass, self).get_filters(
-            search_global,
-            *args, **kwargs
-        )
-        for f in filters:
-            yield f
-
-        if search_global:
-            # The type vars can only be looked up if it's a global search and
-            # not a direct lookup on the class.
-            yield self.get_type_var_filter()
-
-    def is_same_class(self, other):
-        if not isinstance(other, AbstractAnnotatedClass):
-            return False
-
-        if self.tree_node != other.tree_node:
-            # TODO not sure if this is nice.
-            return False
-        given_params1 = self.get_generics()
-        given_params2 = other.get_generics()
-
-        if len(given_params1) != len(given_params2):
-            # If the amount of type vars doesn't match, the class doesn't
-            # match.
-            return False
-
-        # Now compare generics
-        return all(
-            any(
-                # TODO why is this ordering the correct one?
-                cls2.is_same_class(cls1)
-                for cls1 in class_set1
-                for cls2 in class_set2
-            ) for class_set1, class_set2 in zip(given_params1, given_params2)
-        )
-
-    def py__call__(self, arguments):
-        instance, = super(AbstractAnnotatedClass, self).py__call__(arguments)
-        return ContextSet([InstanceWrapper(instance)])
-
-    def get_generics(self):
-        raise NotImplementedError
-
-    def define_generics(self, type_var_dict):
-        changed = False
-        new_generics = []
-        for generic_set in self.get_generics():
-            contexts = NO_CONTEXTS
-            for generic in generic_set:
-                if isinstance(generic, (AbstractAnnotatedClass, TypeVar)):
-                    result = generic.define_generics(type_var_dict)
-                    contexts |= result
-                    if result != ContextSet({generic}):
-                        changed = True
-                else:
-                    contexts |= ContextSet([generic])
-            new_generics.append(contexts)
-
-        if not changed:
-            # There might not be any type vars that change. In that case just
-            # return itself, because it does not make sense to potentially lose
-            # cached results.
-            return ContextSet([self])
-
-        return ContextSet([GenericClass(
-            self._wrapped_context,
-            generics=tuple(new_generics)
-        )])
-
-    def __repr__(self):
-        return '<%s: %s%s>' % (
-            self.__class__.__name__,
-            self._wrapped_context,
-            list(self.get_generics()),
-        )
-
-    @to_list
-    def py__bases__(self):
-        for base in self._wrapped_context.py__bases__():
-            yield LazyAnnotatedBaseClass(self, base)
-
-
-class LazyGenericClass(AbstractAnnotatedClass):
-    def __init__(self, class_context, index_context, context_of_index):
-        super(LazyGenericClass, self).__init__(class_context)
-        self._index_context = index_context
-        self._context_of_index = context_of_index
-
-    @evaluator_method_cache()
-    def get_generics(self):
-        return list(_iter_over_arguments(self._index_context, self._context_of_index))
-
-
-class GenericClass(AbstractAnnotatedClass):
-    def __init__(self, class_context, generics):
-        super(GenericClass, self).__init__(class_context)
-        self._generics = generics
-
-    def get_generics(self):
-        return self._generics
-
-
-class LazyAnnotatedBaseClass(object):
-    def __init__(self, class_context, lazy_base_class):
-        self._class_context = class_context
-        self._lazy_base_class = lazy_base_class
-
-    @iterator_to_context_set
-    def infer(self):
-        for base in self._lazy_base_class.infer():
-            if isinstance(base, AbstractAnnotatedClass):
-                # Here we have to recalculate the given types.
-                yield GenericClass.create_cached(
-                    base.evaluator,
-                    base._wrapped_context,
-                    tuple(self._remap_type_vars(base)),
-                )
-            else:
-                yield base
-
-    def _remap_type_vars(self, base):
-        filter = self._class_context.get_type_var_filter()
-        for type_var_set in base.get_generics():
-            new = NO_CONTEXTS
-            for type_var in type_var_set:
-                if isinstance(type_var, TypeVar):
-                    names = filter.get(type_var.py__name__())
-                    new |= ContextSet.from_sets(
-                        name.infer() for name in names
-                    )
-                else:
-                    # Mostly will be type vars, except if in some cases
-                    # a concrete type will already be there. In that
-                    # case just add it to the context set.
-                    new |= ContextSet([type_var])
-            yield new
-
-
-class InstanceWrapper(ContextWrapper):
-    def py__stop_iteration_returns(self):
-        for cls in self._wrapped_context.class_context.py__mro__():
-            if cls.py__name__() == 'Generator':
-                generics = cls.get_generics()
-                try:
-                    return generics[2].execute_annotation()
-                except IndexError:
-                    pass
-            elif cls.py__name__() == 'Iterator':
-                return ContextSet([builtin_from_name(self.evaluator, u'None')])
-        return self._wrapped_context.py__stop_iteration_returns()

jedi/evaluate/gradual/utils.py

@@ -1,32 +0,0 @@
-import os
-
-from jedi.evaluate.gradual.typeshed import TYPESHED_PATH, create_stub_module
-
-
-def load_proper_stub_module(evaluator, file_io, import_names, module_node):
-    """
-    This function is given a random .pyi file and should return the proper
-    module.
-    """
-    path = file_io.path
-    assert path.endswith('.pyi')
-    if path.startswith(TYPESHED_PATH):
-        # /foo/stdlib/3/os/__init__.pyi -> stdlib/3/os/__init__
-        rest = path[len(TYPESHED_PATH) + 1: -4]
-        split_paths = tuple(rest.split(os.path.sep))
-        # Remove the stdlib/3 or third_party/3.5 part
-        import_names = split_paths[2:]
-        if import_names[-1] == '__init__':
-            import_names = import_names[:-1]
-
-    if import_names is not None:
-        actual_context_set = evaluator.import_module(import_names, prefer_stubs=False)
-        if not actual_context_set:
-            return None
-
-        stub = create_stub_module(
-            evaluator, actual_context_set, module_node, file_io, import_names
-        )
-        evaluator.stub_module_cache[import_names] = stub
-        return stub
-    return None

jedi/evaluate/helpers.py

@@ -1,269 +0,0 @@
-import copy
-import sys
-import re
-import os
-from itertools import chain
-from contextlib import contextmanager
-
-from parso.python import tree
-
-from jedi._compatibility import unicode
-from jedi.parser_utils import get_parent_scope
-
-
-def is_stdlib_path(path):
-    # Python standard library paths look like this:
-    # /usr/lib/python3.5/...
-    # TODO The implementation below is probably incorrect and not complete.
-    if 'dist-packages' in path or 'site-packages' in path:
-        return False
-
-    base_path = os.path.join(sys.prefix, 'lib', 'python')
-    return bool(re.match(re.escape(base_path) + r'\d.\d', path))
-
-
-def deep_ast_copy(obj):
-    """
-    Much, much faster than copy.deepcopy, but just for parser tree nodes.
-    """
-    # If it's already in the cache, just return it.
-    new_obj = copy.copy(obj)
-
-    # Copy children
-    new_children = []
-    for child in obj.children:
-        if isinstance(child, tree.Leaf):
-            new_child = copy.copy(child)
-            new_child.parent = new_obj
-        else:
-            new_child = deep_ast_copy(child)
-            new_child.parent = new_obj
-        new_children.append(new_child)
-    new_obj.children = new_children
-
-    return new_obj
-
-
-def evaluate_call_of_leaf(context, leaf, cut_own_trailer=False):
-    """
-    Creates a "call" node that consist of all ``trailer`` and ``power``
-    objects.  E.g. if you call it with ``append``::
-
-        list([]).append(3) or None
-
-    You would get a node with the content ``list([]).append`` back.
-
-    This generates a copy of the original ast node.
-
-    If you're using the leaf, e.g. the bracket `)` it will return ``list([])``.
-
-    We use this function for two purposes. Given an expression ``bar.foo``,
-    we may want to
-      - infer the type of ``foo`` to offer completions after foo
-      - infer the type of ``bar`` to be able to jump to the definition of foo
-    The option ``cut_own_trailer`` must be set to true for the second purpose.
-    """
-    trailer = leaf.parent
-    if trailer.type == 'fstring':
-        from jedi.evaluate import compiled
-        return compiled.get_string_context_set(context.evaluator)
-
-    # The leaf may not be the last or first child, because there exist three
-    # different trailers: `( x )`, `[ x ]` and `.x`. In the first two examples
-    # we should not match anything more than x.
-    if trailer.type != 'trailer' or leaf not in (trailer.children[0], trailer.children[-1]):
-        if trailer.type == 'atom':
-            return context.eval_node(trailer)
-        return context.eval_node(leaf)
-
-    power = trailer.parent
-    index = power.children.index(trailer)
-    if cut_own_trailer:
-        cut = index
-    else:
-        cut = index + 1
-
-    if power.type == 'error_node':
-        start = index
-        while True:
-            start -= 1
-            base = power.children[start]
-            if base.type != 'trailer':
-                break
-        trailers = power.children[start + 1: index + 1]
-    else:
-        base = power.children[0]
-        trailers = power.children[1:cut]
-
-    if base == 'await':
-        base = trailers[0]
-        trailers = trailers[1:]
-
-    values = context.eval_node(base)
-    from jedi.evaluate.syntax_tree import eval_trailer
-    for trailer in trailers:
-        values = eval_trailer(context, values, trailer)
-    return values
-
-
-def call_of_leaf(leaf):
-    """
-    Creates a "call" node that consist of all ``trailer`` and ``power``
-    objects.  E.g. if you call it with ``append``::
-
-        list([]).append(3) or None
-
-    You would get a node with the content ``list([]).append`` back.
-
-    This generates a copy of the original ast node.
-
-    If you're using the leaf, e.g. the bracket `)` it will return ``list([])``.
-    """
-    # TODO this is the old version of this call. Try to remove it.
-    trailer = leaf.parent
-    # The leaf may not be the last or first child, because there exist three
-    # different trailers: `( x )`, `[ x ]` and `.x`. In the first two examples
-    # we should not match anything more than x.
-    if trailer.type != 'trailer' or leaf not in (trailer.children[0], trailer.children[-1]):
-        if trailer.type == 'atom':
-            return trailer
-        return leaf
-
-    power = trailer.parent
-    index = power.children.index(trailer)
-
-    new_power = copy.copy(power)
-    new_power.children = list(new_power.children)
-    new_power.children[index + 1:] = []
-
-    if power.type == 'error_node':
-        start = index
-        while True:
-            start -= 1
-            if power.children[start].type != 'trailer':
-                break
-        transformed = tree.Node('power', power.children[start:])
-        transformed.parent = power.parent
-        return transformed
-
-    return power
-
-
-def get_names_of_node(node):
-    try:
-        children = node.children
-    except AttributeError:
-        if node.type == 'name':
-            return [node]
-        else:
-            return []
-    else:
-        return list(chain.from_iterable(get_names_of_node(c) for c in children))
-
-
-def get_module_names(module, all_scopes):
-    """
-    Returns a dictionary with name parts as keys and their call paths as
-    values.
-    """
-    names = list(chain.from_iterable(module.get_used_names().values()))
-    if not all_scopes:
-        # We have to filter all the names that don't have the module as a
-        # parent_scope. There's None as a parent, because nodes in the module
-        # node have the parent module and not suite as all the others.
-        # Therefore it's important to catch that case.
-
-        def is_module_scope_name(name):
-            parent_scope = get_parent_scope(name)
-            # async functions have an extra wrapper. Strip it.
-            if parent_scope and parent_scope.type == 'async_stmt':
-                parent_scope = parent_scope.parent
-            return parent_scope in (module, None)
-
-        names = [n for n in names if is_module_scope_name(n)]
-    return names
-
-
-@contextmanager
-def predefine_names(context, flow_scope, dct):
-    predefined = context.predefined_names
-    predefined[flow_scope] = dct
-    try:
-        yield
-    finally:
-        del predefined[flow_scope]
-
-
-def is_string(context):
-    if context.evaluator.environment.version_info.major == 2:
-        str_classes = (unicode, bytes)
-    else:
-        str_classes = (unicode,)
-    return context.is_compiled() and isinstance(context.get_safe_value(default=None), str_classes)
-
-
-def is_literal(context):
-    return is_number(context) or is_string(context)
-
-
-def _get_safe_value_or_none(context, accept):
-    value = context.get_safe_value(default=None)
-    if isinstance(value, accept):
-        return value
-
-
-def get_int_or_none(context):
-    return _get_safe_value_or_none(context, int)
-
-
-def get_str_or_none(context):
-    return _get_safe_value_or_none(context, (bytes, unicode))
-
-
-def is_number(context):
-    return _get_safe_value_or_none(context, (int, float)) is not None
-
-
-class SimpleGetItemNotFound(Exception):
-    pass
-
-
-@contextmanager
-def reraise_getitem_errors(*exception_classes):
-    try:
-        yield
-    except exception_classes as e:
-        raise SimpleGetItemNotFound(e)
-
-
-def parse_dotted_names(nodes, is_import_from, until_node=None):
-    level = 0
-    names = []
-    for node in nodes[1:]:
-        if node in ('.', '...'):
-            if not names:
-                level += len(node.value)
-        elif node.type == 'dotted_name':
-            for n in node.children[::2]:
-                names.append(n)
-                if n is until_node:
-                    break
-            else:
-                continue
-            break
-        elif node.type == 'name':
-            names.append(node)
-            if node is until_node:
-                break
-        elif node == ',':
-            if not is_import_from:
-                names = []
-        else:
-            # Here if the keyword `import` comes along it stops checking
-            # for names.
-            break
-    return level, names
-
-
-def contexts_from_qualified_names(evaluator, *names):
-    return evaluator.import_module(names[:-1]).py__getattribute__(names[-1])

jedi/evaluate/imports.py

@@ -1,568 +0,0 @@
-"""
-:mod:`jedi.evaluate.imports` is here to resolve import statements and return
-the modules/classes/functions/whatever, which they stand for. However there's
-not any actual importing done. This module is about finding modules in the
-filesystem. This can be quite tricky sometimes, because Python imports are not
-always that simple.
-
-This module uses imp for python up to 3.2 and importlib for python 3.3 on; the
-correct implementation is delegated to _compatibility.
-
-This module also supports import autocompletion, which means to complete
-statements like ``from datetim`` (cursor at the end would return ``datetime``).
-"""
-import os
-
-from parso.python import tree
-from parso.tree import search_ancestor
-from parso import python_bytes_to_unicode
-
-from jedi._compatibility import (FileNotFoundError, ImplicitNSInfo,
-                                 force_unicode, unicode)
-from jedi import debug
-from jedi import settings
-from jedi.file_io import KnownContentFileIO, FileIO
-from jedi.parser_utils import get_cached_code_lines
-from jedi.evaluate import sys_path
-from jedi.evaluate import helpers
-from jedi.evaluate import compiled
-from jedi.evaluate import analysis
-from jedi.evaluate.utils import unite
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.names import ImportName, SubModuleName
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate.gradual.typeshed import import_module_decorator
-from jedi.evaluate.context.module import iter_module_names
-from jedi.plugins import plugin_manager
-
-
-class ModuleCache(object):
-    def __init__(self):
-        self._path_cache = {}
-        self._name_cache = {}
-
-    def add(self, string_names, context_set):
-        #path = module.py__file__()
-        #self._path_cache[path] = context_set
-        if string_names is not None:
-            self._name_cache[string_names] = context_set
-
-    def get(self, string_names):
-        return self._name_cache[string_names]
-
-    def get_from_path(self, path):
-        return self._path_cache[path]
-
-
-# This memoization is needed, because otherwise we will infinitely loop on
-# certain imports.
-@evaluator_method_cache(default=NO_CONTEXTS)
-def infer_import(context, tree_name, is_goto=False):
-    module_context = context.get_root_context()
-    import_node = search_ancestor(tree_name, 'import_name', 'import_from')
-    import_path = import_node.get_path_for_name(tree_name)
-    from_import_name = None
-    evaluator = context.evaluator
-    try:
-        from_names = import_node.get_from_names()
-    except AttributeError:
-        # Is an import_name
-        pass
-    else:
-        if len(from_names) + 1 == len(import_path):
-            # We have to fetch the from_names part first and then check
-            # if from_names exists in the modules.
-            from_import_name = import_path[-1]
-            import_path = from_names
-
-    importer = Importer(evaluator, tuple(import_path),
-                        module_context, import_node.level)
-
-    types = importer.follow()
-
-    #if import_node.is_nested() and not self.nested_resolve:
-    #    scopes = [NestedImportModule(module, import_node)]
-
-    if not types:
-        return NO_CONTEXTS
-
-    if from_import_name is not None:
-        types = unite(
-            t.py__getattribute__(
-                from_import_name,
-                name_context=context,
-                is_goto=is_goto,
-                analysis_errors=False
-            )
-            for t in types
-        )
-        if not is_goto:
-            types = ContextSet(types)
-
-        if not types:
-            path = import_path + [from_import_name]
-            importer = Importer(evaluator, tuple(path),
-                                module_context, import_node.level)
-            types = importer.follow()
-            # goto only accepts `Name`
-            if is_goto:
-                types = set(s.name for s in types)
-    else:
-        # goto only accepts `Name`
-        if is_goto:
-            types = set(s.name for s in types)
-
-    debug.dbg('after import: %s', types)
-    return types
-
-
-class NestedImportModule(tree.Module):
-    """
-    TODO while there's no use case for nested import module right now, we might
-        be able to use them for static analysis checks later on.
-    """
-    def __init__(self, module, nested_import):
-        self._module = module
-        self._nested_import = nested_import
-
-    def _get_nested_import_name(self):
-        """
-        Generates an Import statement, that can be used to fake nested imports.
-        """
-        i = self._nested_import
-        # This is not an existing Import statement. Therefore, set position to
-        # 0 (0 is not a valid line number).
-        zero = (0, 0)
-        names = [unicode(name) for name in i.namespace_names[1:]]
-        name = helpers.FakeName(names, self._nested_import)
-        new = tree.Import(i._sub_module, zero, zero, name)
-        new.parent = self._module
-        debug.dbg('Generated a nested import: %s', new)
-        return helpers.FakeName(str(i.namespace_names[1]), new)
-
-    def __getattr__(self, name):
-        return getattr(self._module, name)
-
-    def __repr__(self):
-        return "<%s: %s of %s>" % (self.__class__.__name__, self._module,
-                                   self._nested_import)
-
-
-def _add_error(context, name, message):
-    if hasattr(name, 'parent') and context is not None:
-        analysis.add(context, 'import-error', name, message)
-    else:
-        debug.warning('ImportError without origin: ' + message)
-
-
-def _level_to_base_import_path(project_path, directory, level):
-    """
-    In case the level is outside of the currently known package (something like
-    import .....foo), we can still try our best to help the user for
-    completions.
-    """
-    for i in range(level - 1):
-        old = directory
-        directory = os.path.dirname(directory)
-        if old == directory:
-            return None, None
-
-    d = directory
-    level_import_paths = []
-    # Now that we are on the level that the user wants to be, calculate the
-    # import path for it.
-    while True:
-        if d == project_path:
-            return level_import_paths, d
-        dir_name = os.path.basename(d)
-        if dir_name:
-            level_import_paths.insert(0, dir_name)
-            d = os.path.dirname(d)
-        else:
-            return None, directory
-
-
-class Importer(object):
-    def __init__(self, evaluator, import_path, module_context, level=0):
-        """
-        An implementation similar to ``__import__``. Use `follow`
-        to actually follow the imports.
-
-        *level* specifies whether to use absolute or relative imports. 0 (the
-        default) means only perform absolute imports. Positive values for level
-        indicate the number of parent directories to search relative to the
-        directory of the module calling ``__import__()`` (see PEP 328 for the
-        details).
-
-        :param import_path: List of namespaces (strings or Names).
-        """
-        debug.speed('import %s %s' % (import_path, module_context))
-        self._evaluator = evaluator
-        self.level = level
-        self.module_context = module_context
-
-        self._fixed_sys_path = None
-        self._inference_possible = True
-        if level:
-            base = module_context.py__package__()
-            # We need to care for two cases, the first one is if it's a valid
-            # Python import. This import has a properly defined module name
-            # chain like `foo.bar.baz` and an import in baz is made for
-            # `..lala.` It can then resolve to `foo.bar.lala`.
-            # The else here is a heuristic for all other cases, if for example
-            # in `foo` you search for `...bar`, it's obviously out of scope.
-            # However since Jedi tries to just do it's best, we help the user
-            # here, because he might have specified something wrong in his
-            # project.
-            if level <= len(base):
-                # Here we basically rewrite the level to 0.
-                base = tuple(base)
-                if level > 1:
-                    base = base[:-level + 1]
-                import_path = base + tuple(import_path)
-            else:
-                path = module_context.py__file__()
-                import_path = list(import_path)
-                if path is None:
-                    # If no path is defined, our best guess is that the current
-                    # file is edited by a user on the current working
-                    # directory. We need to add an initial path, because it
-                    # will get removed as the name of the current file.
-                    directory = os.getcwd()
-                else:
-                    directory = os.path.dirname(path)
-
-                base_import_path, base_directory = _level_to_base_import_path(
-                    self._evaluator.project._path, directory, level,
-                )
-                if base_directory is None:
-                    # Everything is lost, the relative import does point
-                    # somewhere out of the filesystem.
-                    self._inference_possible = False
-                else:
-                    self._fixed_sys_path = [force_unicode(base_directory)]
-
-                if base_import_path is None:
-                    if import_path:
-                        _add_error(
-                            module_context, import_path[0],
-                            message='Attempted relative import beyond top-level package.'
-                        )
-                else:
-                    import_path = base_import_path + import_path
-        self.import_path = import_path
-
-    @property
-    def _str_import_path(self):
-        """Returns the import path as pure strings instead of `Name`."""
-        return tuple(
-            name.value if isinstance(name, tree.Name) else name
-            for name in self.import_path
-        )
-
-    def _sys_path_with_modifications(self):
-        if self._fixed_sys_path is not None:
-            return self._fixed_sys_path
-
-        sys_path_mod = (
-            self._evaluator.get_sys_path()
-            + sys_path.check_sys_path_modifications(self.module_context)
-        )
-
-        if self._evaluator.environment.version_info.major == 2:
-            file_path = self.module_context.py__file__()
-            if file_path is not None:
-                # Python2 uses an old strange way of importing relative imports.
-                sys_path_mod.append(force_unicode(os.path.dirname(file_path)))
-
-        return sys_path_mod
-
-    def follow(self):
-        if not self.import_path or not self._inference_possible:
-            return NO_CONTEXTS
-
-        import_names = tuple(
-            force_unicode(i.value if isinstance(i, tree.Name) else i)
-            for i in self.import_path
-        )
-        sys_path = self._sys_path_with_modifications()
-
-        context_set = [None]
-        for i, name in enumerate(self.import_path):
-            context_set = ContextSet.from_sets([
-                self._evaluator.import_module(
-                    import_names[:i+1],
-                    parent_module_context,
-                    sys_path
-                ) for parent_module_context in context_set
-            ])
-            if not context_set:
-                message = 'No module named ' + '.'.join(import_names)
-                _add_error(self.module_context, name, message)
-                return NO_CONTEXTS
-        return context_set
-
-    def _get_module_names(self, search_path=None, in_module=None):
-        """
-        Get the names of all modules in the search_path. This means file names
-        and not names defined in the files.
-        """
-        names = []
-        # add builtin module names
-        if search_path is None and in_module is None:
-            names += [ImportName(self.module_context, name)
-                      for name in self._evaluator.compiled_subprocess.get_builtin_module_names()]
-
-        if search_path is None:
-            search_path = self._sys_path_with_modifications()
-
-        for name in iter_module_names(self._evaluator, search_path):
-            if in_module is None:
-                n = ImportName(self.module_context, name)
-            else:
-                n = SubModuleName(in_module, name)
-            names.append(n)
-        return names
-
-    def completion_names(self, evaluator, only_modules=False):
-        """
-        :param only_modules: Indicates wheter it's possible to import a
-            definition that is not defined in a module.
-        """
-        if not self._inference_possible:
-            return []
-
-        names = []
-        if self.import_path:
-            # flask
-            if self._str_import_path == ('flask', 'ext'):
-                # List Flask extensions like ``flask_foo``
-                for mod in self._get_module_names():
-                    modname = mod.string_name
-                    if modname.startswith('flask_'):
-                        extname = modname[len('flask_'):]
-                        names.append(ImportName(self.module_context, extname))
-                # Now the old style: ``flaskext.foo``
-                for dir in self._sys_path_with_modifications():
-                    flaskext = os.path.join(dir, 'flaskext')
-                    if os.path.isdir(flaskext):
-                        names += self._get_module_names([flaskext])
-
-            contexts = self.follow()
-            for context in contexts:
-                # Non-modules are not completable.
-                if context.api_type != 'module':  # not a module
-                    continue
-                names += context.sub_modules_dict().values()
-
-            if not only_modules:
-                from jedi.evaluate.gradual.conversion import convert_contexts
-
-                both_contexts = contexts | convert_contexts(contexts)
-                for c in both_contexts:
-                    for filter in c.get_filters(search_global=False):
-                        names += filter.values()
-        else:
-            if self.level:
-                # We only get here if the level cannot be properly calculated.
-                names += self._get_module_names(self._fixed_sys_path)
-            else:
-                # This is just the list of global imports.
-                names += self._get_module_names()
-        return names
-
-
-@plugin_manager.decorate()
-@import_module_decorator
-def import_module(evaluator, import_names, parent_module_context, sys_path):
-    """
-    This method is very similar to importlib's `_gcd_import`.
-    """
-    if import_names[0] in settings.auto_import_modules:
-        module = _load_builtin_module(evaluator, import_names, sys_path)
-        if module is None:
-            return NO_CONTEXTS
-        return ContextSet([module])
-
-    module_name = '.'.join(import_names)
-    if parent_module_context is None:
-        # Override the sys.path. It works only good that way.
-        # Injecting the path directly into `find_module` did not work.
-        file_io_or_ns, is_pkg = evaluator.compiled_subprocess.get_module_info(
-            string=import_names[-1],
-            full_name=module_name,
-            sys_path=sys_path,
-            is_global_search=True,
-        )
-        if is_pkg is None:
-            return NO_CONTEXTS
-    else:
-        try:
-            method = parent_module_context.py__path__
-        except AttributeError:
-            # The module is not a package.
-            return NO_CONTEXTS
-        else:
-            paths = method()
-            for path in paths:
-                # At the moment we are only using one path. So this is
-                # not important to be correct.
-                if not isinstance(path, list):
-                    path = [path]
-                file_io_or_ns, is_pkg = evaluator.compiled_subprocess.get_module_info(
-                    string=import_names[-1],
-                    path=path,
-                    full_name=module_name,
-                    is_global_search=False,
-                )
-                if is_pkg is not None:
-                    break
-            else:
-                return NO_CONTEXTS
-
-    if isinstance(file_io_or_ns, ImplicitNSInfo):
-        from jedi.evaluate.context.namespace import ImplicitNamespaceContext
-        module = ImplicitNamespaceContext(
-            evaluator,
-            fullname=file_io_or_ns.name,
-            paths=file_io_or_ns.paths,
-        )
-    elif file_io_or_ns is None:
-        module = _load_builtin_module(evaluator, import_names, sys_path)
-        if module is None:
-            return NO_CONTEXTS
-    else:
-        module = _load_python_module(
-            evaluator, file_io_or_ns, sys_path,
-            import_names=import_names,
-            is_package=is_pkg,
-        )
-
-    if parent_module_context is None:
-        debug.dbg('global search_module %s: %s', import_names[-1], module)
-    else:
-        debug.dbg('search_module %s in paths %s: %s', module_name, paths, module)
-    return ContextSet([module])
-
-
-def _load_python_module(evaluator, file_io, sys_path=None,
-                        import_names=None, is_package=False):
-    try:
-        return evaluator.module_cache.get_from_path(file_io.path)
-    except KeyError:
-        pass
-
-    module_node = evaluator.parse(
-        file_io=file_io,
-        cache=True,
-        diff_cache=settings.fast_parser,
-        cache_path=settings.cache_directory
-    )
-
-    from jedi.evaluate.context import ModuleContext
-    return ModuleContext(
-        evaluator, module_node,
-        file_io=file_io,
-        string_names=import_names,
-        code_lines=get_cached_code_lines(evaluator.grammar, file_io.path),
-        is_package=is_package,
-    )
-
-
-def _load_builtin_module(evaluator, import_names=None, sys_path=None):
-    if sys_path is None:
-        sys_path = evaluator.get_sys_path()
-
-    dotted_name = '.'.join(import_names)
-    assert dotted_name is not None
-    module = compiled.load_module(evaluator, dotted_name=dotted_name, sys_path=sys_path)
-    if module is None:
-        # The file might raise an ImportError e.g. and therefore not be
-        # importable.
-        return None
-    return module
-
-
-def _load_module_from_path(evaluator, file_io, base_names):
-    """
-    This should pretty much only be used for get_modules_containing_name. It's
-    here to ensure that a random path is still properly loaded into the Jedi
-    module structure.
-    """
-    e_sys_path = evaluator.get_sys_path()
-    path = file_io.path
-    if base_names:
-        module_name = os.path.basename(path)
-        module_name = sys_path.remove_python_path_suffix(module_name)
-        is_package = module_name == '__init__'
-        if is_package:
-            import_names = base_names
-        else:
-            import_names = base_names + (module_name,)
-    else:
-        import_names, is_package = sys_path.transform_path_to_dotted(e_sys_path, path)
-
-    module = _load_python_module(
-        evaluator, file_io,
-        sys_path=e_sys_path,
-        import_names=import_names,
-        is_package=is_package,
-    )
-    evaluator.module_cache.add(import_names, ContextSet([module]))
-    return module
-
-
-def get_modules_containing_name(evaluator, modules, name):
-    """
-    Search a name in the directories of modules.
-    """
-    def check_directory(folder_io):
-        for file_name in folder_io.list():
-            if file_name.endswith('.py'):
-                yield folder_io.get_file_io(file_name)
-
-    def check_fs(file_io, base_names):
-        try:
-            code = file_io.read()
-        except FileNotFoundError:
-            return None
-        code = python_bytes_to_unicode(code, errors='replace')
-        if name not in code:
-            return None
-        new_file_io = KnownContentFileIO(file_io.path, code)
-        m = _load_module_from_path(evaluator, new_file_io, base_names)
-        if isinstance(m, compiled.CompiledObject):
-            return None
-        return m
-
-    # skip non python modules
-    used_mod_paths = set()
-    folders_with_names_to_be_checked = []
-    for m in modules:
-        if m.file_io is not None:
-            path = m.file_io.path
-            if path not in used_mod_paths:
-                used_mod_paths.add(path)
-                folders_with_names_to_be_checked.append((
-                    m.file_io.get_parent_folder(),
-                    m.py__package__()
-                ))
-        yield m
-
-    if not settings.dynamic_params_for_other_modules:
-        return
-
-    def get_file_ios_to_check():
-        for folder_io, base_names in folders_with_names_to_be_checked:
-            for file_io in check_directory(folder_io):
-                yield file_io, base_names
-
-        for p in settings.additional_dynamic_modules:
-            p = os.path.abspath(p)
-            if p not in used_mod_paths:
-                yield FileIO(p), None
-
-    for file_io, base_names in get_file_ios_to_check():
-        m = check_fs(file_io, base_names)
-        if m is not None:
-            yield m

jedi/evaluate/lazy_context.py

@@ -1,59 +0,0 @@
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-from jedi.common.utils import monkeypatch
-
-
-class AbstractLazyContext(object):
-    def __init__(self, data):
-        self.data = data
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self.data)
-
-    def infer(self):
-        raise NotImplementedError
-
-
-class LazyKnownContext(AbstractLazyContext):
-    """data is a context."""
-    def infer(self):
-        return ContextSet([self.data])
-
-
-class LazyKnownContexts(AbstractLazyContext):
-    """data is a ContextSet."""
-    def infer(self):
-        return self.data
-
-
-class LazyUnknownContext(AbstractLazyContext):
-    def __init__(self):
-        super(LazyUnknownContext, self).__init__(None)
-
-    def infer(self):
-        return NO_CONTEXTS
-
-
-class LazyTreeContext(AbstractLazyContext):
-    def __init__(self, context, node):
-        super(LazyTreeContext, self).__init__(node)
-        self.context = context
-        # We need to save the predefined names. It's an unfortunate side effect
-        # that needs to be tracked otherwise results will be wrong.
-        self._predefined_names = dict(context.predefined_names)
-
-    def infer(self):
-        with monkeypatch(self.context, 'predefined_names', self._predefined_names):
-            return self.context.eval_node(self.data)
-
-
-def get_merged_lazy_context(lazy_contexts):
-    if len(lazy_contexts) > 1:
-        return MergedLazyContexts(lazy_contexts)
-    else:
-        return lazy_contexts[0]
-
-
-class MergedLazyContexts(AbstractLazyContext):
-    """data is a list of lazy contexts."""
-    def infer(self):
-        return ContextSet.from_sets(l.infer() for l in self.data)

jedi/evaluate/names.py

@@ -1,375 +0,0 @@
-from abc import abstractmethod
-
-from parso.tree import search_ancestor
-
-from jedi._compatibility import Parameter
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-from jedi.cache import memoize_method
-
-
-class AbstractNameDefinition(object):
-    start_pos = None
-    string_name = None
-    parent_context = None
-    tree_name = None
-    is_context_name = True
-    """
-    Used for the Jedi API to know if it's a keyword or an actual name.
-    """
-
-    @abstractmethod
-    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.
-        return {self}
-
-    def get_qualified_names(self, include_module_names=False):
-        qualified_names = self._get_qualified_names()
-        if qualified_names is None or not include_module_names:
-            return qualified_names
-
-        module_names = self.get_root_context().string_names
-        if module_names is None:
-            return None
-        return module_names + qualified_names
-
-    def _get_qualified_names(self):
-        # By default, a name has no qualified names.
-        return None
-
-    def get_root_context(self):
-        return self.parent_context.get_root_context()
-
-    def __repr__(self):
-        if self.start_pos is None:
-            return '<%s: string_name=%s>' % (self.__class__.__name__, self.string_name)
-        return '<%s: string_name=%s start_pos=%s>' % (self.__class__.__name__,
-                                                      self.string_name, self.start_pos)
-
-    def is_import(self):
-        return False
-
-    @property
-    def api_type(self):
-        return self.parent_context.api_type
-
-
-class AbstractArbitraryName(AbstractNameDefinition):
-    """
-    When you e.g. want to complete dicts keys, you probably want to complete
-    string literals, which is not really a name, but for Jedi we use this
-    concept of Name for completions as well.
-    """
-    is_context_name = False
-
-    def __init__(self, evaluator, string):
-        self.evaluator = evaluator
-        self.string_name = string
-        self.parent_context = evaluator.builtins_module
-
-    def infer(self):
-        return NO_CONTEXTS
-
-
-class AbstractTreeName(AbstractNameDefinition):
-    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')
-        # 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
-        # lookup.
-        if import_node is not None and not (import_node.level == 1
-                                            and self.get_root_context().is_package):
-            # TODO improve the situation for when level is present.
-            if include_module_names and not import_node.level:
-                return tuple(n.value for n in import_node.get_path_for_name(self.tree_name))
-            else:
-                return None
-
-        return super(AbstractTreeName, self).get_qualified_names(include_module_names)
-
-    def _get_qualified_names(self):
-        parent_names = self.parent_context.get_qualified_names()
-        if parent_names is None:
-            return None
-        return parent_names + (self.tree_name.value,)
-
-    def goto(self, **kwargs):
-        return self.parent_context.evaluator.goto(self.parent_context, self.tree_name, **kwargs)
-
-    def is_import(self):
-        imp = search_ancestor(self.tree_name, 'import_from', 'import_name')
-        return imp is not None
-
-    @property
-    def string_name(self):
-        return self.tree_name.value
-
-    @property
-    def start_pos(self):
-        return self.tree_name.start_pos
-
-
-class ContextNameMixin(object):
-    def infer(self):
-        return ContextSet([self._context])
-
-    def _get_qualified_names(self):
-        return self._context.get_qualified_names()
-
-    def get_root_context(self):
-        if self.parent_context is None:  # A module
-            return self._context
-        return super(ContextNameMixin, self).get_root_context()
-
-    @property
-    def api_type(self):
-        return self._context.api_type
-
-
-class ContextName(ContextNameMixin, AbstractTreeName):
-    def __init__(self, context, tree_name):
-        super(ContextName, self).__init__(context.parent_context, tree_name)
-        self._context = context
-
-    def goto(self):
-        return ContextSet([self._context.name])
-
-
-class TreeNameDefinition(AbstractTreeName):
-    _API_TYPES = dict(
-        import_name='module',
-        import_from='module',
-        funcdef='function',
-        param='param',
-        classdef='class',
-    )
-
-    def infer(self):
-        # Refactor this, should probably be here.
-        from jedi.evaluate.syntax_tree import tree_name_to_contexts
-        parent = self.parent_context
-        return tree_name_to_contexts(parent.evaluator, parent, self.tree_name)
-
-    @property
-    def api_type(self):
-        definition = self.tree_name.get_definition(import_name_always=True)
-        if definition is None:
-            return 'statement'
-        return self._API_TYPES.get(definition.type, 'statement')
-
-
-class _ParamMixin(object):
-    def maybe_positional_argument(self, include_star=True):
-        options = [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]
-        if include_stars:
-            options.append(Parameter.VAR_KEYWORD)
-        return self.get_kind() in options
-
-    def _kind_string(self):
-        kind = self.get_kind()
-        if kind == Parameter.VAR_POSITIONAL:  # *args
-            return '*'
-        if kind == Parameter.VAR_KEYWORD:  # **kwargs
-            return '**'
-        return ''
-
-
-class ParamNameInterface(_ParamMixin):
-    api_type = u'param'
-
-    def get_kind(self):
-        raise NotImplementedError
-
-    def to_string(self):
-        raise NotImplementedError
-
-    def get_param(self):
-        # TODO document better where this is used and when. Currently it has
-        #      very limited use, but is still in use. It's currently not even
-        #      clear what values would be allowed.
-        return None
-
-    @property
-    def star_count(self):
-        kind = self.get_kind()
-        if kind == Parameter.VAR_POSITIONAL:
-            return 1
-        if kind == Parameter.VAR_KEYWORD:
-            return 2
-        return 0
-
-
-class BaseTreeParamName(ParamNameInterface, AbstractTreeName):
-    annotation_node = None
-    default_node = None
-
-    def to_string(self):
-        output = self._kind_string() + self.string_name
-        annotation = self.annotation_node
-        default = self.default_node
-        if annotation is not None:
-            output += ': ' + annotation.get_code(include_prefix=False)
-        if default is not None:
-            output += '=' + default.get_code(include_prefix=False)
-        return output
-
-
-class ParamName(BaseTreeParamName):
-    def _get_param_node(self):
-        return search_ancestor(self.tree_name, 'param')
-
-    @property
-    def annotation_node(self):
-        return self._get_param_node().annotation
-
-    def infer_annotation(self, execute_annotation=True):
-        node = self.annotation_node
-        if node is None:
-            return NO_CONTEXTS
-        contexts = self.parent_context.parent_context.eval_node(node)
-        if execute_annotation:
-            contexts = contexts.execute_annotation()
-        return contexts
-
-    def infer_default(self):
-        node = self.default_node
-        if node is None:
-            return NO_CONTEXTS
-        return self.parent_context.parent_context.eval_node(node)
-
-    @property
-    def default_node(self):
-        return self._get_param_node().default
-
-    @property
-    def string_name(self):
-        name = self.tree_name.value
-        if name.startswith('__'):
-            # Params starting with __ are an equivalent to positional only
-            # variables in typeshed.
-            name = name[2:]
-        return name
-
-    def get_kind(self):
-        tree_param = self._get_param_node()
-        if tree_param.star_count == 1:  # *args
-            return Parameter.VAR_POSITIONAL
-        if tree_param.star_count == 2:  # **kwargs
-            return Parameter.VAR_KEYWORD
-
-        # Params starting with __ are an equivalent to positional only
-        # variables in typeshed.
-        if tree_param.name.value.startswith('__'):
-            return Parameter.POSITIONAL_ONLY
-
-        parent = tree_param.parent
-        param_appeared = False
-        for p in parent.children:
-            if param_appeared:
-                if p == '/':
-                    return Parameter.POSITIONAL_ONLY
-            else:
-                if p == '*':
-                    return Parameter.KEYWORD_ONLY
-                if p.type == 'param':
-                    if p.star_count:
-                        return Parameter.KEYWORD_ONLY
-                    if p == tree_param:
-                        param_appeared = True
-        return Parameter.POSITIONAL_OR_KEYWORD
-
-    def infer(self):
-        return self.get_param().infer()
-
-    def get_param(self):
-        params, _ = self.parent_context.get_executed_params_and_issues()
-        param_node = search_ancestor(self.tree_name, 'param')
-        return params[param_node.position_index]
-
-
-class ParamNameWrapper(_ParamMixin):
-    def __init__(self, param_name):
-        self._wrapped_param_name = param_name
-
-    def __getattr__(self, name):
-        return getattr(self._wrapped_param_name, name)
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self._wrapped_param_name)
-
-
-class ImportName(AbstractNameDefinition):
-    start_pos = (1, 0)
-    _level = 0
-
-    def __init__(self, parent_context, string_name):
-        self._from_module_context = parent_context
-        self.string_name = string_name
-
-    def get_qualified_names(self, include_module_names=False):
-        if include_module_names:
-            if self._level:
-                assert self._level == 1, "Everything else is not supported for now"
-                module_names = self._from_module_context.string_names
-                if module_names is None:
-                    return module_names
-                return module_names + (self.string_name,)
-            return (self.string_name,)
-        return ()
-
-    @property
-    def parent_context(self):
-        m = self._from_module_context
-        import_contexts = self.infer()
-        if not import_contexts:
-            return m
-        # It's almost always possible to find the import or to not find it. The
-        # importing returns only one context, pretty much always.
-        return next(iter(import_contexts))
-
-    @memoize_method
-    def infer(self):
-        from jedi.evaluate.imports import Importer
-        m = self._from_module_context
-        return Importer(m.evaluator, [self.string_name], m, level=self._level).follow()
-
-    def goto(self):
-        return [m.name for m in self.infer()]
-
-    @property
-    def api_type(self):
-        return 'module'
-
-
-class SubModuleName(ImportName):
-    _level = 1
-
-
-class NameWrapper(object):
-    def __init__(self, wrapped_name):
-        self._wrapped_name = wrapped_name
-
-    @abstractmethod
-    def infer(self):
-        raise NotImplementedError
-
-    def __getattr__(self, name):
-        return getattr(self._wrapped_name, name)
-
-    def __repr__(self):
-        return '%s(%s)' % (self.__class__.__name__, self._wrapped_name)

jedi/evaluate/parser_cache.py

@@ -1,6 +0,0 @@
-from jedi.evaluate.cache import evaluator_function_cache
-
-
-@evaluator_function_cache()
-def get_yield_exprs(evaluator, funcdef):
-    return list(funcdef.iter_yield_exprs())

jedi/evaluate/signature.py

@@ -1,116 +0,0 @@
-from jedi._compatibility import Parameter
-from jedi.cache import memoize_method
-
-
-class _SignatureMixin(object):
-    def to_string(self):
-        def param_strings():
-            is_positional = False
-            is_kw_only = False
-            for n in self.get_param_names(resolve_stars=True):
-                kind = n.get_kind()
-                is_positional |= kind == Parameter.POSITIONAL_ONLY
-                if is_positional and kind != Parameter.POSITIONAL_ONLY:
-                    yield '/'
-                    is_positional = False
-
-                if kind == Parameter.VAR_POSITIONAL:
-                    is_kw_only = True
-                elif kind == Parameter.KEYWORD_ONLY and not is_kw_only:
-                    yield '*'
-                    is_kw_only = True
-
-                yield n.to_string()
-
-            if is_positional:
-                yield '/'
-
-        s = self.name.string_name + '(' + ', '.join(param_strings()) + ')'
-        annotation = self.annotation_string
-        if annotation:
-            s += ' -> ' + annotation
-        return s
-
-
-class AbstractSignature(_SignatureMixin):
-    def __init__(self, context, is_bound=False):
-        self.context = context
-        self.is_bound = is_bound
-
-    @property
-    def name(self):
-        return self.context.name
-
-    @property
-    def annotation_string(self):
-        return ''
-
-    def get_param_names(self, resolve_stars=False):
-        param_names = self._function_context.get_param_names()
-        if self.is_bound:
-            return param_names[1:]
-        return param_names
-
-    def bind(self, context):
-        raise NotImplementedError
-
-    def __repr__(self):
-        return '<%s: %s, %s>' % (self.__class__.__name__, self.context, self._function_context)
-
-
-class TreeSignature(AbstractSignature):
-    def __init__(self, context, function_context=None, is_bound=False):
-        super(TreeSignature, self).__init__(context, is_bound)
-        self._function_context = function_context or context
-
-    def bind(self, context):
-        return TreeSignature(context, self._function_context, is_bound=True)
-
-    @property
-    def _annotation(self):
-        # Classes don't need annotations, even if __init__ has one. They always
-        # return themselves.
-        if self.context.is_class():
-            return None
-        return self._function_context.tree_node.annotation
-
-    @property
-    def annotation_string(self):
-        a = self._annotation
-        if a is None:
-            return ''
-        return a.get_code(include_prefix=False)
-
-    @memoize_method
-    def get_param_names(self, resolve_stars=False):
-        params = super(TreeSignature, self).get_param_names(resolve_stars=False)
-        if resolve_stars:
-            from jedi.evaluate.star_args import process_params
-            params = process_params(params)
-        return params
-
-
-class BuiltinSignature(AbstractSignature):
-    def __init__(self, context, return_string, is_bound=False):
-        super(BuiltinSignature, self).__init__(context, is_bound)
-        self._return_string = return_string
-
-    @property
-    def annotation_string(self):
-        return self._return_string
-
-    @property
-    def _function_context(self):
-        return self.context
-
-    def bind(self, context):
-        assert not self.is_bound
-        return BuiltinSignature(context, self._return_string, is_bound=True)
-
-
-class SignatureWrapper(_SignatureMixin):
-    def __init__(self, wrapped_signature):
-        self._wrapped_signature = wrapped_signature
-
-    def __getattr__(self, name):
-        return getattr(self._wrapped_signature, name)

jedi/evaluate/syntax_tree.py

@@ -1,730 +0,0 @@
-"""
-Functions evaluating the syntax tree.
-"""
-import copy
-
-from parso.python import tree
-
-from jedi._compatibility import force_unicode, unicode
-from jedi import debug
-from jedi import parser_utils
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, ContextualizedNode, \
-    ContextualizedName, iterator_to_context_set, iterate_contexts
-from jedi.evaluate.lazy_context import LazyTreeContext
-from jedi.evaluate import compiled
-from jedi.evaluate import recursion
-from jedi.evaluate import helpers
-from jedi.evaluate import analysis
-from jedi.evaluate import imports
-from jedi.evaluate import arguments
-from jedi.evaluate.context import ClassContext, FunctionContext
-from jedi.evaluate.context import iterable
-from jedi.evaluate.context import TreeInstance
-from jedi.evaluate.finder import NameFinder
-from jedi.evaluate.helpers import is_string, is_literal, is_number
-from jedi.evaluate.compiled.access import COMPARISON_OPERATORS
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.gradual.stub_context import VersionInfo
-from jedi.evaluate.gradual import annotation
-from jedi.evaluate.context.decorator import Decoratee
-from jedi.plugins import plugin_manager
-
-
-def _limit_context_infers(func):
-    """
-    This is for now the way how we limit type inference going wild. There are
-    other ways to ensure recursion limits as well. This is mostly necessary
-    because of instance (self) access that can be quite tricky to limit.
-
-    I'm still not sure this is the way to go, but it looks okay for now and we
-    can still go anther way in the future. Tests are there. ~ dave
-    """
-    def wrapper(context, *args, **kwargs):
-        n = context.tree_node
-        evaluator = context.evaluator
-        try:
-            evaluator.inferred_element_counts[n] += 1
-            if evaluator.inferred_element_counts[n] > 300:
-                debug.warning('In context %s there were too many inferences.', n)
-                return NO_CONTEXTS
-        except KeyError:
-            evaluator.inferred_element_counts[n] = 1
-        return func(context, *args, **kwargs)
-
-    return wrapper
-
-
-def _py__stop_iteration_returns(generators):
-    results = NO_CONTEXTS
-    for generator in generators:
-        try:
-            method = generator.py__stop_iteration_returns
-        except AttributeError:
-            debug.warning('%s is not actually a generator', generator)
-        else:
-            results |= method()
-    return results
-
-
-@debug.increase_indent
-@_limit_context_infers
-def eval_node(context, element):
-    debug.dbg('eval_node %s@%s in %s', element, element.start_pos, context)
-    evaluator = context.evaluator
-    typ = element.type
-    if typ in ('name', 'number', 'string', 'atom', 'strings', 'keyword', 'fstring'):
-        return eval_atom(context, element)
-    elif typ == 'lambdef':
-        return ContextSet([FunctionContext.from_context(context, element)])
-    elif typ == 'expr_stmt':
-        return eval_expr_stmt(context, element)
-    elif typ in ('power', 'atom_expr'):
-        first_child = element.children[0]
-        children = element.children[1:]
-        had_await = False
-        if first_child.type == 'keyword' and first_child.value == 'await':
-            had_await = True
-            first_child = children.pop(0)
-
-        context_set = context.eval_node(first_child)
-        for (i, trailer) in enumerate(children):
-            if trailer == '**':  # has a power operation.
-                right = context.eval_node(children[i + 1])
-                context_set = _eval_comparison(
-                    evaluator,
-                    context,
-                    context_set,
-                    trailer,
-                    right
-                )
-                break
-            context_set = eval_trailer(context, context_set, trailer)
-
-        if had_await:
-            return context_set.py__await__().py__stop_iteration_returns()
-        return context_set
-    elif typ in ('testlist_star_expr', 'testlist',):
-        # The implicit tuple in statements.
-        return ContextSet([iterable.SequenceLiteralContext(evaluator, context, element)])
-    elif typ in ('not_test', 'factor'):
-        context_set = context.eval_node(element.children[-1])
-        for operator in element.children[:-1]:
-            context_set = eval_factor(context_set, operator)
-        return context_set
-    elif typ == 'test':
-        # `x if foo else y` case.
-        return (context.eval_node(element.children[0]) |
-                context.eval_node(element.children[-1]))
-    elif typ == 'operator':
-        # Must be an ellipsis, other operators are not evaluated.
-        # In Python 2 ellipsis is coded as three single dot tokens, not
-        # as one token 3 dot token.
-        if element.value not in ('.', '...'):
-            origin = element.parent
-            raise AssertionError("unhandled operator %s in %s " % (repr(element.value), origin))
-        return ContextSet([compiled.builtin_from_name(evaluator, u'Ellipsis')])
-    elif typ == 'dotted_name':
-        context_set = eval_atom(context, element.children[0])
-        for next_name in element.children[2::2]:
-            # TODO add search_global=True?
-            context_set = context_set.py__getattribute__(next_name, name_context=context)
-        return context_set
-    elif typ == 'eval_input':
-        return eval_node(context, element.children[0])
-    elif typ == 'annassign':
-        return annotation.eval_annotation(context, element.children[1]) \
-            .execute_annotation()
-    elif typ == 'yield_expr':
-        if len(element.children) and element.children[1].type == 'yield_arg':
-            # Implies that it's a yield from.
-            element = element.children[1].children[1]
-            generators = context.eval_node(element) \
-                .py__getattribute__('__iter__').execute_evaluated()
-            return generators.py__stop_iteration_returns()
-
-        # Generator.send() is not implemented.
-        return NO_CONTEXTS
-    elif typ == 'namedexpr_test':
-        return eval_node(context, element.children[2])
-    else:
-        return eval_or_test(context, element)
-
-
-def eval_trailer(context, atom_contexts, trailer):
-    trailer_op, node = trailer.children[:2]
-    if node == ')':  # `arglist` is optional.
-        node = None
-
-    if trailer_op == '[':
-        trailer_op, node, _ = trailer.children
-        return atom_contexts.get_item(
-            eval_subscript_list(context.evaluator, context, node),
-            ContextualizedNode(context, trailer)
-        )
-    else:
-        debug.dbg('eval_trailer: %s in %s', trailer, atom_contexts)
-        if trailer_op == '.':
-            return atom_contexts.py__getattribute__(
-                name_context=context,
-                name_or_str=node
-            )
-        else:
-            assert trailer_op == '(', 'trailer_op is actually %s' % trailer_op
-            args = arguments.TreeArguments(context.evaluator, context, node, trailer)
-            return atom_contexts.execute(args)
-
-
-def eval_atom(context, atom):
-    """
-    Basically to process ``atom`` nodes. The parser sometimes doesn't
-    generate the node (because it has just one child). In that case an atom
-    might be a name or a literal as well.
-    """
-    if atom.type == 'name':
-        if atom.value in ('True', 'False', 'None'):
-            # Python 2...
-            return ContextSet([compiled.builtin_from_name(context.evaluator, atom.value)])
-
-        # This is the first global lookup.
-        stmt = tree.search_ancestor(
-            atom, 'expr_stmt', 'lambdef'
-        ) or atom
-        if stmt.type == 'lambdef':
-            stmt = atom
-        position = stmt.start_pos
-        if _is_annotation_name(atom):
-            # Since Python 3.7 (with from __future__ import annotations),
-            # annotations are essentially strings and can reference objects
-            # that are defined further down in code. Therefore just set the
-            # position to None, so the finder will not try to stop at a certain
-            # position in the module.
-            position = None
-        return context.py__getattribute__(
-            name_or_str=atom,
-            position=position,
-            search_global=True
-        )
-    elif atom.type == 'keyword':
-        # For False/True/None
-        if atom.value in ('False', 'True', 'None'):
-            return ContextSet([compiled.builtin_from_name(context.evaluator, atom.value)])
-        elif atom.value == 'print':
-            # print e.g. could be evaluated like this in Python 2.7
-            return NO_CONTEXTS
-        elif atom.value == 'yield':
-            # Contrary to yield from, yield can just appear alone to return a
-            # value when used with `.send()`.
-            return NO_CONTEXTS
-        assert False, 'Cannot evaluate the keyword %s' % atom
-
-    elif isinstance(atom, tree.Literal):
-        string = context.evaluator.compiled_subprocess.safe_literal_eval(atom.value)
-        return ContextSet([compiled.create_simple_object(context.evaluator, string)])
-    elif atom.type == 'strings':
-        # Will be multiple string.
-        context_set = eval_atom(context, atom.children[0])
-        for string in atom.children[1:]:
-            right = eval_atom(context, string)
-            context_set = _eval_comparison(context.evaluator, context, context_set, u'+', right)
-        return context_set
-    elif atom.type == 'fstring':
-        return compiled.get_string_context_set(context.evaluator)
-    else:
-        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
-                        len(c[1].children) > 1):
-            return context.eval_node(c[1])
-
-        try:
-            comp_for = c[1].children[1]
-        except (IndexError, AttributeError):
-            pass
-        else:
-            if comp_for == ':':
-                # Dict comprehensions have a colon at the 3rd index.
-                try:
-                    comp_for = c[1].children[3]
-                except IndexError:
-                    pass
-
-            if comp_for.type in ('comp_for', 'sync_comp_for'):
-                return ContextSet([iterable.comprehension_from_atom(
-                    context.evaluator, context, atom
-                )])
-
-        # It's a dict/list/tuple literal.
-        array_node = c[1]
-        try:
-            array_node_c = array_node.children
-        except AttributeError:
-            array_node_c = []
-        if c[0] == '{' and (array_node == '}' or ':' in array_node_c or
-                            '**' in array_node_c):
-            context = iterable.DictLiteralContext(context.evaluator, context, atom)
-        else:
-            context = iterable.SequenceLiteralContext(context.evaluator, context, atom)
-        return ContextSet([context])
-
-
-@_limit_context_infers
-def eval_expr_stmt(context, stmt, seek_name=None):
-    with recursion.execution_allowed(context.evaluator, stmt) as allowed:
-        # Here we allow list/set to recurse under certain conditions. To make
-        # it possible to resolve stuff like list(set(list(x))), this is
-        # necessary.
-        if not allowed and context.get_root_context() == context.evaluator.builtins_module:
-            try:
-                instance = context.var_args.instance
-            except AttributeError:
-                pass
-            else:
-                if instance.name.string_name in ('list', 'set'):
-                    c = instance.get_first_non_keyword_argument_contexts()
-                    if instance not in c:
-                        allowed = True
-
-        if allowed:
-            return _eval_expr_stmt(context, stmt, seek_name)
-    return NO_CONTEXTS
-
-
-@debug.increase_indent
-def _eval_expr_stmt(context, stmt, seek_name=None):
-    """
-    The starting point of the completion. A statement always owns a call
-    list, which are the calls, that a statement does. In case multiple
-    names are defined in the statement, `seek_name` returns the result for
-    this name.
-
-    :param stmt: A `tree.ExprStmt`.
-    """
-    debug.dbg('eval_expr_stmt %s (%s)', stmt, seek_name)
-    rhs = stmt.get_rhs()
-    context_set = context.eval_node(rhs)
-
-    if seek_name:
-        c_node = ContextualizedName(context, seek_name)
-        context_set = check_tuple_assignments(context.evaluator, c_node, context_set)
-
-    first_operator = next(stmt.yield_operators(), None)
-    if first_operator not in ('=', None) and first_operator.type == 'operator':
-        # `=` is always the last character in aug assignments -> -1
-        operator = copy.copy(first_operator)
-        operator.value = operator.value[:-1]
-        name = stmt.get_defined_names()[0].value
-        left = context.py__getattribute__(
-            name, position=stmt.start_pos, search_global=True)
-
-        for_stmt = tree.search_ancestor(stmt, 'for_stmt')
-        if for_stmt is not None and for_stmt.type == 'for_stmt' and context_set \
-                and parser_utils.for_stmt_defines_one_name(for_stmt):
-            # Iterate through result and add the values, that's possible
-            # only in for loops without clutter, because they are
-            # predictable. Also only do it, if the variable is not a tuple.
-            node = for_stmt.get_testlist()
-            cn = ContextualizedNode(context, node)
-            ordered = list(cn.infer().iterate(cn))
-
-            for lazy_context in ordered:
-                dct = {for_stmt.children[1].value: lazy_context.infer()}
-                with helpers.predefine_names(context, for_stmt, dct):
-                    t = context.eval_node(rhs)
-                    left = _eval_comparison(context.evaluator, context, left, operator, t)
-            context_set = left
-        else:
-            context_set = _eval_comparison(context.evaluator, context, left, operator, context_set)
-    debug.dbg('eval_expr_stmt result %s', context_set)
-    return context_set
-
-
-def eval_or_test(context, or_test):
-    iterator = iter(or_test.children)
-    types = context.eval_node(next(iterator))
-    for operator in iterator:
-        right = next(iterator)
-        if operator.type == 'comp_op':  # not in / is not
-            operator = ' '.join(c.value for c in operator.children)
-
-        # handle lazy evaluation of and/or here.
-        if operator in ('and', 'or'):
-            left_bools = set(left.py__bool__() for left in types)
-            if left_bools == {True}:
-                if operator == 'and':
-                    types = context.eval_node(right)
-            elif left_bools == {False}:
-                if operator != 'and':
-                    types = context.eval_node(right)
-            # Otherwise continue, because of uncertainty.
-        else:
-            types = _eval_comparison(context.evaluator, context, types, operator,
-                                     context.eval_node(right))
-    debug.dbg('eval_or_test types %s', types)
-    return types
-
-
-@iterator_to_context_set
-def eval_factor(context_set, operator):
-    """
-    Calculates `+`, `-`, `~` and `not` prefixes.
-    """
-    for context in context_set:
-        if operator == '-':
-            if is_number(context):
-                yield context.negate()
-        elif operator == 'not':
-            value = context.py__bool__()
-            if value is None:  # Uncertainty.
-                return
-            yield compiled.create_simple_object(context.evaluator, not value)
-        else:
-            yield context
-
-
-def _literals_to_types(evaluator, result):
-    # Changes literals ('a', 1, 1.0, etc) to its type instances (str(),
-    # int(), float(), etc).
-    new_result = NO_CONTEXTS
-    for typ in result:
-        if is_literal(typ):
-            # Literals are only valid as long as the operations are
-            # correct. Otherwise add a value-free instance.
-            cls = compiled.builtin_from_name(evaluator, typ.name.string_name)
-            new_result |= cls.execute_evaluated()
-        else:
-            new_result |= ContextSet([typ])
-    return new_result
-
-
-def _eval_comparison(evaluator, context, left_contexts, operator, right_contexts):
-    if not left_contexts or not right_contexts:
-        # illegal slices e.g. cause left/right_result to be None
-        result = (left_contexts or NO_CONTEXTS) | (right_contexts or NO_CONTEXTS)
-        return _literals_to_types(evaluator, result)
-    else:
-        # I don't think there's a reasonable chance that a string
-        # operation is still correct, once we pass something like six
-        # objects.
-        if len(left_contexts) * len(right_contexts) > 6:
-            return _literals_to_types(evaluator, left_contexts | right_contexts)
-        else:
-            return ContextSet.from_sets(
-                _eval_comparison_part(evaluator, context, left, operator, right)
-                for left in left_contexts
-                for right in right_contexts
-            )
-
-
-def _is_annotation_name(name):
-    ancestor = tree.search_ancestor(name, 'param', 'funcdef', 'expr_stmt')
-    if ancestor is None:
-        return False
-
-    if ancestor.type in ('param', 'funcdef'):
-        ann = ancestor.annotation
-        if ann is not None:
-            return ann.start_pos <= name.start_pos < ann.end_pos
-    elif ancestor.type == 'expr_stmt':
-        c = ancestor.children
-        if len(c) > 1 and c[1].type == 'annassign':
-            return c[1].start_pos <= name.start_pos < c[1].end_pos
-    return False
-
-
-def _is_tuple(context):
-    return isinstance(context, iterable.Sequence) and context.array_type == 'tuple'
-
-
-def _is_list(context):
-    return isinstance(context, iterable.Sequence) and context.array_type == 'list'
-
-
-def _bool_to_context(evaluator, bool_):
-    return compiled.builtin_from_name(evaluator, force_unicode(str(bool_)))
-
-
-def _get_tuple_ints(context):
-    if not isinstance(context, iterable.SequenceLiteralContext):
-        return None
-    numbers = []
-    for lazy_context in context.py__iter__():
-        if not isinstance(lazy_context, LazyTreeContext):
-            return None
-        node = lazy_context.data
-        if node.type != 'number':
-            return None
-        try:
-            numbers.append(int(node.value))
-        except ValueError:
-            return None
-    return numbers
-
-
-def _eval_comparison_part(evaluator, context, left, operator, right):
-    l_is_num = is_number(left)
-    r_is_num = is_number(right)
-    if isinstance(operator, unicode):
-        str_operator = operator
-    else:
-        str_operator = force_unicode(str(operator.value))
-
-    if str_operator == '*':
-        # for iterables, ignore * operations
-        if isinstance(left, iterable.Sequence) or is_string(left):
-            return ContextSet([left])
-        elif isinstance(right, iterable.Sequence) or is_string(right):
-            return ContextSet([right])
-    elif str_operator == '+':
-        if l_is_num and r_is_num or is_string(left) and is_string(right):
-            return ContextSet([left.execute_operation(right, str_operator)])
-        elif _is_tuple(left) and _is_tuple(right) or _is_list(left) and _is_list(right):
-            return ContextSet([iterable.MergedArray(evaluator, (left, right))])
-    elif str_operator == '-':
-        if l_is_num and r_is_num:
-            return ContextSet([left.execute_operation(right, str_operator)])
-    elif str_operator == '%':
-        # With strings and numbers the left type typically remains. Except for
-        # `int() % float()`.
-        return ContextSet([left])
-    elif str_operator in COMPARISON_OPERATORS:
-        if left.is_compiled() and right.is_compiled():
-            # Possible, because the return is not an option. Just compare.
-            try:
-                return ContextSet([left.execute_operation(right, str_operator)])
-            except TypeError:
-                # Could be True or False.
-                pass
-        else:
-            if str_operator in ('is', '!=', '==', 'is not'):
-                operation = COMPARISON_OPERATORS[str_operator]
-                bool_ = operation(left, right)
-                return ContextSet([_bool_to_context(evaluator, bool_)])
-
-            if isinstance(left, VersionInfo):
-                version_info = _get_tuple_ints(right)
-                if version_info is not None:
-                    bool_result = compiled.access.COMPARISON_OPERATORS[operator](
-                        evaluator.environment.version_info,
-                        tuple(version_info)
-                    )
-                    return ContextSet([_bool_to_context(evaluator, bool_result)])
-
-        return ContextSet([_bool_to_context(evaluator, True), _bool_to_context(evaluator, False)])
-    elif str_operator == 'in':
-        return NO_CONTEXTS
-
-    def check(obj):
-        """Checks if a Jedi object is either a float or an int."""
-        return isinstance(obj, TreeInstance) and \
-            obj.name.string_name in ('int', 'float')
-
-    # Static analysis, one is a number, the other one is not.
-    if str_operator in ('+', '-') and l_is_num != r_is_num \
-            and not (check(left) or check(right)):
-        message = "TypeError: unsupported operand type(s) for +: %s and %s"
-        analysis.add(context, 'type-error-operation', operator,
-                     message % (left, right))
-
-    result = ContextSet([left, right])
-    debug.dbg('Used operator %s resulting in %s', operator, result)
-    return result
-
-
-def _remove_statements(evaluator, context, stmt, name):
-    """
-    This is the part where statements are being stripped.
-
-    Due to lazy evaluation, statements like a = func; b = a; b() have to be
-    evaluated.
-    """
-    pep0484_contexts = \
-        annotation.find_type_from_comment_hint_assign(context, stmt, name)
-    if pep0484_contexts:
-        return pep0484_contexts
-
-    return eval_expr_stmt(context, stmt, seek_name=name)
-
-
-@plugin_manager.decorate()
-def tree_name_to_contexts(evaluator, context, tree_name):
-    context_set = NO_CONTEXTS
-    module_node = context.get_root_context().tree_node
-    # First check for annotations, like: `foo: int = 3`
-    if module_node is not None:
-        names = module_node.get_used_names().get(tree_name.value, [])
-        for name in names:
-            expr_stmt = name.parent
-
-            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:
-                    context_set |= annotation.eval_annotation(
-                        context, expr_stmt.children[1].children[1]
-                    ).execute_annotation()
-        if context_set:
-            return context_set
-
-    types = []
-    node = tree_name.get_definition(import_name_always=True)
-    if node is None:
-        node = tree_name.parent
-        if node.type == 'global_stmt':
-            context = evaluator.create_context(context, tree_name)
-            finder = NameFinder(evaluator, context, context, tree_name.value)
-            filters = finder.get_filters(search_global=True)
-            # For global_stmt lookups, we only need the first possible scope,
-            # which means the function itself.
-            filters = [next(filters)]
-            return finder.find(filters, attribute_lookup=False)
-        elif node.type not in ('import_from', 'import_name'):
-            context = evaluator.create_context(context, tree_name)
-            return eval_atom(context, tree_name)
-
-    typ = node.type
-    if typ == 'for_stmt':
-        types = annotation.find_type_from_comment_hint_for(context, node, tree_name)
-        if types:
-            return types
-    if typ == 'with_stmt':
-        types = annotation.find_type_from_comment_hint_with(context, node, tree_name)
-        if types:
-            return types
-
-    if typ in ('for_stmt', 'comp_for', 'sync_comp_for'):
-        try:
-            types = context.predefined_names[node][tree_name.value]
-        except KeyError:
-            cn = ContextualizedNode(context, node.children[3])
-            for_types = iterate_contexts(
-                cn.infer(),
-                contextualized_node=cn,
-                is_async=node.parent.type == 'async_stmt',
-            )
-            c_node = ContextualizedName(context, tree_name)
-            types = check_tuple_assignments(evaluator, c_node, for_types)
-    elif typ == 'expr_stmt':
-        types = _remove_statements(evaluator, context, node, tree_name)
-    elif typ == 'with_stmt':
-        context_managers = context.eval_node(node.get_test_node_from_name(tree_name))
-        enter_methods = context_managers.py__getattribute__(u'__enter__')
-        return enter_methods.execute_evaluated()
-    elif typ in ('import_from', 'import_name'):
-        types = imports.infer_import(context, tree_name)
-    elif typ in ('funcdef', 'classdef'):
-        types = _apply_decorators(context, node)
-    elif typ == 'try_stmt':
-        # TODO an exception can also be a tuple. Check for those.
-        # TODO check for types that are not classes and add it to
-        # the static analysis report.
-        exceptions = context.eval_node(tree_name.get_previous_sibling().get_previous_sibling())
-        types = exceptions.execute_evaluated()
-    elif node.type == 'param':
-        types = NO_CONTEXTS
-    else:
-        raise ValueError("Should not happen. type: %s" % typ)
-    return types
-
-
-# We don't want to have functions/classes that are created by the same
-# tree_node.
-@evaluator_method_cache()
-def _apply_decorators(context, node):
-    """
-    Returns the function, that should to be executed in the end.
-    This is also the places where the decorators are processed.
-    """
-    if node.type == 'classdef':
-        decoratee_context = ClassContext(
-            context.evaluator,
-            parent_context=context,
-            tree_node=node
-        )
-    else:
-        decoratee_context = FunctionContext.from_context(context, node)
-    initial = values = ContextSet([decoratee_context])
-    for dec in reversed(node.get_decorators()):
-        debug.dbg('decorator: %s %s', dec, values, color="MAGENTA")
-        with debug.increase_indent_cm():
-            dec_values = context.eval_node(dec.children[1])
-            trailer_nodes = dec.children[2:-1]
-            if trailer_nodes:
-                # Create a trailer and evaluate it.
-                trailer = tree.PythonNode('trailer', trailer_nodes)
-                trailer.parent = dec
-                dec_values = eval_trailer(context, dec_values, trailer)
-
-            if not len(dec_values):
-                code = dec.get_code(include_prefix=False)
-                # For the short future, we don't want to hear about the runtime
-                # decorator in typing that was intentionally omitted. This is not
-                # "correct", but helps with debugging.
-                if code != '@runtime\n':
-                    debug.warning('decorator not found: %s on %s', dec, node)
-                return initial
-
-            values = dec_values.execute(arguments.ValuesArguments([values]))
-            if not len(values):
-                debug.warning('not possible to resolve wrappers found %s', node)
-                return initial
-
-        debug.dbg('decorator end %s', values, color="MAGENTA")
-    if values != initial:
-        return ContextSet([Decoratee(c, decoratee_context) for c in values])
-    return values
-
-
-def check_tuple_assignments(evaluator, contextualized_name, context_set):
-    """
-    Checks if tuples are assigned.
-    """
-    lazy_context = None
-    for index, node in contextualized_name.assignment_indexes():
-        cn = ContextualizedNode(contextualized_name.context, node)
-        iterated = context_set.iterate(cn)
-        if isinstance(index, slice):
-            # For no star unpacking is not possible.
-            return NO_CONTEXTS
-        for _ in range(index + 1):
-            try:
-                lazy_context = next(iterated)
-            except StopIteration:
-                # 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
-                # finished.
-                return NO_CONTEXTS
-        context_set = lazy_context.infer()
-    return context_set
-
-
-def eval_subscript_list(evaluator, context, index):
-    """
-    Handles slices in subscript nodes.
-    """
-    if index == ':':
-        # Like array[:]
-        return ContextSet([iterable.Slice(context, None, None, None)])
-
-    elif index.type == 'subscript' and not index.children[0] == '.':
-        # subscript basically implies a slice operation, except for Python 2's
-        # Ellipsis.
-        # e.g. array[:3]
-        result = []
-        for el in index.children:
-            if el == ':':
-                if not result:
-                    result.append(None)
-            elif el.type == 'sliceop':
-                if len(el.children) == 2:
-                    result.append(el.children[1])
-            else:
-                result.append(el)
-        result += [None] * (3 - len(result))
-
-        return ContextSet([iterable.Slice(context, *result)])
-    elif index.type == 'subscriptlist':
-        return ContextSet([iterable.SequenceLiteralContext(evaluator, context, index)])
-
-    # No slices
-    return context.eval_node(index)

jedi/evaluate/usages.py

@@ -1,61 +0,0 @@
-from jedi.evaluate import imports
-from jedi.evaluate.names import TreeNameDefinition
-
-
-def _resolve_names(definition_names, avoid_names=()):
-    for name in definition_names:
-        if name in avoid_names:
-            # Avoiding recursions here, because goto on a module name lands
-            # on the same module.
-            continue
-
-        if not isinstance(name, imports.SubModuleName):
-            # SubModuleNames are not actually existing names but created
-            # names when importing something like `import foo.bar.baz`.
-            yield name
-
-        if name.api_type == 'module':
-            for name in _resolve_names(name.goto(), definition_names):
-                yield name
-
-
-def _dictionarize(names):
-    return dict(
-        (n if n.tree_name is None else n.tree_name, n)
-        for n in names
-    )
-
-
-def _find_names(module_context, tree_name):
-    context = module_context.create_context(tree_name)
-    name = TreeNameDefinition(context, tree_name)
-    found_names = set(name.goto())
-    found_names.add(name)
-    return _dictionarize(_resolve_names(found_names))
-
-
-def usages(module_context, tree_name):
-    search_name = tree_name.value
-    found_names = _find_names(module_context, tree_name)
-    modules = set(d.get_root_context() for d in found_names.values())
-    modules = set(m for m in modules if m.is_module() and not m.is_compiled())
-
-    non_matching_usage_maps = {}
-    for m in imports.get_modules_containing_name(module_context.evaluator, modules, search_name):
-        for name_leaf in m.tree_node.get_used_names().get(search_name, []):
-            new = _find_names(m, name_leaf)
-            if any(tree_name in found_names for tree_name in new):
-                found_names.update(new)
-                for tree_name in new:
-                    for dct in non_matching_usage_maps.get(tree_name, []):
-                        # A usage that was previously searched for matches with
-                        # a now found name. Merge.
-                        found_names.update(dct)
-                    try:
-                        del non_matching_usage_maps[tree_name]
-                    except KeyError:
-                        pass
-            else:
-                for name in new:
-                    non_matching_usage_maps.setdefault(name, []).append(new)
-    return found_names.values()

jedi/file_io.py

@@ -3,26 +3,61 @@ import os
 from parso import file_io
 
 
-class AbstractFolderIO(object):
+class AbstractFolderIO:
     def __init__(self, path):
         self.path = path
 
+    def get_base_name(self):
+        raise NotImplementedError
+
     def list(self):
         raise NotImplementedError
 
     def get_file_io(self, name):
         raise NotImplementedError
 
+    def get_parent_folder(self):
+        raise NotImplementedError
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.path)
+
 
 class FolderIO(AbstractFolderIO):
+    def get_base_name(self):
+        return os.path.basename(self.path)
+
     def list(self):
         return os.listdir(self.path)
 
     def get_file_io(self, name):
         return FileIO(os.path.join(self.path, name))
 
+    def get_parent_folder(self):
+        return FolderIO(os.path.dirname(self.path))
 
-class FileIOFolderMixin(object):
+    def walk(self):
+        for root, dirs, files in os.walk(self.path):
+            root_folder_io = FolderIO(root)
+            original_folder_ios = [FolderIO(os.path.join(root, d)) for d in dirs]
+            modified_folder_ios = list(original_folder_ios)
+            yield (
+                root_folder_io,
+                modified_folder_ios,
+                [FileIO(os.path.join(root, f)) for f in files],
+            )
+            modified_iterator = iter(reversed(modified_folder_ios))
+            current = next(modified_iterator, None)
+            i = len(original_folder_ios)
+            for folder_io in reversed(original_folder_ios):
+                i -= 1   # Basically enumerate but reversed
+                if current is folder_io:
+                    current = next(modified_iterator, None)
+                else:
+                    del dirs[i]
+
+
+class FileIOFolderMixin:
     def get_parent_folder(self):
         return FolderIO(os.path.dirname(self.path))
 
@@ -30,13 +65,13 @@ class FileIOFolderMixin(object):
 class ZipFileIO(file_io.KnownContentFileIO, FileIOFolderMixin):
     """For .zip and .egg archives"""
     def __init__(self, path, code, zip_path):
-        super(ZipFileIO, self).__init__(path, code)
+        super().__init__(path, code)
         self._zip_path = zip_path
 
     def get_last_modified(self):
         try:
             return os.path.getmtime(self._zip_path)
-        except OSError:  # Python 3 would probably only need FileNotFoundError
+        except (FileNotFoundError, PermissionError, NotADirectoryError):
             return None
 
 

jedi/inference/__init__.py

@@ -0,0 +1,199 @@
+"""
+Type inference of Python code in |jedi| is based on three assumptions:
+
+* The code uses as least side effects as possible. Jedi understands certain
+  list/tuple/set modifications, but there's no guarantee that Jedi detects
+  everything (list.append in different modules for example).
+* No magic is being used:
+
+  - metaclasses
+  - ``setattr()`` / ``__import__()``
+  - writing to ``globals()``, ``locals()``, ``object.__dict__``
+* The programmer is not a total dick, e.g. like `this
+  <https://github.com/davidhalter/jedi/issues/24>`_ :-)
+
+The actual algorithm is based on a principle I call lazy type inference.  That
+said, the typical entry point for static analysis is calling
+``infer_expr_stmt``. There's separate logic for autocompletion in the API, the
+inference_state is all about inferring an expression.
+
+TODO this paragraph is not what jedi does anymore, it's similar, but not the
+same.
+
+Now you need to understand what follows after ``infer_expr_stmt``. Let's
+make an example::
+
+    import datetime
+    datetime.date.toda# <-- cursor here
+
+First of all, this module doesn't care about completion. It really just cares
+about ``datetime.date``. At the end of the procedure ``infer_expr_stmt`` will
+return the ``date`` class.
+
+To *visualize* this (simplified):
+
+- ``InferenceState.infer_expr_stmt`` doesn't do much, because there's no assignment.
+- ``Context.infer_node`` cares for resolving the dotted path
+- ``InferenceState.find_types`` searches for global definitions of datetime, which
+  it finds in the definition of an import, by scanning the syntax tree.
+- Using the import logic, the datetime module is found.
+- Now ``find_types`` is called again by ``infer_node`` to find ``date``
+  inside the datetime module.
+
+Now what would happen if we wanted ``datetime.date.foo.bar``? Two more
+calls to ``find_types``. However the second call would be ignored, because the
+first one would return nothing (there's no foo attribute in ``date``).
+
+What if the import would contain another ``ExprStmt`` like this::
+
+    from foo import bar
+    Date = bar.baz
+
+Well... You get it. Just another ``infer_expr_stmt`` recursion. It's really
+easy. Python can obviously get way more complicated then this. To understand
+tuple assignments, list comprehensions and everything else, a lot more code had
+to be written.
+
+Jedi has been tested very well, so you can just start modifying code. It's best
+to write your own test first for your "new" feature. Don't be scared of
+breaking stuff. As long as the tests pass, you're most likely to be fine.
+
+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.
+"""
+import parso
+from jedi.file_io import FileIO
+
+from jedi import debug
+from jedi import settings
+from jedi.inference import imports
+from jedi.inference import recursion
+from jedi.inference.cache import inference_state_function_cache
+from jedi.inference import helpers
+from jedi.inference.names import TreeNameDefinition
+from jedi.inference.base_value import ContextualizedNode, \
+    ValueSet, iterate_values
+from jedi.inference.value import ClassValue, FunctionValue
+from jedi.inference.syntax_tree import infer_expr_stmt, \
+    check_tuple_assignments, tree_name_to_values
+from jedi.inference.imports import follow_error_node_imports_if_possible
+from jedi.plugins import plugin_manager
+
+
+class InferenceState:
+    def __init__(self, project, environment=None, script_path=None):
+        if environment is None:
+            environment = project.get_environment()
+        self.environment = environment
+        self.script_path = script_path
+        self.compiled_subprocess = environment.get_inference_state_subprocess(self)
+        self.grammar = environment.get_grammar()
+
+        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]]
+        self.compiled_cache = {}  # see `inference.compiled.create()`
+        self.inferred_element_counts = {}
+        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_unsafe_executions = False
+        self.flow_analysis_enabled = True
+
+        self.reset_recursion_limitations()
+
+    def import_module(self, import_names, sys_path=None, prefer_stubs=True):
+        return imports.import_module_by_names(
+            self, import_names, sys_path, prefer_stubs=prefer_stubs)
+
+    @staticmethod
+    @plugin_manager.decorate()
+    def execute(value, arguments):
+        debug.dbg('execute: %s %s', value, arguments)
+        with debug.increase_indent_cm():
+            value_set = value.py__call__(arguments=arguments)
+        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)
+    @property  # type: ignore[misc]
+    @inference_state_function_cache()
+    def builtins_module(self):
+        module_name = 'builtins'
+        builtins_module, = self.import_module((module_name,), sys_path=[])
+        return builtins_module
+
+    @property  # type: ignore[misc]
+    @inference_state_function_cache()
+    def typing_module(self):
+        typing_module, = self.import_module(('typing',))
+        return typing_module
+
+    def reset_recursion_limitations(self):
+        self.recursion_detector = recursion.RecursionDetector()
+        self.execution_recursion_detector = recursion.ExecutionRecursionDetector(self)
+
+    def get_sys_path(self, **kwargs):
+        """Convenience function"""
+        return self.project._get_sys_path(self, **kwargs)
+
+    def infer(self, context, name):
+        def_ = name.get_definition(import_name_always=True)
+        if def_ is not None:
+            type_ = def_.type
+            is_classdef = type_ == 'classdef'
+            if is_classdef or type_ == 'funcdef':
+                if is_classdef:
+                    c = ClassValue(self, context, name.parent)
+                else:
+                    c = FunctionValue.from_context(context, name.parent)
+                return ValueSet([c])
+
+            if type_ == 'expr_stmt':
+                is_simple_name = name.parent.type not in ('power', 'trailer')
+                if is_simple_name:
+                    return infer_expr_stmt(context, def_, name)
+            if type_ == 'for_stmt':
+                container_types = context.infer_node(def_.children[3])
+                cn = ContextualizedNode(context, def_.children[3])
+                for_types = iterate_values(container_types, cn)
+                n = TreeNameDefinition(context, name)
+                return check_tuple_assignments(n, for_types)
+            if type_ in ('import_from', 'import_name'):
+                return imports.infer_import(context, name)
+            if type_ == 'with_stmt':
+                return tree_name_to_values(self, context, name)
+            elif type_ == 'param':
+                return context.py__getattribute__(name.value, position=name.end_pos)
+            elif type_ == 'namedexpr_test':
+                return context.infer_node(def_)
+        else:
+            result = follow_error_node_imports_if_possible(context, name)
+            if result is not None:
+                return result
+
+        return helpers.infer_call_of_leaf(context, name)
+
+    def parse_and_get_code(self, code=None, path=None,
+                           use_latest_grammar=False, file_io=None, **kwargs):
+        if code is None:
+            if file_io is None:
+                file_io = FileIO(path)
+            code = file_io.read()
+        # We cannot just use parso, because it doesn't use errors='replace'.
+        code = parso.python_bytes_to_unicode(code, encoding='utf-8', errors='replace')
+
+        if len(code) > settings._cropped_file_size:
+            code = code[:settings._cropped_file_size]
+
+        grammar = self.latest_grammar if use_latest_grammar else self.grammar
+        return grammar.parse(code=code, path=path, file_io=file_io, **kwargs), code
+
+    def parse(self, *args, **kwargs):
+        return self.parse_and_get_code(*args, **kwargs)[0]

jedi/inference/analysis.py

@@ -3,9 +3,8 @@ Module for statical analysis.
 """
 from parso.python import tree
 
-from jedi._compatibility import force_unicode
 from jedi import debug
-from jedi.evaluate.helpers import is_string
+from jedi.inference.helpers import is_string
 
 
 CODES = {
@@ -27,7 +26,7 @@ CODES = {
 }
 
 
-class Error(object):
+class Error:
     def __init__(self, name, module_path, start_pos, message=None):
         self.path = module_path
         self._start_pos = start_pos
@@ -50,16 +49,13 @@ class Error(object):
         first = self.__class__.__name__[0]
         return first + str(CODES[self.name][0])
 
-    def __unicode__(self):
+    def __str__(self):
         return '%s:%s:%s: %s %s' % (self.path, self.line, self.column,
                                     self.code, self.message)
 
-    def __str__(self):
-        return self.__unicode__()
-
     def __eq__(self, other):
-        return (self.path == other.path and self.name == other.name and
-                self._start_pos == other._start_pos)
+        return (self.path == other.path and self.name == other.name
+                and self._start_pos == other._start_pos)
 
     def __ne__(self, other):
         return not self.__eq__(other)
@@ -87,7 +83,7 @@ def add(node_context, error_name, node, message=None, typ=Error, payload=None):
     module_path = module_context.py__file__()
     issue_instance = typ(error_name, module_path, node.start_pos, message)
     debug.warning(str(issue_instance), format=False)
-    node_context.evaluator.analysis.append(issue_instance)
+    node_context.inference_state.analysis.append(issue_instance)
     return issue_instance
 
 
@@ -112,26 +108,18 @@ def _check_for_setattr(instance):
                for n in stmt_names)
 
 
-def add_attribute_error(name_context, lookup_context, name):
-    message = ('AttributeError: %s has no attribute %s.' % (lookup_context, name))
-    from jedi.evaluate.context.instance import CompiledInstanceName
+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
     # instead of an error, if that happens.
     typ = Error
-    if lookup_context.is_instance() and not lookup_context.is_compiled():
-        slot_names = lookup_context.get_function_slot_names(u'__getattr__') + \
-            lookup_context.get_function_slot_names(u'__getattribute__')
-        for n in slot_names:
-            # TODO do we even get here?
-            if isinstance(name, CompiledInstanceName) and \
-                    n.parent_context.obj == object:
-                typ = Warning
-                break
+    if lookup_value.is_instance() and not lookup_value.is_compiled():
+        # TODO maybe make a warning for __getattr__/__getattribute__
 
-        if _check_for_setattr(lookup_context):
+        if _check_for_setattr(lookup_value):
             typ = Warning
 
-    payload = lookup_context, name
+    payload = lookup_value, name
     add(name_context, 'attribute-error', name, message, typ, payload)
 
 
@@ -149,7 +137,7 @@ def _check_for_exception_catch(node_context, jedi_name, exception, payload=None)
 
         for python_cls in exception.mro():
             if cls.py__name__() == python_cls.__name__ \
-                    and cls.parent_context == cls.evaluator.builtins_module:
+                    and cls.parent_context.is_builtins_module():
                 return True
         return False
 
@@ -157,7 +145,7 @@ def _check_for_exception_catch(node_context, jedi_name, exception, payload=None)
         # Only nodes in try
         iterator = iter(obj.children)
         for branch_type in iterator:
-            colon = next(iterator)
+            next(iterator)  # The colon
             suite = next(iterator)
             if branch_type == 'try' \
                     and not (branch_type.start_pos < jedi_name.start_pos <= suite.end_pos):
@@ -167,14 +155,14 @@ def _check_for_exception_catch(node_context, jedi_name, exception, payload=None)
             if node is None:
                 return True  # An exception block that catches everything.
             else:
-                except_classes = node_context.eval_node(node)
+                except_classes = node_context.infer_node(node)
                 for cls in except_classes:
-                    from jedi.evaluate.context import iterable
+                    from jedi.inference.value import iterable
                     if isinstance(cls, iterable.Sequence) and \
                             cls.array_type == 'tuple':
                         # multiple exceptions
-                        for lazy_context in cls.py__iter__():
-                            for typ in lazy_context.infer():
+                        for lazy_value in cls.py__iter__():
+                            for typ in lazy_value.infer():
                                 if check_match(typ, exception):
                                     return True
                     else:
@@ -191,20 +179,21 @@ def _check_for_exception_catch(node_context, jedi_name, exception, payload=None)
             assert trailer.type == 'trailer'
             arglist = trailer.children[1]
             assert arglist.type == 'arglist'
-            from jedi.evaluate.arguments import TreeArguments
-            args = list(TreeArguments(node_context.evaluator, node_context, arglist).unpack())
+            from jedi.inference.arguments import TreeArguments
+            args = TreeArguments(node_context.inference_state, node_context, arglist)
+            unpacked_args = list(args.unpack())
             # Arguments should be very simple
-            assert len(args) == 2
+            assert len(unpacked_args) == 2
 
             # Check name
-            key, lazy_context = args[1]
-            names = list(lazy_context.infer())
+            key, lazy_value = unpacked_args[1]
+            names = list(lazy_value.infer())
             assert len(names) == 1 and is_string(names[0])
-            assert force_unicode(names[0].get_safe_value()) == payload[1].value
+            assert names[0].get_safe_value() == payload[1].value
 
             # Check objects
-            key, lazy_context = args[0]
-            objects = lazy_context.infer()
+            key, lazy_value = unpacked_args[0]
+            objects = lazy_value.infer()
             return payload[0] in objects
         except AssertionError:
             return False

jedi/inference/arguments.py

@@ -1,25 +1,24 @@
 import re
+from itertools import zip_longest
 
 from parso.python import tree
 
-from jedi._compatibility import zip_longest
 from jedi import debug
-from jedi.evaluate.utils import PushBackIterator
-from jedi.evaluate import analysis
-from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \
-    LazyTreeContext, get_merged_lazy_context
-from jedi.evaluate.names import ParamName, TreeNameDefinition
-from jedi.evaluate.base_context import NO_CONTEXTS, ContextSet, ContextualizedNode
-from jedi.evaluate.context import iterable
-from jedi.evaluate.cache import evaluator_as_method_param_cache
-from jedi.evaluate.param import get_executed_params_and_issues, ExecutedParam
+from jedi.inference.utils import PushBackIterator
+from jedi.inference import analysis
+from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \
+    LazyTreeValue, get_merged_lazy_value
+from jedi.inference.names import ParamName, TreeNameDefinition, AnonymousParamName
+from jedi.inference.base_value import NO_VALUES, ValueSet, ContextualizedNode
+from jedi.inference.value import iterable
+from jedi.inference.cache import inference_state_as_method_param_cache
 
 
 def try_iter_content(types, depth=0):
     """Helper method for static analysis."""
     if depth > 10:
         # It's possible that a loop has references on itself (especially with
-        # CompiledObject). Therefore don't loop infinitely.
+        # CompiledValue). Therefore don't loop infinitely.
         return
 
     for typ in types:
@@ -28,15 +27,15 @@ def try_iter_content(types, depth=0):
         except AttributeError:
             pass
         else:
-            for lazy_context in f():
-                try_iter_content(lazy_context.infer(), depth + 1)
+            for lazy_value in f():
+                try_iter_content(lazy_value.infer(), depth + 1)
 
 
 class ParamIssue(Exception):
     pass
 
 
-def repack_with_argument_clinic(string, keep_arguments_param=False, keep_callback_param=False):
+def repack_with_argument_clinic(clinic_string):
     """
     Transforms a function or method with arguments to the signature that is
     given as an argument clinic notation.
@@ -47,45 +46,39 @@ def repack_with_argument_clinic(string, keep_arguments_param=False, keep_callbac
         str.split.__text_signature__
         # Results in: '($self, /, sep=None, maxsplit=-1)'
     """
-    clinic_args = list(_parse_argument_clinic(string))
-
     def decorator(func):
-        def wrapper(context, *args, **kwargs):
-            if keep_arguments_param:
-                arguments = kwargs['arguments']
-            else:
-                arguments = kwargs.pop('arguments')
-            if not keep_arguments_param:
-                kwargs.pop('callback', None)
+        def wrapper(value, arguments):
             try:
-                args += tuple(_iterate_argument_clinic(
-                    context.evaluator,
+                args = tuple(iterate_argument_clinic(
+                    value.inference_state,
                     arguments,
-                    clinic_args
+                    clinic_string,
                 ))
             except ParamIssue:
-                return NO_CONTEXTS
+                return NO_VALUES
             else:
-                return func(context, *args, **kwargs)
+                return func(value, *args)
 
         return wrapper
     return decorator
 
 
-def _iterate_argument_clinic(evaluator, arguments, parameters):
+def iterate_argument_clinic(inference_state, arguments, clinic_string):
     """Uses a list with argument clinic information (see PEP 436)."""
+    clinic_args = list(_parse_argument_clinic(clinic_string))
+
     iterator = PushBackIterator(arguments.unpack())
-    for i, (name, optional, allow_kwargs, stars) in enumerate(parameters):
+    for i, (name, optional, allow_kwargs, stars) in enumerate(clinic_args):
         if stars == 1:
-            lazy_contexts = []
+            lazy_values = []
             for key, argument in iterator:
                 if key is not None:
                     iterator.push_back((key, argument))
                     break
 
-                lazy_contexts.append(argument)
-            yield ContextSet([iterable.FakeSequence(evaluator, u'tuple', lazy_contexts)])
-            lazy_contexts
+                lazy_values.append(argument)
+            yield ValueSet([iterable.FakeTuple(inference_state, lazy_values)])
+            lazy_values
             continue
         elif stars == 2:
             raise NotImplementedError()
@@ -95,18 +88,18 @@ def _iterate_argument_clinic(evaluator, arguments, parameters):
             raise ParamIssue
         if argument is None and not optional:
             debug.warning('TypeError: %s expected at least %s arguments, got %s',
-                          name, len(parameters), i)
+                          name, len(clinic_args), i)
             raise ParamIssue
 
-        context_set = NO_CONTEXTS if argument is None else argument.infer()
+        value_set = NO_VALUES if argument is None else argument.infer()
 
-        if not context_set and not optional:
+        if not value_set and not optional:
             # For the stdlib we always want values. If we don't get them,
             # that's ok, maybe something is too hard to resolve, however,
-            # we will not proceed with the evaluation of that function.
+            # we will not proceed with the type inference of that function.
             debug.warning('argument_clinic "%s" not resolvable.', name)
             raise ParamIssue
-        yield context_set
+        yield value_set
 
 
 def _parse_argument_clinic(string):
@@ -131,22 +124,10 @@ def _parse_argument_clinic(string):
             allow_kwargs = True
 
 
-class _AbstractArgumentsMixin(object):
-    def eval_all(self, funcdef=None):
-        """
-        Evaluates all arguments as a support for static analysis
-        (normally Jedi).
-        """
-        for key, lazy_context in self.unpack():
-            types = lazy_context.infer()
-            try_iter_content(types)
-
+class _AbstractArgumentsMixin:
     def unpack(self, funcdef=None):
         raise NotImplementedError
 
-    def get_executed_params_and_issues(self, execution_context):
-        return get_executed_params_and_issues(execution_context, self)
-
     def get_calling_nodes(self):
         return []
 
@@ -157,29 +138,12 @@ class AbstractArguments(_AbstractArgumentsMixin):
     trailer = None
 
 
-class AnonymousArguments(AbstractArguments):
-    def get_executed_params_and_issues(self, execution_context):
-        from jedi.evaluate.dynamic import search_params
-        return search_params(
-            execution_context.evaluator,
-            execution_context,
-            execution_context.tree_node
-        ), []
-
-    def __repr__(self):
-        return '%s()' % self.__class__.__name__
-
-
 def unpack_arglist(arglist):
     if arglist is None:
         return
 
-    # Allow testlist here as well for Python2's class inheritance
-    # definitions.
-    if not (arglist.type in ('arglist', 'testlist') or (
-            # in python 3.5 **arg is an argument, not arglist
-            (arglist.type == 'argument') and
-            arglist.children[0] in ('*', '**'))):
+    if arglist.type != 'arglist' and not (
+            arglist.type == 'argument' and arglist.children[0] in ('*', '**')):
         yield 0, arglist
         return
 
@@ -188,7 +152,9 @@ def unpack_arglist(arglist):
         if child == ',':
             continue
         elif child in ('*', '**'):
-            yield len(child.value), next(iterator)
+            c = next(iterator, None)
+            assert c is not None
+            yield len(child.value), c
         elif child.type == 'argument' and \
                 child.children[0] in ('*', '**'):
             assert len(child.children) == 2
@@ -198,21 +164,17 @@ def unpack_arglist(arglist):
 
 
 class TreeArguments(AbstractArguments):
-    def __init__(self, evaluator, context, argument_node, trailer=None):
+    def __init__(self, inference_state, context, argument_node, trailer=None):
         """
-        The argument_node is either a parser node or a list of evaluated
-        objects. Those evaluated objects may be lists of evaluated objects
-        themselves (one list for the first argument, one for the second, etc).
-
         :param argument_node: May be an argument_node or a list of nodes.
         """
         self.argument_node = argument_node
         self.context = context
-        self._evaluator = evaluator
+        self._inference_state = inference_state
         self.trailer = trailer  # Can be None, e.g. in a class definition.
 
     @classmethod
-    @evaluator_as_method_param_cache()
+    @inference_state_as_method_param_cache()
     def create_cached(cls, *args, **kwargs):
         return cls(*args, **kwargs)
 
@@ -220,44 +182,40 @@ class TreeArguments(AbstractArguments):
         named_args = []
         for star_count, el in unpack_arglist(self.argument_node):
             if star_count == 1:
-                arrays = self.context.eval_node(el)
+                arrays = self.context.infer_node(el)
                 iterators = [_iterate_star_args(self.context, a, el, funcdef)
                              for a in arrays]
                 for values in list(zip_longest(*iterators)):
-                    # TODO zip_longest yields None, that means this would raise
-                    # an exception?
-                    yield None, get_merged_lazy_context(
+                    yield None, get_merged_lazy_value(
                         [v for v in values if v is not None]
                     )
             elif star_count == 2:
-                arrays = self.context.eval_node(el)
+                arrays = self.context.infer_node(el)
                 for dct in arrays:
-                    for key, values in _star_star_dict(self.context, dct, el, funcdef):
-                        yield key, values
+                    yield from _star_star_dict(self.context, dct, el, funcdef)
             else:
                 if el.type == 'argument':
                     c = el.children
                     if len(c) == 3:  # Keyword argument.
-                        named_args.append((c[0].value, LazyTreeContext(self.context, c[2]),))
+                        named_args.append((c[0].value, LazyTreeValue(self.context, c[2]),))
                     else:  # Generator comprehension.
                         # Include the brackets with the parent.
                         sync_comp_for = el.children[1]
                         if sync_comp_for.type == 'comp_for':
                             sync_comp_for = sync_comp_for.children[1]
                         comp = iterable.GeneratorComprehension(
-                            self._evaluator,
+                            self._inference_state,
                             defining_context=self.context,
                             sync_comp_for_node=sync_comp_for,
                             entry_node=el.children[0],
                         )
-                        yield None, LazyKnownContext(comp)
+                        yield None, LazyKnownValue(comp)
                 else:
-                    yield None, LazyTreeContext(self.context, el)
+                    yield None, LazyTreeValue(self.context, el)
 
         # Reordering arguments is necessary, because star args sometimes appear
         # after named argument, but in the actual order it's prepended.
-        for named_arg in named_args:
-            yield named_arg
+        yield from named_args
 
     def _as_tree_tuple_objects(self):
         for star_count, argument in unpack_arglist(self.argument_node):
@@ -279,7 +237,6 @@ class TreeArguments(AbstractArguments):
         return '<%s: %s>' % (self.__class__.__name__, self.argument_node)
 
     def get_calling_nodes(self):
-        from jedi.evaluate.dynamic import DynamicExecutedParams
         old_arguments_list = []
         arguments = self
 
@@ -292,17 +249,14 @@ class TreeArguments(AbstractArguments):
                 names = calling_name.goto()
                 if len(names) != 1:
                     break
+                if isinstance(names[0], AnonymousParamName):
+                    # Dynamic parameters should not have calling nodes, because
+                    # they are dynamic and extremely random.
+                    return []
                 if not isinstance(names[0], ParamName):
                     break
-                param = names[0].get_param()
-                if isinstance(param, DynamicExecutedParams):
-                    # For dynamic searches we don't even want to see errors.
-                    return []
-                if not isinstance(param, ExecutedParam):
-                    break
-                if param.var_args is None:
-                    break
-                arguments = param.var_args
+                executed_param_name = names[0].get_executed_param_name()
+                arguments = executed_param_name.arguments
                 break
 
         if arguments.argument_node is not None:
@@ -318,7 +272,7 @@ class ValuesArguments(AbstractArguments):
 
     def unpack(self, funcdef=None):
         for values in self._values_list:
-            yield None, LazyKnownContexts(values)
+            yield None, LazyKnownValues(values)
 
     def __repr__(self):
         return '<%s: %s>' % (self.__class__.__name__, self._values_list)
@@ -362,12 +316,11 @@ def _iterate_star_args(context, array, input_node, funcdef=None):
     except AttributeError:
         pass
     else:
-        for lazy_context in iter_():
-            yield lazy_context
+        yield from iter_()
 
 
 def _star_star_dict(context, array, input_node, funcdef):
-    from jedi.evaluate.context.instance import CompiledInstance
+    from jedi.inference.value.instance import CompiledInstance
     if isinstance(array, CompiledInstance) and array.name.string_name == 'dict':
         # For now ignore this case. In the future add proper iterators and just
         # make one call without crazy isinstance checks.

jedi/inference/base_value.py

@@ -0,0 +1,558 @@
+"""
+Values are the "values" that Python would return. However Values are at the
+same time also the "values" that a user is currently sitting in.
+
+A ValueSet is typically used to specify the return of a function or any other
+static analysis operation. In jedi there are always multiple returns and not
+just one.
+"""
+from functools import reduce
+from operator import add
+from itertools import zip_longest
+
+from parso.python.tree import Name
+
+from jedi import debug
+from jedi.parser_utils import clean_scope_docstring
+from jedi.inference.helpers import SimpleGetItemNotFound
+from jedi.inference.utils import safe_property
+from jedi.inference.cache import inference_state_as_method_param_cache
+from jedi.cache import memoize_method
+
+sentinel = object()
+
+
+class HasNoContext(Exception):
+    pass
+
+
+class HelperValueMixin:
+    def get_root_context(self):
+        value = self
+        if value.parent_context is None:
+            return value.as_context()
+
+        while True:
+            if value.parent_context is None:
+                return value
+            value = value.parent_context
+
+    def execute(self, arguments):
+        return self.inference_state.execute(self, arguments=arguments)
+
+    def execute_with_values(self, *value_list):
+        from jedi.inference.arguments import ValuesArguments
+        arguments = ValuesArguments([ValueSet([value]) for value in value_list])
+        return self.inference_state.execute(self, arguments)
+
+    def execute_annotation(self):
+        return self.execute_with_values()
+
+    def gather_annotation_classes(self):
+        return ValueSet([self])
+
+    def merge_types_of_iterate(self, contextualized_node=None, is_async=False):
+        return ValueSet.from_sets(
+            lazy_value.infer()
+            for lazy_value in self.iterate(contextualized_node, is_async)
+        )
+
+    def _get_value_filters(self, name_or_str):
+        origin_scope = name_or_str if isinstance(name_or_str, Name) else None
+        yield from self.get_filters(origin_scope=origin_scope)
+        # This covers the case where a stub files are incomplete.
+        if self.is_stub():
+            from jedi.inference.gradual.conversion import convert_values
+            for c in convert_values(ValueSet({self})):
+                yield from c.get_filters()
+
+    def goto(self, name_or_str, name_context=None, analysis_errors=True):
+        from jedi.inference import finder
+        filters = self._get_value_filters(name_or_str)
+        names = finder.filter_name(filters, name_or_str)
+        debug.dbg('context.goto %s in (%s): %s', name_or_str, self, names)
+        return names
+
+    def py__getattribute__(self, name_or_str, name_context=None, position=None,
+                           analysis_errors=True):
+        """
+        :param position: Position of the last statement -> tuple of line, column
+        """
+        if name_context is None:
+            name_context = self
+        names = self.goto(name_or_str, name_context, analysis_errors)
+        values = ValueSet.from_sets(name.infer() for name in names)
+        if not values:
+            n = name_or_str.value if isinstance(name_or_str, Name) else name_or_str
+            values = self.py__getattribute__alternatives(n)
+
+        if not names and not values and analysis_errors:
+            if isinstance(name_or_str, Name):
+                from jedi.inference import analysis
+                analysis.add_attribute_error(
+                    name_context, self, name_or_str)
+        debug.dbg('context.names_to_types: %s -> %s', names, values)
+        return values
+
+    def py__await__(self):
+        await_value_set = self.py__getattribute__("__await__")
+        if not await_value_set:
+            debug.warning('Tried to run __await__ on value %s', self)
+        return await_value_set.execute_with_values()
+
+    def py__name__(self):
+        return self.name.string_name
+
+    def iterate(self, contextualized_node=None, is_async=False):
+        debug.dbg('iterate %s', self)
+        if is_async:
+            from jedi.inference.lazy_value import LazyKnownValues
+            # TODO if no __aiter__ values are there, error should be:
+            # TypeError: 'async for' requires an object with __aiter__ method, got int
+            return iter([
+                LazyKnownValues(
+                    self.py__getattribute__('__aiter__').execute_with_values()
+                        .py__getattribute__('__anext__').execute_with_values()
+                        .py__getattribute__('__await__').execute_with_values()
+                        .py__stop_iteration_returns()
+                )  # noqa: E124
+            ])
+        return self.py__iter__(contextualized_node)
+
+    def is_sub_class_of(self, class_value):
+        with debug.increase_indent_cm('subclass matching of %s <=> %s' % (self, class_value),
+                                      color='BLUE'):
+            for cls in self.py__mro__():
+                if cls.is_same_class(class_value):
+                    debug.dbg('matched subclass True', color='BLUE')
+                    return True
+            debug.dbg('matched subclass False', color='BLUE')
+            return False
+
+    def is_same_class(self, class2):
+        # Class matching should prefer comparisons that are not this function.
+        if type(class2).is_same_class != HelperValueMixin.is_same_class:
+            return class2.is_same_class(self)
+        return self == class2
+
+    @memoize_method
+    def as_context(self, *args, **kwargs):
+        return self._as_context(*args, **kwargs)
+
+
+class Value(HelperValueMixin):
+    """
+    To be implemented by subclasses.
+    """
+    tree_node = None
+    # Possible values: None, tuple, list, dict and set. Here to deal with these
+    # very important containers.
+    array_type = None
+    api_type = 'not_defined_please_report_bug'
+
+    def __init__(self, inference_state, parent_context=None):
+        self.inference_state = inference_state
+        self.parent_context = parent_context
+
+    def py__getitem__(self, index_value_set, contextualized_node):
+        from jedi.inference import analysis
+        # TODO this value is probably not right.
+        analysis.add(
+            contextualized_node.context,
+            'type-error-not-subscriptable',
+            contextualized_node.node,
+            message="TypeError: '%s' object is not subscriptable" % self
+        )
+        return NO_VALUES
+
+    def py__simple_getitem__(self, index):
+        raise SimpleGetItemNotFound
+
+    def py__iter__(self, contextualized_node=None):
+        if contextualized_node is not None:
+            from jedi.inference import analysis
+            analysis.add(
+                contextualized_node.context,
+                'type-error-not-iterable',
+                contextualized_node.node,
+                message="TypeError: '%s' object is not iterable" % self)
+        return iter([])
+
+    def py__next__(self, contextualized_node=None):
+        return self.py__iter__(contextualized_node)
+
+    def get_signatures(self):
+        return []
+
+    def is_class(self):
+        return False
+
+    def is_class_mixin(self):
+        return False
+
+    def is_instance(self):
+        return False
+
+    def is_function(self):
+        return False
+
+    def is_module(self):
+        return False
+
+    def is_namespace(self):
+        return False
+
+    def is_compiled(self):
+        return False
+
+    def is_bound_method(self):
+        return False
+
+    def is_builtins_module(self):
+        return False
+
+    def py__bool__(self):
+        """
+        Since Wrapper is a super class for classes, functions and modules,
+        the return value will always be true.
+        """
+        return True
+
+    def py__doc__(self):
+        try:
+            self.tree_node.get_doc_node
+        except AttributeError:
+            return ''
+        else:
+            return clean_scope_docstring(self.tree_node)
+
+    def get_safe_value(self, default=sentinel):
+        if default is sentinel:
+            raise ValueError("There exists no safe value for value %s" % self)
+        return default
+
+    def execute_operation(self, other, operator):
+        debug.warning("%s not possible between %s and %s", operator, self, other)
+        return NO_VALUES
+
+    def py__call__(self, arguments):
+        debug.warning("no execution possible %s", self)
+        return NO_VALUES
+
+    def py__stop_iteration_returns(self):
+        debug.warning("Not possible to return the stop iterations of %s", self)
+        return NO_VALUES
+
+    def py__getattribute__alternatives(self, name_or_str):
+        """
+        For now a way to add values in cases like __getattr__.
+        """
+        return NO_VALUES
+
+    def py__get__(self, instance, class_value):
+        debug.warning("No __get__ defined on %s", self)
+        return ValueSet([self])
+
+    def py__get__on_class(self, calling_instance, instance, class_value):
+        return NotImplemented
+
+    def get_qualified_names(self):
+        # Returns Optional[Tuple[str, ...]]
+        return None
+
+    def is_stub(self):
+        # The root value knows if it's a stub or not.
+        return self.parent_context.is_stub()
+
+    def _as_context(self):
+        raise HasNoContext
+
+    @property
+    def name(self):
+        raise NotImplementedError
+
+    def get_type_hint(self, add_class_info=True):
+        return None
+
+    def infer_type_vars(self, value_set):
+        """
+        When the current instance represents a type annotation, this method
+        tries to find information about undefined type vars and returns a dict
+        from type var name to value set.
+
+        This is for example important to understand what `iter([1])` returns.
+        According to typeshed, `iter` returns an `Iterator[_T]`:
+
+            def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
+
+        This functions would generate `int` for `_T` in this case, because it
+        unpacks the `Iterable`.
+
+        Parameters
+        ----------
+
+        `self`: represents the annotation of the current parameter to infer the
+            value for. In the above example, this would initially be the
+            `Iterable[_T]` of the `iterable` parameter and then, when recursing,
+            just the `_T` generic parameter.
+
+        `value_set`: represents the actual argument passed to the parameter
+            we're inferred for, or (for recursive calls) their types. In the
+            above example this would first be the representation of the list
+            `[1]` and then, when recursing, just of `1`.
+        """
+        return {}
+
+
+def iterate_values(values, contextualized_node=None, is_async=False):
+    """
+    Calls `iterate`, on all values but ignores the ordering and just returns
+    all values that the iterate functions yield.
+    """
+    return ValueSet.from_sets(
+        lazy_value.infer()
+        for lazy_value in values.iterate(contextualized_node, is_async=is_async)
+    )
+
+
+class _ValueWrapperBase(HelperValueMixin):
+    @safe_property
+    def name(self):
+        from jedi.inference.names import ValueName
+        wrapped_name = self._wrapped_value.name
+        if wrapped_name.tree_name is not None:
+            return ValueName(self, wrapped_name.tree_name)
+        else:
+            from jedi.inference.compiled import CompiledValueName
+            return CompiledValueName(self, wrapped_name.string_name)
+
+    @classmethod
+    @inference_state_as_method_param_cache()
+    def create_cached(cls, inference_state, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    def __getattr__(self, name):
+        assert name != '_wrapped_value', 'Problem with _get_wrapped_value'
+        return getattr(self._wrapped_value, name)
+
+
+class LazyValueWrapper(_ValueWrapperBase):
+    @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__)
+
+    def _get_wrapped_value(self):
+        raise NotImplementedError
+
+
+class ValueWrapper(_ValueWrapperBase):
+    def __init__(self, wrapped_value):
+        self._wrapped_value = wrapped_value
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self._wrapped_value)
+
+
+class TreeValue(Value):
+    def __init__(self, inference_state, parent_context, tree_node):
+        super().__init__(inference_state, parent_context)
+        self.tree_node = tree_node
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.tree_node)
+
+
+class ContextualizedNode:
+    def __init__(self, context, node):
+        self.context = context
+        self.node = node
+
+    def get_root_context(self):
+        return self.context.get_root_context()
+
+    def infer(self):
+        return self.context.infer_node(self.node)
+
+    def __repr__(self):
+        return '<%s: %s in %s>' % (self.__class__.__name__, self.node, self.context)
+
+
+def _getitem(value, index_values, contextualized_node):
+    # The actual getitem call.
+    result = NO_VALUES
+    unused_values = set()
+    for index_value in index_values:
+        index = index_value.get_safe_value(default=None)
+        if type(index) in (float, int, str, slice, bytes):
+            try:
+                result |= value.py__simple_getitem__(index)
+                continue
+            except SimpleGetItemNotFound:
+                pass
+
+        unused_values.add(index_value)
+
+    # The index was somehow not good enough or simply a wrong type.
+    # Therefore we now iterate through all the values and just take
+    # all results.
+    if unused_values or not index_values:
+        result |= value.py__getitem__(
+            ValueSet(unused_values),
+            contextualized_node
+        )
+    debug.dbg('py__getitem__ result: %s', result)
+    return result
+
+
+class ValueSet:
+    def __init__(self, iterable):
+        self._set = frozenset(iterable)
+        for value in iterable:
+            assert not isinstance(value, ValueSet)
+
+    @classmethod
+    def _from_frozen_set(cls, frozenset_):
+        self = cls.__new__(cls)
+        self._set = frozenset_
+        return self
+
+    @classmethod
+    def from_sets(cls, sets):
+        """
+        Used to work with an iterable of set.
+        """
+        aggregated = set()
+        for set_ in sets:
+            if isinstance(set_, ValueSet):
+                aggregated |= set_._set
+            else:
+                aggregated |= frozenset(set_)
+        return cls._from_frozen_set(frozenset(aggregated))
+
+    def __or__(self, other):
+        return self._from_frozen_set(self._set | other._set)
+
+    def __and__(self, other):
+        return self._from_frozen_set(self._set & other._set)
+
+    def __iter__(self):
+        return iter(self._set)
+
+    def __bool__(self):
+        return bool(self._set)
+
+    def __len__(self):
+        return len(self._set)
+
+    def __repr__(self):
+        return 'S{%s}' % (', '.join(str(s) for s in self._set))
+
+    def filter(self, filter_func):
+        return self.__class__(filter(filter_func, self._set))
+
+    def __getattr__(self, name):
+        def mapper(*args, **kwargs):
+            return self.from_sets(
+                getattr(value, name)(*args, **kwargs)
+                for value in self._set
+            )
+        return mapper
+
+    def __eq__(self, other):
+        return self._set == other._set
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(self._set)
+
+    def py__class__(self):
+        return ValueSet(c.py__class__() for c in self._set)
+
+    def iterate(self, contextualized_node=None, is_async=False):
+        from jedi.inference.lazy_value import get_merged_lazy_value
+        type_iters = [c.iterate(contextualized_node, is_async=is_async) for c in self._set]
+        for lazy_values in zip_longest(*type_iters):
+            yield get_merged_lazy_value(
+                [l for l in lazy_values if l is not None]
+            )
+
+    def execute(self, arguments):
+        return ValueSet.from_sets(c.inference_state.execute(c, arguments) for c in self._set)
+
+    def execute_with_values(self, *args, **kwargs):
+        return ValueSet.from_sets(c.execute_with_values(*args, **kwargs) for c in self._set)
+
+    def goto(self, *args, **kwargs):
+        return reduce(add, [c.goto(*args, **kwargs) for c in self._set], [])
+
+    def py__getattribute__(self, *args, **kwargs):
+        return ValueSet.from_sets(c.py__getattribute__(*args, **kwargs) for c in self._set)
+
+    def get_item(self, *args, **kwargs):
+        return ValueSet.from_sets(_getitem(c, *args, **kwargs) for c in self._set)
+
+    def try_merge(self, function_name):
+        value_set = self.__class__([])
+        for c in self._set:
+            try:
+                method = getattr(c, function_name)
+            except AttributeError:
+                pass
+            else:
+                value_set |= method()
+        return value_set
+
+    def gather_annotation_classes(self):
+        return ValueSet.from_sets([c.gather_annotation_classes() for c in self._set])
+
+    def get_signatures(self):
+        return [sig for c in self._set for sig in c.get_signatures()]
+
+    def get_type_hint(self, add_class_info=True):
+        t = [v.get_type_hint(add_class_info=add_class_info) for v in self._set]
+        type_hints = sorted(filter(None, t))
+        if len(type_hints) == 1:
+            return type_hints[0]
+
+        optional = 'None' in type_hints
+        if optional:
+            type_hints.remove('None')
+
+        if len(type_hints) == 0:
+            return None
+        elif len(type_hints) == 1:
+            s = type_hints[0]
+        else:
+            s = 'Union[%s]' % ', '.join(type_hints)
+        if optional:
+            s = 'Optional[%s]' % s
+        return s
+
+    def infer_type_vars(self, value_set):
+        # Circular
+        from jedi.inference.gradual.annotation import merge_type_var_dicts
+
+        type_var_dict = {}
+        for value in self._set:
+            merge_type_var_dicts(
+                type_var_dict,
+                value.infer_type_vars(value_set),
+            )
+        return type_var_dict
+
+
+NO_VALUES = ValueSet([])
+
+
+def iterator_to_value_set(func):
+    def wrapper(*args, **kwargs):
+        return ValueSet(func(*args, **kwargs))
+
+    return wrapper