Remove Python 3.3 from environment tests

Fixes #952
Inspired by #1461

.coveragerc

@@ -1,10 +1,8 @@
 [run]
 omit =
     jedi/_compatibility.py
-    jedi/evaluate/compiled/subprocess/__main__.py
+    jedi/inference/compiled/subprocess/__main__.py
     jedi/__main__.py
-    # Is statically analyzed and not actually executed.
-    jedi/evaluate/jedi_typing.py
     # For now this is not being used.
     jedi/refactoring.py
 
@@ -13,3 +11,4 @@ omit =
 exclude_lines =
     # Don't complain about missing debug-only code:
     def __repr__
+    debug.warning

.github/FUNDING.yml

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

.gitmodules

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

.travis.yml

@@ -1,59 +1,73 @@
+dist: xenial
 language: python
-sudo: true
 python:
   - 2.7
-  - 3.3
   - 3.4
   - 3.5
   - 3.6
+  - 3.7
+  - 3.8
 
 env:
   - JEDI_TEST_ENVIRONMENT=27
-  - JEDI_TEST_ENVIRONMENT=33
   - JEDI_TEST_ENVIRONMENT=34
   - JEDI_TEST_ENVIRONMENT=35
   - JEDI_TEST_ENVIRONMENT=36
-
-addons:
-  apt:
-    packages:
-     # Required to properly create a virtual environment with system Python 3.4.
-     - python3.4-venv
+  - JEDI_TEST_ENVIRONMENT=37
+  - JEDI_TEST_ENVIRONMENT=38
+  - JEDI_TEST_ENVIRONMENT=interpreter
 
 matrix:
-  allow_failures:
-    - python: pypy
-    - env: TOXENV=sith
-    - env:
-        - TOXENV=cov
-        - JEDI_TEST_ENVIRONMENT=36
-    - python: 3.7-dev
   include:
-    - python: 3.6
+    - python: 3.7
       env:
-        - TOXENV=cov
-        - JEDI_TEST_ENVIRONMENT=36
-    - python: 3.6
-      env: TOXENV=sith
+        - TOXENV=cov-py37
+        - JEDI_TEST_ENVIRONMENT=37
     # For now ignore pypy, there are so many issues that we don't really need
     # to run it.
     #- python: pypy
-    - python: "3.7-dev"
-before_install:
-    - ./travis_install.sh
-    # Need to add the path to the Python versions in the end. This might add
-    # something twice, but it doesn't really matter, because they are appended.
-    - export PATH=$PATH:/opt/python/3.3/bin
-    - export PATH=$PATH:/opt/python/3.5/bin
-    # 3.6 was not installed manually, but already is on the system. However
-    # it's not on path (unless 3.6 is selected).
-    - export PATH=$PATH:/opt/python/3.6/bin
+    # The 3.9 dev build does not seem to be available end 2019.
+    #- python: 3.9-dev
+    #  env:
+    #    - JEDI_TEST_ENVIRONMENT=39
 install:
     - pip install --quiet tox-travis
+    - sudo apt-get -y install python3-venv
 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" ] && [ "$JEDI_TEST_ENVIRONMENT" != "interpreter" ]; 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 coveralls;
-      coveralls;
+    - |
+      if [ $TOXENV == "cov-py37" ]; 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

@@ -50,5 +50,10 @@ 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>
 
 Note: (@user) means a github user name.

CHANGELOG.rst

@@ -3,6 +3,128 @@
 Changelog
 ---------
 
+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()``
+- ``BaseDefinition.goto_assignments`` renamed to ``BaseDefinition.goto``
+- Add follow_imports to ``Definition.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)
++++++++++++++++++++
+
+- Small bugfix and removal of a print statement
+
+0.15.0 (2019-08-11)
++++++++++++++++++++
+
+- 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
+- When using Interpreter, properties are now executed, since a lot of people
+  have complained about this. Discussion in #1299, #1347.
+
+New APIs:
+
+- ``Definition.get_signatures() -> List[Signature]``. Signatures are similar to
+  ``CallSignature``. ``Definition.params`` is therefore deprecated.
+- ``Signature.to_string()`` to format signatures.
+- ``Signature.params -> List[ParamDefinition]``, ParamDefinition 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.
+
+
+0.14.1 (2019-07-13)
++++++++++++++++++++
+
+- CallSignature.index should now be working a lot better
+- A couple of smaller bugfixes
+
+0.14.0 (2019-06-20)
++++++++++++++++++++
+
+- 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
+
+0.13.3 (2019-02-24)
++++++++++++++++++++
+
+- Fixed an issue with embedded Python, see https://github.com/davidhalter/jedi-vim/issues/870
+
+0.13.2 (2018-12-15)
++++++++++++++++++++
+
+- Fixed a bug that led to Jedi spawning a lot of subprocesses.
+
+0.13.1 (2018-10-02)
++++++++++++++++++++
+
+- Bugfixes, because tensorflow completions were still slow.
+
+0.13.0 (2018-10-02)
++++++++++++++++++++
+
+- A small release. Some bug fixes.
+- Remove Python 3.3 support. Python 3.3 support has been dropped by the Python
+  foundation.
+- Default environments are now using the same Python version as the Python
+  process. In 0.12.x, we used to load the latest Python version on the system.
+- Added ``include_builtins`` as a parameter to usages.
+- ``goto_assignments`` has a new ``follow_builtin_imports`` parameter that
+  changes the previous behavior slightly.
+
+0.12.1 (2018-06-30)
++++++++++++++++++++
+
+- This release forces you to upgrade parso. If you don't, nothing will work
+  anymore. Otherwise changes should be limited to bug fixes. Unfortunately Jedi
+  still uses a few internals of parso that make it hard to keep compatibility
+  over multiple releases. Parso >=0.3.0 is going to be needed.
+
 0.12.0 (2018-04-15)
 +++++++++++++++++++
 
@@ -54,12 +176,12 @@ Changelog
 ++++++++++++++++++
 
 - 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!

CONTRIBUTING.md

@@ -5,4 +5,4 @@ Pull Requests are great.
  3. Add your name to AUTHORS.txt
  4. Push to your fork and submit a pull request.
 
-**Try to use the PEP8 style guide.**
+**Try to use the PEP8 style guide** (and it's ok to have a line length of 100 characters).

MANIFEST.in

@@ -8,8 +8,10 @@ include conftest.py
 include pytest.ini
 include tox.ini
 include requirements.txt
-include jedi/evaluate/compiled/fake/*.pym
 include jedi/parser/python/grammar*.txt
+recursive-include jedi/third_party *.pyi
+include jedi/third_party/typeshed/LICENSE
+include jedi/third_party/typeshed/README
 recursive-include test *
 recursive-include docs *
 recursive-exclude * *.pyc

README.rst

@@ -27,20 +27,18 @@ Jedi - an awesome autocompletion/static analysis library for Python
 <https://stackoverflow.com/questions/tagged/python-jedi>`_ *with the label* ``python-jedi``.
 
 
-Jedi is a static analysis tool for Python that can be used in IDEs/editors. Its
-historic focus is autocompletion, but does static analysis for now as well.
-Jedi is fast and is very well tested. It understands Python on a deeper level
-than all other static analysis frameworks for Python.
+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 two different goto functions. It's possible to search for
-related names and to list all names in a Python file and infer them. Jedi
-understands docstrings and you can use Jedi autocompletion in your REPL as
-well.
+Jedi has support for different goto functions. It's possible to search for
+references and list names in a Python file to get information about them.
 
-Jedi uses a very simple API to connect with IDEs. There's a reference
+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.
-It's really easy.
+Autocompletion in your REPL is also possible, IPython uses it natively and for
+the CPython REPL you have to install it.
 
 Jedi can currently be used with the following editors/projects:
 
@@ -111,8 +109,8 @@ 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.3+ but it should also
-understand/parse code older than those versions. Additonally you should be able
+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>`_
 very well.
 
@@ -122,7 +120,7 @@ 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/plugin-api.html>`_.
+You can find the documentation for the `API here <https://jedi.readthedocs.org/en/latest/docs/api.html>`_.
 
 
 Autocompletion / Goto / Pydoc
@@ -130,9 +128,9 @@ Autocompletion / Goto / Pydoc
 
 Please check the API for a good explanation. There are the following commands:
 
-- ``jedi.Script.goto_assignments``
-- ``jedi.Script.completions``
-- ``jedi.Script.usages``
+- ``jedi.Script.goto``
+- ``jedi.Script.complete``
+- ``jedi.Script.get_references``
 
 The returned objects are very powerful and really all you might need.
 
@@ -148,16 +146,12 @@ This means that in Python 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 / Linter
+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.
-
-Linting is another thing that is going to be part of Jedi. For now you can try
-an alpha version ``python -m jedi linter``. The API might change though and
-it's still buggy. It's Jedi's goal to be smarter than classic linter and
-understand ``AttributeError`` and other code issues.
+To do all forms of static analysis, please try to use
+``jedi.Script(...).get_names``. It will return a list of names that you can use
+to infer types and so on.
 
 
 Refactoring
@@ -210,7 +204,7 @@ Acknowledgements
 
 
 .. _jedi-vim: https://github.com/davidhalter/jedi-vim
-.. _youcompleteme: https://valloric.github.io/YouCompleteMe/
+.. _youcompleteme: https://github.com/ycm-core/YouCompleteMe
 .. _deoplete-jedi: https://github.com/zchee/deoplete-jedi
 .. _completor.vim: https://github.com/maralla/completor.vim
 .. _Jedi.el: https://github.com/tkf/emacs-jedi

appveyor.yml

@@ -3,9 +3,6 @@ environment:
   - TOXENV: py27
     PYTHON_PATH: C:\Python27
     JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py27
-    PYTHON_PATH: C:\Python27
-    JEDI_TEST_ENVIRONMENT: 33
   - TOXENV: py27
     PYTHON_PATH: C:\Python27
     JEDI_TEST_ENVIRONMENT: 34
@@ -15,45 +12,13 @@ environment:
   - TOXENV: py27
     PYTHON_PATH: C:\Python27
     JEDI_TEST_ENVIRONMENT: 36
-
-  - TOXENV: py33
-    PYTHON_PATH: C:\Python33
-    JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py33
-    PYTHON_PATH: C:\Python33
-    JEDI_TEST_ENVIRONMENT: 33
-  - TOXENV: py33
-    PYTHON_PATH: C:\Python33
-    JEDI_TEST_ENVIRONMENT: 34
-  - TOXENV: py33
-    PYTHON_PATH: C:\Python33
-    JEDI_TEST_ENVIRONMENT: 35
-  - TOXENV: py33
-    PYTHON_PATH: C:\Python33
-    JEDI_TEST_ENVIRONMENT: 36
-
-  - TOXENV: py34
-    PYTHON_PATH: C:\Python34
-    JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py34
-    PYTHON_PATH: C:\Python34
-    JEDI_TEST_ENVIRONMENT: 33
-  - 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: py27
+    PYTHON_PATH: C:\Python27
+    JEDI_TEST_ENVIRONMENT: 37
 
   - TOXENV: py35
     PYTHON_PATH: C:\Python35
     JEDI_TEST_ENVIRONMENT: 27
-  - TOXENV: py35
-    PYTHON_PATH: C:\Python35
-    JEDI_TEST_ENVIRONMENT: 33
   - TOXENV: py35
     PYTHON_PATH: C:\Python35
     JEDI_TEST_ENVIRONMENT: 34
@@ -63,13 +28,13 @@ environment:
   - 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: 33
   - TOXENV: py36
     PYTHON_PATH: C:\Python36
     JEDI_TEST_ENVIRONMENT: 34
@@ -79,7 +44,27 @@ environment:
   - 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:

conftest.py

@@ -1,28 +1,32 @@
 import tempfile
 import shutil
 import os
+import sys
 from functools import partial
 
 import pytest
 
 import jedi
-from jedi.api.environment import get_default_environment, get_system_environment
+from jedi.api.environment import get_system_environment, InterpreterEnvironment
 from jedi._compatibility import py_version
 
 collect_ignore = [
     'setup.py',
     '__main__.py',
-    'jedi/evaluate/compiled/subprocess/__main__.py',
+    'jedi/inference/compiled/subprocess/__main__.py',
     'build/',
     'test/examples',
 ]
+if sys.version_info < (3, 6):
+    # Python 2 not supported syntax
+    collect_ignore.append('test/test_inference/test_mixed.py')
 
 
 # The following hooks (pytest_configure, pytest_unconfigure) are used
 # to modify `jedi.settings.cache_directory` because `clean_jedi_cache`
 # has no effect during doctests.  Without these hooks, doctests uses
 # user's cache (e.g., ~/.cache/jedi/).  We should remove this
-# workaround once the problem is fixed in py.test.
+# workaround once the problem is fixed in pytest.
 #
 # See:
 # - https://github.com/davidhalter/jedi/pull/168
@@ -41,6 +45,9 @@ def pytest_addoption(parser):
 
     parser.addoption("--env", action='store',
                      help="Execute the tests in that environment (e.g. 35 for python3.5).")
+    parser.addoption("--interpreter-env", "-I", action='store_true',
+                     help="Don't use subprocesses to guarantee having safe "
+                          "code execution. Useful for debugging.")
 
 
 def pytest_configure(config):
@@ -91,8 +98,8 @@ def environment(request):
     if version is None:
         version = os.environ.get('JEDI_TEST_ENVIRONMENT', str(py_version))
 
-    if int(version) == py_version:
-        return get_default_environment()
+    if request.config.option.interpreter_env or version == 'interpreter':
+        return InterpreterEnvironment()
 
     return get_system_environment(version[0] + '.' + version[1:])
 
@@ -102,6 +109,26 @@ def Script(environment):
     return partial(jedi.Script, environment=environment)
 
 
+@pytest.fixture(scope='session')
+def get_names(Script):
+    return lambda code, **kwargs: Script(code).get_names(**kwargs)
+
+
+@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):
+    return lambda code, *args, **kwargs: getattr(Script(code), request.param)(*args, **kwargs)
+
+
 @pytest.fixture(scope='session')
 def has_typing(environment):
     if environment.version_info >= (3, 5, 0):
@@ -110,9 +137,49 @@ def has_typing(environment):
         return True
 
     script = jedi.Script('import typing', environment=environment)
-    return bool(script.goto_definitions())
+    return bool(script.infer())
 
 
 @pytest.fixture(scope='session')
 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):
+        # This if is just needed to avoid that tests ever skip way more than
+        # they should for all Python versions.
+        pytest.skip()
+
+
+@pytest.fixture()
+def skip_pre_python37(environment):
+    if environment.version_info < (3, 7):
+        # This if is just needed to avoid that tests ever skip way more than
+        # they should for all Python versions.
+        pytest.skip()
+
+
+@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()
+
+
+@pytest.fixture()
+def skip_pre_python36(environment):
+    if environment.version_info < (3, 6):
+        # 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

@@ -21,6 +21,7 @@ rm -rf $PROJECT_NAME
 git clone .. $PROJECT_NAME
 cd $PROJECT_NAME
 git checkout $BRANCH
+git submodule update --init
 
 # Test first.
 tox

docs/docs/api.rst

@@ -29,9 +29,8 @@ 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`
+- The main starting points for complete/goto: :class:`.Script` and :class:`.Interpreter`
+- Helpful functions: :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`
@@ -47,7 +46,6 @@ Static Analysis Interface
     :members:
 .. autoclass:: jedi.Interpreter
     :members:
-.. autofunction:: jedi.names
 .. autofunction:: jedi.preload_module
 .. autofunction:: jedi.set_debug_function
 
@@ -76,10 +74,10 @@ Completions:
 
    >>> import jedi
    >>> source = '''import json; json.l'''
-   >>> script = jedi.Script(source, 1, 19, '')
+   >>> script = jedi.Script(source, path='')
    >>> script
    <jedi.api.Script object at 0x2121b10>
-   >>> completions = script.completions()
+   >>> completions = script.complete(1, 19)
    >>> completions
    [<Completion: load>, <Completion: loads>]
    >>> completions[1]
@@ -102,15 +100,15 @@ Definitions / Goto:
     ... inception = my_list[2]
     ... 
     ... inception()'''
-    >>> script = jedi.Script(source, 8, 1, '')
+    >>> script = jedi.Script(source, path='')
     >>>
-    >>> script.goto_assignments()
+    >>> script.goto(8, 1)
     [<Definition inception=my_list[2]>]
     >>>
-    >>> script.goto_definitions()
+    >>> script.infer(8, 1)
     [<Definition def my_func>]
 
-Related names:
+References:
 
 .. sourcecode:: python
 
@@ -120,13 +118,12 @@ Related names:
     ...     x = 4
     ... else:
     ...     del x'''
-    >>> script = jedi.Script(source, 5, 8, '')
-    >>> rns = script.related_names()
+    >>> script = jedi.Script(source, '')
+    >>> 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'
+    [<Definition full_name='__main__.x', description='x = 3'>,
+     <Definition full_name='__main__.x', description='x'>]
+    >>> rns[1].line
+    5
+    >>> rns[0].column
+    8

docs/docs/development.rst

@@ -8,6 +8,8 @@ Jedi Development
 .. note:: This documentation is for Jedi developers who want to improve Jedi
     itself, but have no idea how Jedi works. If you want to use Jedi for 
     your IDE, look at the `plugin api <api.html>`_.
+    It is also important to note that it's a pretty old version and some things
+    might not apply anymore.
 
 
 Introduction
@@ -45,12 +47,12 @@ 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:
 
@@ -64,32 +66,32 @@ 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
 `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:
@@ -122,33 +124,33 @@ 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:
 
-Parameter completion (evaluate/dynamic.py)
+Parameter completion (inference/dynamic.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.dynamic
+.. automodule:: jedi.inference.dynamic
 
 
 .. _docstrings:
 
-Docstrings (evaluate/docstrings.py)
+Docstrings (inference/docstrings.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.docstrings
+.. automodule:: jedi.inference.docstrings
 
 .. _refactoring:
 
-Refactoring (evaluate/refactoring.py)
+Refactoring (inference/refactoring.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.refactoring
@@ -167,18 +169,18 @@ 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
 
 
 .. _caching-recursions:
@@ -202,7 +204,7 @@ Caching (cache.py)
 Recursions (recursion.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.recursion
+.. automodule:: jedi.inference.recursion
 
 
 .. _dev-helpers:

docs/docs/features.rst

@@ -6,10 +6,7 @@ Features and Caveats
 Jedi obviously supports autocompletion. It's also possible to get it working in
 (:ref:`your REPL (IPython, etc.) <repl-completion>`).
 
-Static analysis is also possible by using the command ``jedi.names``.
-
-The Jedi Linter is currently in an alpha version and can be tested by calling
-``python -m jedi linter``.
+Static analysis is also possible by using ``jedi.Script(...).get_names``.
 
 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,
@@ -20,12 +17,13 @@ make it work.
 General Features
 ----------------
 
-- Python 2.7 and 3.3+ support
+- Python 2.7 and 3.4+ 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
 
 
 Supported Python Features
@@ -54,6 +52,7 @@ Supported Python Features
 - ``isinstance`` checks for if/while/assert
 - namespace packages (includes ``pkgutil``, ``pkg_resources`` and PEP420 namespaces)
 - Django / Flask / Buildout support
+- Understands Pytest fixtures
 
 
 Not Supported
@@ -69,7 +68,6 @@ Will probably never be implemented:
 - metaclasses (how could an auto-completion ever support this)
 - ``setattr()``, ``__import__()``
 - writing to some dicts: ``globals()``, ``locals()``, ``object.__dict__``
-- evaluating ``if`` / ``while`` / ``del``
 
 
 Caveats
@@ -86,7 +84,7 @@ etc.
 **Security**
 
 Security is an important issue for |jedi|. Therefore no Python code is
-executed.  As long as you write pure Python, everything is evaluated
+executed.  As long as you write pure Python, everything is inferred
 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
@@ -142,15 +140,8 @@ 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.
 
-Things that are missing (and this is not an exhaustive list; some of these
-are planned, others might be hard to implement and provide little worth):
+You can also use stub files.
 
-- annotating functions with comments: https://www.python.org/dev/peps/pep-0484/#suggested-syntax-for-python-2-7-and-straddling-code
-- understanding ``typing.cast()``
-- stub files: https://www.python.org/dev/peps/pep-0484/#stub-files
-- ``typing.Callable``
-- ``typing.TypeVar``
-- User defined generic types: https://www.python.org/dev/peps/pep-0484/#user-defined-generic-types
 
 **Sphinx style**
 

docs/docs/installation.rst

@@ -11,8 +11,16 @@ jedi-vim_ does by default), or you can install it systemwide.
     editor, refer to the corresponding documentation.
 
 
-The preferred way
------------------
+The normal way
+--------------
+
+Most people use Jedi with a :ref:`editor plugins<editor-plugins>`. Typically
+you install Jedi by installing an editor plugin. No necessary steps are needed.
+Just take a look at the instructions for the plugin.
+
+
+With pip
+--------
 
 On any system you can install |jedi| directly from the Python package index
 using pip::
@@ -57,19 +65,15 @@ Others
 We are in the discussion of adding |jedi| to the Fedora repositories.
 
 
-Manual installation from a downloaded package
+Manual installation from GitHub
 ---------------------------------------------
 
-If you prefer not to use an automated package installer, you can `download
-<https://github.com/davidhalter/jedi/archive/master.zip>`__ a current copy of
-|jedi| and install it manually.
-
-To install it, navigate to the directory containing `setup.py` on your console
-and type::
+If you prefer not to use an automated package installer, you can clone the source from GitHub and install it manually. To install it, run these commands::
 
+    git clone --recurse-submodules https://github.com/davidhalter/jedi
+    cd jedi
     sudo python setup.py install
 
-
 Inclusion as a submodule
 ------------------------
 

jedi/__init__.py

@@ -1,42 +1,39 @@
 """
-Jedi is a static analysis tool for Python that can be used in IDEs/editors. Its
-historic focus is autocompletion, but does static analysis for now as well.
-Jedi is fast and is very well tested. It understands Python on a deeper level
-than all other static analysis frameworks for Python.
+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 two different goto functions. It's possible to search for
-related names and to list all names in a Python file and infer them. Jedi
-understands docstrings and you can use Jedi autocompletion in your REPL as
-well.
+Jedi has support for different goto functions. It's possible to search for
+references 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.
-It's really easy.
+Autocompletion in your REPL is also possible, IPython uses it natively and for
+the CPython REPL you have to install it.
 
-To give you a simple example how you can use the Jedi library, here is an
-example for the autocompletion feature:
+Here's a simple example of the autocompletion feature:
 
 >>> import jedi
 >>> source = '''
-... import datetime
-... datetime.da'''
->>> script = jedi.Script(source, 3, len('datetime.da'), 'example.py')
+... import json
+... json.lo'''
+>>> script = jedi.Script(source, path='example.py')
 >>> script
-<Script: 'example.py'>
->>> completions = script.completions()
->>> completions                                         #doctest: +ELLIPSIS
-[<Completion: date>, <Completion: datetime>, ...]
+<Script: 'example.py' ...>
+>>> completions = script.complete(3, len('json.lo'))
+>>> completions
+[<Completion: load>, <Completion: loads>]
 >>> print(completions[0].complete)
-te
+ad
 >>> print(completions[0].name)
-date
+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.12.0'
+__version__ = '0.16.0'
 
 from jedi.api import Script, Interpreter, set_debug_function, \
     preload_module, names
@@ -45,3 +42,6 @@ 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
+# Finally load the internal plugins. This is only internal.
+from jedi.plugins import registry
+del registry

jedi/__main__.py

@@ -40,9 +40,23 @@ def _start_linter():
                 raise
 
 
+def _complete():
+    import jedi
+    import pdb
+
+    try:
+        for c in jedi.Script(sys.argv[2]).complete():
+            c.docstring()
+            c.type
+    except Exception:
+        pdb.post_mortem()
+
+
 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':
     _start_linter()
+elif len(sys.argv) > 1 and sys.argv[1] == '_complete':
+    _complete()

jedi/_compatibility.py

@@ -2,8 +2,10 @@
 To ensure compatibility from Python ``2.7`` - ``3.x``, a module has been
 created. Clearly there is huge need to use conforming syntax.
 """
-import binascii
+from __future__ import print_function
+import atexit
 import errno
+import functools
 import sys
 import os
 import re
@@ -11,18 +13,41 @@ 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_py33 = is_py3 and sys.version_info[1] >= 3
-is_py34 = is_py3 and sys.version_info[1] >= 4
 is_py35 = is_py3 and sys.version_info[1] >= 5
 py_version = int(str(sys.version_info[0]) + str(sys.version_info[1]))
 
 
+if sys.version_info[:2] < (3, 5):
+    """
+    A super-minimal shim around listdir that behave like
+    scandir for the information we need.
+    """
+    class _DirEntry:
+
+        def __init__(self, name, basepath):
+            self.name = name
+            self.basepath = basepath
+
+        def is_dir(self):
+            path_for_name = os.path.join(self.basepath, self.name)
+            return os.path.isdir(path_for_name)
+
+    def scandir(dir):
+        return [_DirEntry(name, dir) for name in os.listdir(dir)]
+else:
+    from os import scandir
+
+
 class DummyFile(object):
     def __init__(self, loader, string):
         self.loader = loader
@@ -35,24 +60,36 @@ class DummyFile(object):
         del self.loader
 
 
-def find_module_py34(string, path=None, full_name=None):
+def find_module_py34(string, path=None, full_name=None, is_global_search=True):
     spec = None
     loader = None
 
-    spec = importlib.machinery.PathFinder.find_spec(string, path)
-    if spec is not None:
-        # We try to disambiguate implicit namespace pkgs with non implicit namespace pkgs
-        if not spec.has_location:
-            full_name = string if not path else full_name
-            implicit_ns_info = ImplicitNSInfo(full_name, spec.submodule_search_locations._path)
-            return None, implicit_ns_info, False
+    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
 
-        # we have found the tail end of the dotted path
-        loader = spec.loader
     return find_module_py33(string, path, loader)
 
 
-def find_module_py33(string, path=None, loader=None, full_name=None):
+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
@@ -72,47 +109,81 @@ def find_module_py33(string, path=None, loader=None, full_name=None):
     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:
-        is_package = loader.is_package(string)
-        if is_package:
-            if hasattr(loader, 'path'):
-                module_path = os.path.dirname(loader.path)
-            else:
-                # At least zipimporter does not have path attribute
-                module_path = os.path.dirname(loader.get_filename(string))
-            if hasattr(loader, 'archive'):
-                module_file = DummyFile(loader, string)
-            else:
-                module_file = None
-        else:
-            module_path = loader.get_filename(string)
-            module_file = DummyFile(loader, string)
+        get_filename = loader.get_filename
     except AttributeError:
-        # ExtensionLoader has not attribute get_filename, instead it has a
-        # path attribute that we can use to retrieve the module path
-        try:
-            module_path = loader.path
-            module_file = DummyFile(loader, string)
-        except AttributeError:
-            module_path = string
-            module_file = None
-        finally:
-            is_package = False
+        return None, is_package
+    else:
+        module_path = cast_path(get_filename(string))
 
-    if hasattr(loader, 'archive'):
-        module_path = loader.archive
+    # 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)
 
-    return module_file, module_path, is_package
+    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 find_module_pre_py33(string, path=None, full_name=None):
+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]
-        return module_file, module_path, module_type is imp.PKG_DIRECTORY
+        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
 
@@ -121,27 +192,13 @@ def find_module_pre_py33(string, path=None, full_name=None):
     for item in path:
         loader = pkgutil.get_importer(item)
         if loader:
-            try:
-                loader = loader.find_module(string)
-                if loader:
-                    is_package = loader.is_package(string)
-                    is_archive = hasattr(loader, 'archive')
-                    module_path = loader.get_filename(string)
-                    if is_package:
-                        module_path = os.path.dirname(module_path)
-                    if is_archive:
-                        module_path = loader.archive
-                    file = None
-                    if not is_package or is_archive:
-                        file = DummyFile(loader, string)
-                    return file, module_path, is_package
-            except ImportError:
-                pass
+            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_py33 if is_py33 else find_module_pre_py33
-find_module = find_module_py34 if is_py34 else find_module
+find_module = find_module_py34 if is_py3 else find_module_pre_py3
 find_module.__doc__ = """
 Provides information about a module.
 
@@ -208,6 +265,7 @@ def _iter_modules(paths, prefix=''):
                 yield importer, prefix + modname, ispkg
         # END COPY
 
+
 iter_modules = _iter_modules if py_version >= 34 else pkgutil.iter_modules
 
 
@@ -253,16 +311,6 @@ Usage::
 
 """
 
-class Python3Method(object):
-    def __init__(self, func):
-        self.func = func
-
-    def __get__(self, obj, objtype):
-        if obj is None:
-            return lambda *args, **kwargs: self.func(*args, **kwargs)
-        else:
-            return lambda *args, **kwargs: self.func(obj, *args, **kwargs)
-
 
 def use_metaclass(meta, *bases):
     """ Create a class with a metaclass. """
@@ -313,10 +361,10 @@ def force_unicode(obj):
 try:
     import builtins  # module name in python 3
 except ImportError:
-    import __builtin__ as builtins
+    import __builtin__ as builtins  # noqa: F401
 
 
-import ast
+import ast  # noqa: F401
 
 
 def literal_eval(string):
@@ -326,7 +374,7 @@ def literal_eval(string):
 try:
     from itertools import zip_longest
 except ImportError:
-    from itertools import izip_longest as zip_longest  # Python 2
+    from itertools import izip_longest as zip_longest  # Python 2  # noqa: F401
 
 try:
     FileNotFoundError = FileNotFoundError
@@ -334,9 +382,14 @@ except NameError:
     FileNotFoundError = IOError
 
 try:
-    NotADirectoryError = NotADirectoryError
+    IsADirectoryError = IsADirectoryError
 except NameError:
-    NotADirectoryError = IOError
+    IsADirectoryError = IOError
+
+try:
+    PermissionError = PermissionError
+except NameError:
+    PermissionError = IOError
 
 
 def no_unicode_pprint(dct):
@@ -351,13 +404,6 @@ def no_unicode_pprint(dct):
     print(re.sub("u'", "'", s))
 
 
-def print_to_stderr(*args):
-    if is_py3:
-        eval("print(*args, file=sys.stderr)")
-    else:
-        print >> sys.stderr, args
-
-
 def utf8_repr(func):
     """
     ``__repr__`` methods in Python 2 don't allow unicode objects to be
@@ -379,10 +425,14 @@ def utf8_repr(func):
 if is_py3:
     import queue
 else:
-    import Queue as queue
+    import Queue as queue  # noqa: F401
 
-
-import pickle
+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
@@ -443,53 +493,61 @@ if sys.version_info[:2] == (3, 3):
     pickle.loads = loads
 
 
-_PICKLE_PROTOCOL = 2
-is_windows = sys.platform == 'win32'
-
-# The Windows shell on Python 2 consumes all control characters (below 32) and expand on
-# all Python versions \n to \r\n.
-# pickle starting from protocol version 1 uses binary data, which could not be escaped by
-# any normal unicode encoder. Therefore, the only bytes encoder which doesn't produce
-# control characters is binascii.hexlify.
-
-
 def pickle_load(file):
-    if is_windows:
-        try:
-            data = file.readline()
-            data = binascii.unhexlify(data.strip())
-            if is_py3:
-                return pickle.loads(data, encoding='bytes')
-            else:
-                return pickle.loads(data)
-        # Python on Windows don't throw EOF errors for pipes. So reraise them with
-        # the correct type, which is cought upwards.
-        except OSError:
-            raise EOFError()
-    else:
+    try:
         if is_py3:
             return pickle.load(file, encoding='bytes')
-        else:
-            return pickle.load(file)
+        return pickle.load(file)
+    # Python on Windows don't throw EOF errors for pipes. So reraise them with
+    # the correct type, which is caught upwards.
+    except OSError:
+        if sys.platform == 'win32':
+            raise EOFError()
+        raise
 
 
-def pickle_dump(data, file):
-    if is_windows:
-        try:
-            data = pickle.dumps(data, protocol=_PICKLE_PROTOCOL)
-            data = binascii.hexlify(data)
-            file.write(data)
-            file.write(b'\n')
-            # On Python 3.3 flush throws sometimes an error even if the two file writes
-            # should done it already before. This could be also computer / speed depending.
-            file.flush()
-        # Python on Windows don't throw EPIPE errors for pipes. So reraise them with
-        # the correct type and error number.
-        except OSError:
-            raise IOError(errno.EPIPE, "Broken pipe")
-    else:
-        pickle.dump(data, file, protocol=_PICKLE_PROTOCOL)
+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.
         file.flush()
+    # Python on Windows don't throw EPIPE errors for pipes. So reraise them with
+    # the correct type and error number.
+    except OSError:
+        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:
@@ -512,4 +570,165 @@ class GeneralizedPopen(subprocess.Popen):
             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
+
+        # To me it's an absolute mystery why in Python 2 we need _=None. It
+        # makes really no sense since it's never really called. Then again it
+        # might be called by Python 2.7 itself, but weakref.finalize is not
+        # documented in Python 2 and therefore shouldn't be randomly called.
+        # We never call this stuff with a parameter and therefore this
+        # parameter should not be needed. But it is. ~dave
+        def __call__(self, _=None):
+            """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
+
+
+if is_py3 and sys.version_info[1] > 5:
+    from inspect import unwrap
+else:
+    # Only Python >=3.6 does properly limit the amount of unwraps. This is very
+    # relevant in the case of unittest.mock.patch.
+    # Below is the implementation of Python 3.7.
+    def unwrap(func, stop=None):
+        """Get the object wrapped by *func*.
+
+       Follows the chain of :attr:`__wrapped__` attributes returning the last
+       object in the chain.
+
+       *stop* is an optional callback accepting an object in the wrapper chain
+       as its sole argument that allows the unwrapping to be terminated early if
+       the callback returns a true value. If the callback never returns a true
+       value, the last object in the chain is returned as usual. For example,
+       :func:`signature` uses this to stop unwrapping if any object in the
+       chain has a ``__signature__`` attribute defined.
+
+       :exc:`ValueError` is raised if a cycle is encountered.
+
+        """
+        if stop is None:
+            def _is_wrapper(f):
+                return hasattr(f, '__wrapped__')
+        else:
+            def _is_wrapper(f):
+                return hasattr(f, '__wrapped__') and not stop(f)
+        f = func  # remember the original func for error reporting
+        # Memoise by id to tolerate non-hashable objects, but store objects to
+        # ensure they aren't destroyed, which would allow their IDs to be reused.
+        memo = {id(f): f}
+        recursion_limit = sys.getrecursionlimit()
+        while _is_wrapper(func):
+            func = func.__wrapped__
+            id_func = id(func)
+            if (id_func in memo) or (len(memo) >= recursion_limit):
+                raise ValueError('wrapper loop when unwrapping {!r}'.format(f))
+            memo[id_func] = func
+        return func

jedi/api/__init__.py

@@ -11,31 +11,37 @@ arguments.
 """
 import os
 import sys
+import warnings
 
 import parso
 from parso.python import tree
 
-from jedi._compatibility import force_unicode, is_py3
+from jedi._compatibility import force_unicode, cast_path, is_py3
 from jedi.parser_utils import get_executable_nodes
 from jedi import debug
 from jedi import settings
 from jedi import cache
+from jedi.file_io import KnownContentFileIO
 from jedi.api import classes
 from jedi.api import interpreter
 from jedi.api import helpers
+from jedi.api.helpers import validate_line_column
 from jedi.api.completion import Completion
+from jedi.api.keywords import KeywordName
 from jedi.api.environment import InterpreterEnvironment
-from jedi.api.project import get_default_project
-from jedi.evaluate import Evaluator
-from jedi.evaluate import imports
-from jedi.evaluate import usages
-from jedi.evaluate.arguments import try_iter_content
-from jedi.evaluate.helpers import get_module_names, evaluate_call_of_leaf
-from jedi.evaluate.sys_path import dotted_path_in_sys_path
-from jedi.evaluate.filters import TreeNameDefinition, ParamName
-from jedi.evaluate.syntax_tree import tree_name_to_contexts
-from jedi.evaluate.context import ModuleContext
-from jedi.evaluate.context.iterable import unpack_tuple_to_dict
+from jedi.api.project import get_default_project, Project
+from jedi.inference import InferenceState
+from jedi.inference import imports
+from jedi.inference.references import find_references
+from jedi.inference.arguments import try_iter_content
+from jedi.inference.helpers import get_module_names, infer_call_of_leaf
+from jedi.inference.sys_path import transform_path_to_dotted
+from jedi.inference.syntax_tree import tree_name_to_values
+from jedi.inference.value import ModuleValue
+from jedi.inference.base_value import ValueSet
+from jedi.inference.value.iterable import unpack_tuple_to_dict
+from jedi.inference.gradual.conversion import convert_names, convert_values
+from jedi.inference.gradual.utils import load_proper_stub_module
 
 # Jedi uses lots and lots of recursion. By setting this a little bit higher, we
 # can remove some "maximum recursion depth" errors.
@@ -57,16 +63,16 @@ class Script(object):
 
     - if `sys_path` parameter is ``None`` and ``VIRTUAL_ENV`` environment
       variable is defined, ``sys.path`` for the specified environment will be
-      guessed (see :func:`jedi.evaluate.sys_path.get_venv_path`) and used for
+      guessed (see :func:`jedi.inference.sys_path.get_venv_path`) and used for
       the script;
 
     - otherwise ``sys.path`` will match that of |jedi|.
 
     :param source: The source code of the current file, separated by newlines.
     :type source: str
-    :param line: The line to perform actions on (starting with 1).
+    :param line: Deprecated, please use it directly on e.g. `.complete`
     :type line: int
-    :param column: The column of the cursor (starting with 0).
+    :param column: Deprecated, please use it directly on e.g. `.complete`
     :type column: int
     :param path: The path of the file in the file system, or ``''`` if
         it hasn't been saved yet.
@@ -74,16 +80,14 @@ class Script(object):
     :param encoding: The encoding of ``source``, if it is not a
         ``unicode`` object (default ``'utf-8'``).
     :type encoding: str
-    :param source_encoding: The encoding of ``source``, if it is not a
-        ``unicode`` object (default ``'utf-8'``).
-    :type encoding: str
     :param sys_path: ``sys.path`` to use during analysis of the script
     :type sys_path: list
     :param environment: TODO
-    :type sys_path: Environment
+    :type environment: Environment
     """
     def __init__(self, source=None, line=None, column=None, path=None,
-                 encoding='utf-8', sys_path=None, environment=None):
+                 encoding='utf-8', sys_path=None, environment=None,
+                 _project=None):
         self._orig_path = path
         # An empty path (also empty string) should always result in no path.
         self.path = os.path.abspath(path) if path else None
@@ -99,167 +103,283 @@ class Script(object):
         if sys_path is not None and not is_py3:
             sys_path = list(map(force_unicode, sys_path))
 
-        # Load the Python grammar of the current interpreter.
-        project = get_default_project(
-            os.path.dirname(self.path)if path else os.getcwd()
-        )
+        project = _project
+        if project is None:
+            # Load the Python grammar of the current interpreter.
+            project = get_default_project(
+                os.path.dirname(self.path)if path else os.getcwd()
+            )
         # TODO deprecate and remove sys_path from the Script API.
         if sys_path is not None:
             project._sys_path = sys_path
-        self._evaluator = Evaluator(
+        self._inference_state = InferenceState(
             project, environment=environment, script_path=self.path
         )
-        self._project = project
         debug.speed('init')
-        self._module_node, source = self._evaluator.parse_and_get_code(
+        self._module_node, source = self._inference_state.parse_and_get_code(
             code=source,
             path=self.path,
+            encoding=encoding,
+            use_latest_grammar=path and path.endswith('.pyi'),
             cache=False,  # No disk cache, because the current script often changes.
-            diff_cache=True,
-            cache_path=settings.cache_directory
+            diff_cache=settings.fast_parser,
+            cache_path=settings.cache_directory,
         )
         debug.speed('parsed')
         self._code_lines = parso.split_lines(source, keepends=True)
         self._code = source
-        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 -= 1
-        if 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 is not in a valid range.')
         self._pos = line, column
-        self._path = path
 
         cache.clear_time_caches()
         debug.reset_time()
 
+    # Cache the module, this is mostly useful for testing, since this shouldn't
+    # be called multiple times.
+    @cache.memoize_method
     def _get_module(self):
-        name = '__main__'
+        names = None
+        is_package = False
         if self.path is not None:
-            n = dotted_path_in_sys_path(self._evaluator.get_sys_path(), self.path)
-            if n is not None:
-                name = n
+            import_names, is_p = transform_path_to_dotted(
+                self._inference_state.get_sys_path(add_parent_paths=False),
+                self.path
+            )
+            if import_names is not None:
+                names = import_names
+                is_package = is_p
 
-        module = ModuleContext(
-            self._evaluator, self._module_node, self.path,
-            code_lines=self._code_lines
+        if self.path is None:
+            file_io = None
+        else:
+            file_io = KnownContentFileIO(cast_path(self.path), self._code)
+        if self.path is not None and self.path.endswith('.pyi'):
+            # We are in a stub file. Try to load the stub properly.
+            stub_module = load_proper_stub_module(
+                self._inference_state,
+                file_io,
+                names,
+                self._module_node
+            )
+            if stub_module is not None:
+                return stub_module
+
+        if names is None:
+            names = ('__main__',)
+
+        module = ModuleValue(
+            self._inference_state, self._module_node,
+            file_io=file_io,
+            string_names=names,
+            code_lines=self._code_lines,
+            is_package=is_package,
         )
-        imports.add_module_to_cache(self._evaluator, name, module)
+        if names[0] not in ('builtins', '__builtin__', 'typing'):
+            # These modules are essential for Jedi, so don't overwrite them.
+            self._inference_state.module_cache.add(names, ValueSet([module]))
         return module
 
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, repr(self._orig_path))
+    def _get_module_context(self):
+        return self._get_module().as_context()
 
-    def completions(self):
+    def __repr__(self):
+        return '<%s: %s %r>' % (
+            self.__class__.__name__,
+            repr(self._orig_path),
+            self._inference_state.environment,
+        )
+
+    @validate_line_column
+    def complete(self, line=None, column=None, **kwargs):
         """
         Return :class:`classes.Completion` objects. Those objects contain
         information about the completions, more than just names.
 
-        :return: Completion objects, sorted by name and __ comes last.
+        :param fuzzy: Default False. Will return fuzzy completions, which means
+            that e.g. ``ooa`` will match ``foobar``.
+        :return: Completion objects, sorted by name and ``__`` comes last.
         :rtype: list of :class:`classes.Completion`
         """
-        debug.speed('completions start')
-        completion = Completion(
-            self._evaluator, self._get_module(), self._code_lines,
-            self._pos, self.call_signatures
-        )
-        completions = completion.completions()
-        debug.speed('completions end')
-        return completions
+        return self._complete(line, column, **kwargs)
 
-    def goto_definitions(self):
+    def _complete(self, line, column, fuzzy=False):  # Python 2...
+        with debug.increase_indent_cm('complete'):
+            completion = Completion(
+                self._inference_state, self._get_module_context(), self._code_lines,
+                (line, column), self.get_signatures, fuzzy=fuzzy,
+            )
+            return completion.complete()
+
+    def completions(self, fuzzy=False):
+        # Deprecated, will be removed.
+        return self.complete(*self._pos, fuzzy=fuzzy)
+
+    @validate_line_column
+    def infer(self, line=None, column=None, **kwargs):
         """
         Return the definitions of a the path under the cursor.  goto function!
         This follows complicated paths and returns the end, not the first
-        definition. The big difference between :meth:`goto_assignments` and
-        :meth:`goto_definitions` is that :meth:`goto_assignments` doesn't
+        definition. The big difference between :meth:`goto` and
+        :meth:`infer` is that :meth:`goto` doesn't
         follow imports and statements. Multiple objects may be returned,
         because Python itself is a dynamic language, which means depending on
         an option you can have two different versions of a function.
 
+        :param only_stubs: Only return stubs for this goto call.
+        :param prefer_stubs: Prefer stubs to Python objects for this type
+            inference call.
         :rtype: list of :class:`classes.Definition`
         """
-        leaf = self._module_node.get_name_of_position(self._pos)
+        with debug.increase_indent_cm('infer'):
+            return self._infer(line, column, **kwargs)
+
+    def goto_definitions(self, **kwargs):
+        # Deprecated, will be removed.
+        return self.infer(*self._pos, **kwargs)
+
+    def _infer(self, line, column, only_stubs=False, prefer_stubs=False):
+        pos = line, column
+        leaf = self._module_node.get_name_of_position(pos)
         if leaf is None:
-            leaf = self._module_node.get_leaf_for_position(self._pos)
-            if leaf is None:
+            leaf = self._module_node.get_leaf_for_position(pos)
+            if leaf is None or leaf.type == 'string':
                 return []
 
-        context = self._evaluator.create_context(self._get_module(), leaf)
-        definitions = helpers.evaluate_goto_definition(self._evaluator, context, leaf)
+        context = self._get_module_context().create_context(leaf)
 
-        names = [s.name for s in definitions]
-        defs = [classes.Definition(self._evaluator, name) for name in names]
+        values = helpers.infer(self._inference_state, context, leaf)
+        values = convert_values(
+            values,
+            only_stubs=only_stubs,
+            prefer_stubs=prefer_stubs,
+        )
+
+        defs = [classes.Definition(self._inference_state, c.name) for c in values]
         # The additional set here allows the definitions to become unique in an
         # API sense. In the internals we want to separate more things than in
         # the API.
         return helpers.sorted_definitions(set(defs))
 
-    def goto_assignments(self, follow_imports=False):
+    def goto_assignments(self, follow_imports=False, follow_builtin_imports=False, **kwargs):
+        # Deprecated, will be removed.
+        return self.goto(*self._pos,
+                         follow_imports=follow_imports,
+                         follow_builtin_imports=follow_builtin_imports,
+                         **kwargs)
+
+    @validate_line_column
+    def goto(self, line=None, column=None, **kwargs):
         """
         Return the first definition found, while optionally following imports.
         Multiple objects may be returned, because Python itself is a
         dynamic language, which means depending on an option you can have two
         different versions of a function.
 
+        :param follow_imports: The goto call will follow imports.
+        :param follow_builtin_imports: If follow_imports is True will decide if
+            it follow builtin imports.
+        :param only_stubs: Only return stubs for this goto call.
+        :param prefer_stubs: Prefer stubs to Python objects for this goto call.
         :rtype: list of :class:`classes.Definition`
         """
-        def filter_follow_imports(names, check):
-            for name in names:
-                if check(name):
-                    for result in filter_follow_imports(name.goto(), check):
-                        yield result
-                else:
-                    yield name
+        with debug.increase_indent_cm('goto'):
+            return self._goto(line, column, **kwargs)
 
-        tree_name = self._module_node.get_name_of_position(self._pos)
+    def _goto(self, line, column, follow_imports=False, follow_builtin_imports=False,
+              only_stubs=False, prefer_stubs=False):
+        tree_name = self._module_node.get_name_of_position((line, column))
         if tree_name is None:
-            return []
-        context = self._evaluator.create_context(self._get_module(), tree_name)
-        names = list(self._evaluator.goto(context, tree_name))
+            # Without a name we really just want to jump to the result e.g.
+            # executed by `foo()`, if we the cursor is after `)`.
+            return self.infer(line, column, only_stubs=only_stubs, prefer_stubs=prefer_stubs)
+        name = self._get_module_context().create_name(tree_name)
+
+        # Make it possible to goto the super class function/attribute
+        # definitions, when they are overwritten.
+        names = []
+        if name.tree_name.is_definition() and name.parent_context.is_class():
+            class_node = name.parent_context.tree_node
+            class_value = self._get_module_context().create_value(class_node)
+            mro = class_value.py__mro__()
+            next(mro)  # Ignore the first entry, because it's the class itself.
+            for cls in mro:
+                names = cls.goto(tree_name.value)
+                if names:
+                    break
+
+        if not names:
+            names = list(name.goto())
 
         if follow_imports:
-            def check(name):
-                return name.is_import()
-        else:
-            def check(name):
-                return isinstance(name, imports.SubModuleName)
+            names = helpers.filter_follow_imports(names)
+        names = convert_names(
+            names,
+            only_stubs=only_stubs,
+            prefer_stubs=prefer_stubs,
+        )
 
-        names = filter_follow_imports(names, check)
-
-        defs = [classes.Definition(self._evaluator, d) for d in set(names)]
+        defs = [classes.Definition(self._inference_state, d) for d in set(names)]
         return helpers.sorted_definitions(defs)
 
-    def usages(self, additional_module_paths=()):
+    @validate_line_column
+    def help(self, line=None, column=None):
+        """
+        Works like goto and returns a list of Definition objects. Returns
+        additional definitions for keywords and operators.
+
+        The additional definitions are of ``Definition(...).type == 'keyword'``.
+        These definitions do not have a lot of value apart from their docstring
+        attribute, which contains the output of Python's ``help()`` function.
+
+        :rtype: list of :class:`classes.Definition`
+        """
+        definitions = self.goto(line, column, follow_imports=True)
+        if definitions:
+            return definitions
+        leaf = self._module_node.get_leaf_for_position((line, column))
+        if leaf.type in ('keyword', 'operator', 'error_leaf'):
+            reserved = self._grammar._pgen_grammar.reserved_syntax_strings.keys()
+            if leaf.value in reserved:
+                name = KeywordName(self._inference_state, leaf.value)
+                return [classes.Definition(self._inference_state, name)]
+        return []
+
+    def usages(self, **kwargs):
+        # Deprecated, will be removed.
+        return self.get_references(*self._pos, **kwargs)
+
+    @validate_line_column
+    def get_references(self, line=None, column=None, **kwargs):
         """
         Return :class:`classes.Definition` objects, which contain all
         names that point to the definition of the name under the cursor. This
-        is very useful for refactoring (renaming), or to show all usages of a
-        variable.
-
-        .. todo:: Implement additional_module_paths
+        is very useful for refactoring (renaming), or to show all references of
+        a variable.
 
+        :param include_builtins: Default True, checks if a reference is a
+            builtin (e.g. ``sys``) and in that case does not return it.
         :rtype: list of :class:`classes.Definition`
         """
-        tree_name = self._module_node.get_name_of_position(self._pos)
-        if tree_name is None:
-            # Must be syntax
-            return []
 
-        names = usages.usages(self._get_module(), tree_name)
+        def _references(include_builtins=True):
+            tree_name = self._module_node.get_name_of_position((line, column))
+            if tree_name is None:
+                # Must be syntax
+                return []
 
-        definitions = [classes.Definition(self._evaluator, n) for n in names]
-        return helpers.sorted_definitions(definitions)
+            names = find_references(self._get_module_context(), tree_name)
+
+            definitions = [classes.Definition(self._inference_state, n) for n in names]
+            if not include_builtins:
+                definitions = [d for d in definitions if not d.in_builtin_module()]
+            return helpers.sorted_definitions(definitions)
+        return _references(**kwargs)
 
     def call_signatures(self):
+        # Deprecated, will be removed.
+        return self.get_signatures(*self._pos)
+
+    @validate_line_column
+    def get_signatures(self, line=None, column=None):
         """
         Return the function object of the call you're currently in.
 
@@ -273,42 +393,73 @@ class Script(object):
 
         This would return an empty list..
 
-        :rtype: list of :class:`classes.CallSignature`
+        :rtype: list of :class:`classes.Signature`
         """
-        call_signature_details = \
-            helpers.get_call_signature_details(self._module_node, self._pos)
-        if call_signature_details is None:
+        pos = line, column
+        call_details = helpers.get_signature_details(self._module_node, pos)
+        if call_details is None:
             return []
 
-        context = self._evaluator.create_context(
-            self._get_module(),
-            call_signature_details.bracket_leaf
-        )
-        definitions = helpers.cache_call_signatures(
-            self._evaluator,
+        context = self._get_module_context().create_context(call_details.bracket_leaf)
+        definitions = helpers.cache_signatures(
+            self._inference_state,
             context,
-            call_signature_details.bracket_leaf,
+            call_details.bracket_leaf,
             self._code_lines,
-            self._pos
+            pos
         )
         debug.speed('func_call followed')
 
-        return [classes.CallSignature(self._evaluator, d.name,
-                                      call_signature_details.bracket_leaf.start_pos,
-                                      call_signature_details.call_index,
-                                      call_signature_details.keyword_name_str)
-                for d in definitions if hasattr(d, 'py__call__')]
+        # TODO here we use stubs instead of the actual values. We should use
+        # the signatures from stubs, but the actual values, probably?!
+        return [classes.Signature(self._inference_state, signature, call_details)
+                for signature in definitions.get_signatures()]
+
+    @validate_line_column
+    def get_context(self, line=None, column=None):
+        pos = (line, column)
+        leaf = self._module_node.get_leaf_for_position(pos, include_prefixes=True)
+        if leaf.start_pos > pos or leaf.type == 'endmarker':
+            previous_leaf = leaf.get_previous_leaf()
+            if previous_leaf is not None:
+                leaf = previous_leaf
+
+        module_context = self._get_module_context()
+
+        n = tree.search_ancestor(leaf, 'funcdef', 'classdef')
+        if n is not None and n.start_pos < pos <= n.children[-1].start_pos:
+            # This is a bit of a special case. The context of a function/class
+            # name/param/keyword is always it's parent context, not the
+            # function itself. Catch all the cases here where we are before the
+            # suite object, but still in the function.
+            context = module_context.create_value(n).as_context()
+        else:
+            context = module_context.create_context(leaf)
+
+        while context.name is None:
+            context = context.parent_context  # comprehensions
+
+        definition = classes.Definition(self._inference_state, context.name)
+        while definition.type != 'module':
+            name = definition._name  # TODO private access
+            tree_name = name.tree_name
+            if tree_name is not None:  # Happens with lambdas.
+                scope = tree_name.get_definition()
+                if scope.start_pos[1] < column:
+                    break
+            definition = definition.parent()
+        return definition
 
     def _analysis(self):
-        self._evaluator.is_analysis = True
-        self._evaluator.analysis_modules = [self._module_node]
-        module = self._get_module()
+        self._inference_state.is_analysis = True
+        self._inference_state.analysis_modules = [self._module_node]
+        module = self._get_module_context()
         try:
             for node in get_executable_nodes(self._module_node):
                 context = module.create_context(node)
                 if node.type in ('funcdef', 'classdef'):
                     # Resolve the decorators.
-                    tree_name_to_contexts(self._evaluator, context, node.children[1])
+                    tree_name_to_values(self._inference_state, context, node.children[1])
                 elif isinstance(node, tree.Import):
                     import_names = set(node.get_defined_names())
                     if node.is_nested():
@@ -316,22 +467,52 @@ class Script(object):
                     for n in import_names:
                         imports.infer_import(context, n)
                 elif node.type == 'expr_stmt':
-                    types = context.eval_node(node)
+                    types = context.infer_node(node)
                     for testlist in node.children[:-1:2]:
                         # Iterate tuples.
                         unpack_tuple_to_dict(context, types, testlist)
                 else:
                     if node.type == 'name':
-                        defs = self._evaluator.goto_definitions(context, node)
+                        defs = self._inference_state.infer(context, node)
                     else:
-                        defs = evaluate_call_of_leaf(context, node)
+                        defs = infer_call_of_leaf(context, node)
                     try_iter_content(defs)
-                self._evaluator.reset_recursion_limitations()
+                self._inference_state.reset_recursion_limitations()
 
-            ana = [a for a in self._evaluator.analysis if self.path == a.path]
+            ana = [a for a in self._inference_state.analysis if self.path == a.path]
             return sorted(set(ana), key=lambda x: x.line)
         finally:
-            self._evaluator.is_analysis = False
+            self._inference_state.is_analysis = False
+
+    def get_names(self, **kwargs):
+        """
+        Returns a list of `Definition` objects, containing name parts.
+        This means you can call ``Definition.goto()`` and get the
+        reference of a name.
+
+        :param all_scopes: If True lists the names of all scopes instead of only
+            the module namespace.
+        :param definitions: If True lists the names that have been defined by a
+            class, function or a statement (``a = b`` returns ``a``).
+        :param references: If True lists all the names that are not listed by
+            ``definitions=True``. E.g. ``a = b`` returns ``b``.
+        """
+        return self._names(**kwargs)  # Python 2...
+
+    def _names(self, all_scopes=False, definitions=True, references=False):
+        def def_ref_filter(_def):
+            is_def = _def._name.tree_name.is_definition()
+            return definitions and is_def or references and not is_def
+
+        # Set line/column to a random position, because they don't matter.
+        module_context = self._get_module_context()
+        defs = [
+            classes.Definition(
+                self._inference_state,
+                module_context.create_name(name)
+            ) for name in get_module_names(self._module_node, all_scopes)
+        ]
+        return sorted(filter(def_ref_filter, defs), key=lambda x: (x.line, x.column))
 
 
 class Interpreter(Script):
@@ -346,9 +527,10 @@ class Interpreter(Script):
     >>> from os.path import join
     >>> namespace = locals()
     >>> script = Interpreter('join("").up', [namespace])
-    >>> print(script.completions()[0].name)
+    >>> print(script.complete()[0].name)
     upper
     """
+    _allow_descriptor_getattr_default = True
 
     def __init__(self, source, namespaces, **kwds):
         """
@@ -376,60 +558,38 @@ class Interpreter(Script):
             if not isinstance(environment, InterpreterEnvironment):
                 raise TypeError("The environment needs to be an InterpreterEnvironment subclass.")
 
-        super(Interpreter, self).__init__(source, environment=environment, **kwds)
+        super(Interpreter, self).__init__(source, environment=environment,
+                                          _project=Project(os.getcwd()), **kwds)
         self.namespaces = namespaces
+        self._inference_state.allow_descriptor_getattr = self._allow_descriptor_getattr_default
 
-    def _get_module(self):
-        return interpreter.MixedModuleContext(
-            self._evaluator,
-            self._module_node,
-            self.namespaces,
-            path=self.path,
+    @cache.memoize_method
+    def _get_module_context(self):
+        tree_module_value = ModuleValue(
+            self._inference_state, self._module_node,
+            file_io=KnownContentFileIO(self.path, self._code),
+            string_names=('__main__',),
             code_lines=self._code_lines,
         )
+        return interpreter.MixedModuleContext(
+            tree_module_value,
+            self.namespaces,
+        )
 
 
 def names(source=None, path=None, encoding='utf-8', all_scopes=False,
           definitions=True, references=False, environment=None):
-    """
-    Returns a list of `Definition` objects, containing name parts.
-    This means you can call ``Definition.goto_assignments()`` and get the
-    reference of a name.
-    The parameters are the same as in :py:class:`Script`, except or the
-    following ones:
+    warnings.warn(
+        "Deprecated since version 0.16.0. Use Script(...).get_names instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
 
-    :param all_scopes: If True lists the names of all scopes instead of only
-        the module namespace.
-    :param definitions: If True lists the names that have been defined by a
-        class, function or a statement (``a = b`` returns ``a``).
-    :param references: If True lists all the names that are not listed by
-        ``definitions=True``. E.g. ``a = b`` returns ``b``.
-    """
-    def def_ref_filter(_def):
-        is_def = _def._name.tree_name.is_definition()
-        return definitions and is_def or references and not is_def
-
-    def create_name(name):
-        if name.parent.type == 'param':
-            cls = ParamName
-        else:
-            cls = TreeNameDefinition
-        is_module = name.parent.type == 'file_input'
-        return cls(
-            module_context.create_context(name if is_module else name.parent),
-            name
-        )
-
-    # Set line/column to a random position, because they don't matter.
-    script = Script(source, line=1, column=0, path=path, encoding=encoding, environment=environment)
-    module_context = script._get_module()
-    defs = [
-        classes.Definition(
-            script._evaluator,
-            create_name(name)
-        ) for name in get_module_names(script._module_node, all_scopes)
-    ]
-    return sorted(filter(def_ref_filter, defs), key=lambda x: (x.line, x.column))
+    return Script(source, path=path, encoding=encoding).get_names(
+        all_scopes=all_scopes,
+        definitions=definitions,
+        references=references,
+    )
 
 
 def preload_module(*modules):
@@ -441,7 +601,7 @@ def preload_module(*modules):
     """
     for m in modules:
         s = "import %s as x; x." % m
-        Script(s, 1, len(s), None).completions()
+        Script(s, path=None).complete(1, len(s))
 
 
 def set_debug_function(func_cb=debug.print_to_stdout, warnings=True,

jedi/api/classes.py

@@ -4,34 +4,43 @@ These classes are the much bigger part of the whole API, because they contain
 the interesting information about completion and goto operations.
 """
 import re
+import sys
+import warnings
 
 from parso.python.tree import search_ancestor
 
 from jedi import settings
-from jedi.evaluate.utils import ignored, unite
+from jedi import debug
+from jedi.inference.utils import unite
 from jedi.cache import memoize_method
-from jedi.evaluate import imports
-from jedi.evaluate import compiled
-from jedi.evaluate.imports import ImportName
-from jedi.evaluate.context import instance
-from jedi.evaluate.context import ClassContext, FunctionContext, FunctionExecutionContext
+from jedi.inference import imports
+from jedi.inference.imports import ImportName
+from jedi.inference.gradual.typeshed import StubModuleValue
+from jedi.inference.gradual.conversion import convert_names, convert_values
+from jedi.inference.base_value import ValueSet
 from jedi.api.keywords import KeywordName
+from jedi.api import completion_cache
+from jedi.api.helpers import filter_follow_imports
 
 
 def _sort_names_by_start_pos(names):
     return sorted(names, key=lambda s: s.start_pos or (0, 0))
 
 
-def defined_names(evaluator, context):
+def defined_names(inference_state, context):
     """
     List sub-definitions (e.g., methods in class).
 
     :type scope: Scope
     :rtype: list of Definition
     """
-    filter = next(context.get_filters(search_global=True))
+    filter = next(context.get_filters())
     names = [name for name in filter.values()]
-    return [Definition(evaluator, n) for n in _sort_names_by_start_pos(names)]
+    return [Definition(inference_state, n) for n in _sort_names_by_start_pos(names)]
+
+
+def _values_to_definitions(values):
+    return [Definition(c.inference_state, c.name) for c in values]
 
 
 class BaseDefinition(object):
@@ -45,30 +54,41 @@ class BaseDefinition(object):
         'posix': 'os',
         '_io': 'io',
         '_functools': 'functools',
+        '_collections': 'collections',
+        '_socket': 'socket',
         '_sqlite3': 'sqlite3',
-        '__builtin__': '',
-        'builtins': '',
+        '__builtin__': 'builtins',
     }
 
     _tuple_mapping = dict((tuple(k.split('.')), v) for (k, v) in {
         'argparse._ActionsContainer': 'argparse.ArgumentParser',
     }.items())
 
-    def __init__(self, evaluator, name):
-        self._evaluator = evaluator
+    def __init__(self, inference_state, name):
+        self._inference_state = inference_state
         self._name = name
         """
-        An instance of :class:`parso.reprsentation.Name` subclass.
+        An instance of :class:`parso.python.tree.Name` subclass.
         """
         self.is_keyword = isinstance(self._name, KeywordName)
 
-        # generate a path to the definition
-        self._module = name.get_root_context()
-        if self.in_builtin_module():
-            self.module_path = None
-        else:
-            self.module_path = self._module.py__file__()
-            """Shows the file path of a module. e.g. ``/usr/lib/python2.7/os.py``"""
+    @memoize_method
+    def _get_module_context(self):
+        # This can take a while to complete, because in the worst case of
+        # imports (consider `import a` completions), we need to load all
+        # modules starting with a first.
+        return self._name.get_root_context()
+
+    @property
+    def module_path(self):
+        """Shows the file path of a module. e.g. ``/usr/lib/python2.7/os.py``"""
+        module = self._get_module_context()
+        if module.is_stub() or not module.is_compiled():
+            # Compiled modules should not return a module path even if they
+            # have one.
+            return self._get_module_context().py__file__()
+
+        return None
 
     @property
     def name(self):
@@ -79,7 +99,7 @@ class BaseDefinition(object):
 
         :rtype: str or None
         """
-        return self._name.string_name
+        return self._name.get_public_name()
 
     @property
     def type(self):
@@ -88,9 +108,10 @@ class BaseDefinition(object):
 
         Here is an example of the value of this attribute.  Let's consider
         the following source.  As what is in ``variable`` is unambiguous
-        to Jedi, :meth:`jedi.Script.goto_definitions` should return a list of
+        to Jedi, :meth:`jedi.Script.infer` should return a list of
         definition for ``sys``, ``f``, ``C`` and ``x``.
 
+        >>> from jedi._compatibility import no_unicode_pprint
         >>> from jedi import Script
         >>> source = '''
         ... import keyword
@@ -110,15 +131,17 @@ class BaseDefinition(object):
         ...     variable'''
 
         >>> script = Script(source)
-        >>> defs = script.goto_definitions()
+        >>> defs = script.infer()
 
         Before showing what is in ``defs``, let's sort it by :attr:`line`
         so that it is easy to relate the result to the source code.
 
         >>> defs = sorted(defs, key=lambda d: d.line)
-        >>> defs                           # doctest: +NORMALIZE_WHITESPACE
-        [<Definition module keyword>, <Definition class C>,
-         <Definition instance D>, <Definition def f>]
+        >>> no_unicode_pprint(defs)  # doctest: +NORMALIZE_WHITESPACE
+        [<Definition full_name='keyword', description='module keyword'>,
+         <Definition full_name='__main__.C', description='class C'>,
+         <Definition full_name='__main__.D', description='instance D'>,
+         <Definition full_name='__main__.f', description='def f'>]
 
         Finally, here is what you can get from :attr:`type`:
 
@@ -132,6 +155,9 @@ class BaseDefinition(object):
         >>> defs[3]
         'function'
 
+        Valid values for are ``module``, ``class``, ``instance``, ``function``,
+        ``param``, ``path`` and ``keyword``.
+
         """
         tree_name = self._name.tree_name
         resolve = False
@@ -143,50 +169,10 @@ class BaseDefinition(object):
                 resolve = True
 
         if isinstance(self._name, imports.SubModuleName) or resolve:
-            for context in self._name.infer():
-                return context.api_type
+            for value in self._name.infer():
+                return value.api_type
         return self._name.api_type
 
-    def _path(self):
-        """The path to a module/class/function definition."""
-        def to_reverse():
-            name = self._name
-            if name.api_type == 'module':
-                try:
-                    name = list(name.infer())[0].name
-                except IndexError:
-                    pass
-
-            if name.api_type in 'module':
-                module_contexts = name.infer()
-                if module_contexts:
-                    module_context, = module_contexts
-                    for n in reversed(module_context.py__name__().split('.')):
-                        yield n
-                else:
-                    # We don't really know anything about the path here. This
-                    # module is just an import that would lead in an
-                    # ImportError. So simply return the name.
-                    yield name.string_name
-                    return
-            else:
-                yield name.string_name
-
-            parent_context = name.parent_context
-            while parent_context is not None:
-                try:
-                    method = parent_context.py__name__
-                except AttributeError:
-                    try:
-                        yield parent_context.name.string_name
-                    except AttributeError:
-                        pass
-                else:
-                    for name in reversed(method().split('.')):
-                        yield name
-                parent_context = parent_context.parent_context
-        return reversed(list(to_reverse()))
-
     @property
     def module_name(self):
         """
@@ -195,15 +181,18 @@ class BaseDefinition(object):
         >>> from jedi import Script
         >>> source = 'import json'
         >>> script = Script(source, path='example.py')
-        >>> d = script.goto_definitions()[0]
-        >>> print(d.module_name)                       # doctest: +ELLIPSIS
+        >>> d = script.infer()[0]
+        >>> print(d.module_name)  # doctest: +ELLIPSIS
         json
         """
-        return self._module.name.string_name
+        return self._get_module_context().py__name__()
 
     def in_builtin_module(self):
         """Whether this is a builtin module."""
-        return isinstance(self._module, compiled.CompiledObject)
+        value = self._get_module_context().get_value()
+        if isinstance(value, StubModuleValue):
+            return any(v.is_compiled() for v in value.non_stub_value_set)
+        return value.is_compiled()
 
     @property
     def line(self):
@@ -232,18 +221,18 @@ class BaseDefinition(object):
         ... def f(a, b=1):
         ...     "Document for function f."
         ... '''
-        >>> script = Script(source, 1, len('def f'), 'example.py')
-        >>> doc = script.goto_definitions()[0].docstring()
+        >>> script = Script(source, path='example.py')
+        >>> doc = script.infer(1, len('def f'))[0].docstring()
         >>> print(doc)
         f(a, b=1)
         <BLANKLINE>
         Document for function f.
 
         Notice that useful extra information is added to the actual
-        docstring.  For function, it is call signature.  If you need
+        docstring.  For function, it is signature.  If you need
         actual docstring, use ``raw=True`` instead.
 
-        >>> print(script.goto_definitions()[0].docstring(raw=True))
+        >>> print(script.infer(1, len('def f'))[0].docstring(raw=True))
         Document for function f.
 
         :param fast: Don't follow imports that are only one level deep like
@@ -252,12 +241,76 @@ class BaseDefinition(object):
             the ``foo.docstring(fast=False)`` on every object, because it
             parses all libraries starting with ``a``.
         """
-        return _Help(self._name).docstring(fast=fast, raw=raw)
+        if isinstance(self._name, ImportName) and fast:
+            return ''
+        doc = self._get_docstring()
+        if raw:
+            return doc
+
+        signature_text = self._get_docstring_signature()
+        if signature_text and doc:
+            return signature_text + '\n\n' + doc
+        else:
+            return signature_text + doc
+
+    def _get_docstring(self):
+        return self._name.py__doc__()
+
+    def _get_docstring_signature(self):
+        return '\n'.join(
+            signature.to_string()
+            for signature in self._get_signatures(for_docstring=True)
+        )
 
     @property
     def description(self):
-        """A textual description of the object."""
-        return self._name.string_name
+        """
+        A description of the :class:`.Definition` object, which is heavily used
+        in testing. e.g. for ``isinstance`` it returns ``def isinstance``.
+
+        Example:
+
+        >>> from jedi._compatibility import no_unicode_pprint
+        >>> from jedi import Script
+        >>> source = '''
+        ... def f():
+        ...     pass
+        ...
+        ... class C:
+        ...     pass
+        ...
+        ... variable = f if random.choice([0,1]) else C'''
+        >>> script = Script(source)  # line is maximum by default
+        >>> defs = script.infer(column=3)
+        >>> defs = sorted(defs, key=lambda d: d.line)
+        >>> no_unicode_pprint(defs)  # doctest: +NORMALIZE_WHITESPACE
+        [<Definition full_name='__main__.f', description='def f'>,
+         <Definition full_name='__main__.C', description='class C'>]
+        >>> str(defs[0].description)  # strip literals in python2
+        'def f'
+        >>> str(defs[1].description)
+        'class C'
+
+        """
+        typ = self.type
+        tree_name = self._name.tree_name
+        if typ == 'param':
+            return typ + ' ' + self._name.to_string()
+        if typ in ('function', 'class', 'module', 'instance') or tree_name is None:
+            if typ == 'function':
+                # For the description we want a short and a pythonic way.
+                typ = 'def'
+            return typ + ' ' + self._name.get_public_name()
+
+        definition = tree_name.get_definition(include_setitem=True) or tree_name
+        # Remove the prefix, because that's not what we want for get_code
+        # here.
+        txt = definition.get_code(include_prefix=False)
+        # Delete comments:
+        txt = re.sub(r'#[^\n]+\n', ' ', txt)
+        # Delete multi spaces/newlines
+        txt = re.sub(r'\s+', ' ', txt).strip()
+        return txt
 
     @property
     def full_name(self):
@@ -274,8 +327,8 @@ class BaseDefinition(object):
         >>> source = '''
         ... import os
         ... os.path.join'''
-        >>> script = Script(source, 3, len('os.path.join'), 'example.py')
-        >>> print(script.goto_definitions()[0].full_name)
+        >>> script = Script(source, path='example.py')
+        >>> print(script.infer(3, len('os.path.join'))[0].full_name)
         os.path.join
 
         Notice that it returns ``'os.path.join'`` instead of (for example)
@@ -283,84 +336,142 @@ class BaseDefinition(object):
         be ``<module 'posixpath' ...>```. However most users find the latter
         more practical.
         """
-        path = list(self._path())
-        # TODO add further checks, the mapping should only occur on stdlib.
-        if not path:
-            return None  # for keywords the path is empty
+        if not self._name.is_value_name:
+            return None
 
-        with ignored(KeyError):
-            path[0] = self._mapping[path[0]]
-        for key, repl in self._tuple_mapping.items():
-            if tuple(path[:len(key)]) == key:
-                path = [repl] + path[len(key):]
+        names = self._name.get_qualified_names(include_module_names=True)
+        if names is None:
+            return names
 
-        return '.'.join(path if path[0] else path[1:])
+        names = list(names)
+        try:
+            names[0] = self._mapping[names[0]]
+        except KeyError:
+            pass
 
-    def goto_assignments(self):
-        if self._name.tree_name is None:
-            return self
+        return '.'.join(names)
 
-        names = self._evaluator.goto(self._name.parent_context, self._name.tree_name)
-        return [Definition(self._evaluator, n) for n in names]
+    def is_stub(self):
+        if not self._name.is_value_name:
+            return False
 
-    def _goto_definitions(self):
-        # TODO make this function public.
-        return [Definition(self._evaluator, d.name) for d in self._name.infer()]
+        return self._name.get_root_context().is_stub()
+
+    def goto(self, **kwargs):
+        with debug.increase_indent_cm('goto for %s' % self._name):
+            return self._goto(**kwargs)
+
+    def goto_assignments(self, **kwargs):  # Python 2...
+        warnings.warn(
+            "Deprecated since version 0.16.0. Use .goto.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.goto(**kwargs)
+
+    def _goto(self, follow_imports=False, follow_builtin_imports=False,
+              only_stubs=False, prefer_stubs=False):
+
+        if not self._name.is_value_name:
+            return []
+
+        names = self._name.goto()
+        if follow_imports:
+            names = filter_follow_imports(names, follow_builtin_imports)
+        names = convert_names(
+            names,
+            only_stubs=only_stubs,
+            prefer_stubs=prefer_stubs,
+        )
+        return [self if n == self._name else Definition(self._inference_state, n)
+                for n in names]
+
+    def infer(self, **kwargs):  # Python 2...
+        with debug.increase_indent_cm('infer for %s' % self._name):
+            return self._infer(**kwargs)
+
+    def _infer(self, only_stubs=False, prefer_stubs=False):
+        assert not (only_stubs and prefer_stubs)
+
+        if not self._name.is_value_name:
+            return []
+
+        # First we need to make sure that we have stub names (if possible) that
+        # we can follow. If we don't do that, we can end up with the inferred
+        # results of Python objects instead of stubs.
+        names = convert_names([self._name], prefer_stubs=True)
+        values = convert_values(
+            ValueSet.from_sets(n.infer() for n in names),
+            only_stubs=only_stubs,
+            prefer_stubs=prefer_stubs,
+        )
+        resulting_names = [c.name for c in values]
+        return [self if n == self._name else Definition(self._inference_state, n)
+                for n in resulting_names]
 
     @property
     @memoize_method
     def params(self):
         """
-        Raises an ``AttributeError``if the definition is not callable.
+        Deprecated! Will raise a warning soon. Use get_signatures()[...].params.
+
+        Raises an ``AttributeError`` if the definition is not callable.
         Otherwise returns a list of `Definition` that represents the params.
         """
-        def get_param_names(context):
-            param_names = []
-            if context.api_type == 'function':
-                param_names = list(context.get_param_names())
-                if isinstance(context, instance.BoundMethod):
-                    param_names = param_names[1:]
-            elif isinstance(context, (instance.AbstractInstanceContext, ClassContext)):
-                if isinstance(context, ClassContext):
-                    search = u'__init__'
-                else:
-                    search = u'__call__'
-                names = context.get_function_slot_names(search)
-                if not names:
-                    return []
+        warnings.warn(
+            "Deprecated since version 0.16.0. Use get_signatures()[...].params",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        # Only return the first one. There might be multiple one, especially
+        # with overloading.
+        for signature in self._get_signatures():
+            return [
+                Definition(self._inference_state, n)
+                for n in signature.get_param_names(resolve_stars=True)
+            ]
 
-                # Just take the first one here, not optimal, but currently
-                # there's no better solution.
-                inferred = names[0].infer()
-                param_names = get_param_names(next(iter(inferred)))
-                if isinstance(context, ClassContext):
-                    param_names = param_names[1:]
-                return param_names
-            elif isinstance(context, compiled.CompiledObject):
-                return list(context.get_param_names())
-            return param_names
-
-        followed = list(self._name.infer())
-        if not followed or not hasattr(followed[0], 'py__call__'):
-            raise AttributeError()
-        context = followed[0]  # only check the first one.
-
-        return [Definition(self._evaluator, n) for n in get_param_names(context)]
+        if self.type == 'function' or self.type == 'class':
+            # Fallback, if no signatures were defined (which is probably by
+            # itself a bug).
+            return []
+        raise AttributeError('There are no params defined on this.')
 
     def parent(self):
-        context = self._name.parent_context
-        if context is None:
+        if not self._name.is_value_name:
             return None
 
-        if isinstance(context, FunctionExecutionContext):
-            # TODO the function context should be a part of the function
-            # execution context.
-            context = FunctionContext(
-                self._evaluator, context.parent_context, context.tree_node)
-        return Definition(self._evaluator, context.name)
+        if self.type in ('function', 'class', 'param') and self._name.tree_name is not None:
+            # Since the parent_context doesn't really match what the user
+            # thinks of that the parent is here, we do these cases separately.
+            # The reason for this is the following:
+            # - class: Nested classes parent_context is always the
+            #   parent_context of the most outer one.
+            # - function: Functions in classes have the module as
+            #   parent_context.
+            # - param: The parent_context of a param is not its function but
+            #   e.g. the outer class or module.
+            cls_or_func_node = self._name.tree_name.get_definition()
+            parent = search_ancestor(cls_or_func_node, 'funcdef', 'classdef', 'file_input')
+            context = self._get_module_context().create_value(parent).as_context()
+        else:
+            context = self._name.parent_context
+
+        if context is None:
+            return None
+        while context.name is None:
+            # Happens for comprehension contexts
+            context = context.parent_context
+
+        return Definition(self._inference_state, context.name)
 
     def __repr__(self):
-        return "<%s %s>" % (type(self).__name__, self.description)
+        return "<%s %sname=%r, description=%r>" % (
+            self.__class__.__name__,
+            'full_' if self.full_name else '',
+            self.full_name or self.name,
+            self.description,
+        )
 
     def get_line_code(self, before=0, after=0):
         """
@@ -372,26 +483,50 @@ class BaseDefinition(object):
         :return str: Returns the line(s) of code or an empty string if it's a
                      builtin.
         """
-        if self.in_builtin_module():
+        if not self._name.is_value_name:
             return ''
 
         lines = self._name.get_root_context().code_lines
+        if lines is None:
+            # Probably a builtin module, just ignore in that case.
+            return ''
 
         index = self._name.start_pos[0] - 1
         start_index = max(index - before, 0)
         return ''.join(lines[start_index:index + after + 1])
 
+    def _get_signatures(self, for_docstring=False):
+        if for_docstring and self._name.api_type == 'statement' and not self.is_stub():
+            # For docstrings we don't resolve signatures if they are simple
+            # statements and not stubs. This is a speed optimization.
+            return []
+
+        names = convert_names([self._name], prefer_stubs=True)
+        return [sig for name in names for sig in name.infer().get_signatures()]
+
+    def get_signatures(self):
+        return [
+            BaseSignature(self._inference_state, s)
+            for s in self._get_signatures()
+        ]
+
+    def execute(self):
+        return _values_to_definitions(self._name.infer().execute_with_values())
+
 
 class Completion(BaseDefinition):
     """
-    `Completion` objects are returned from :meth:`api.Script.completions`. They
+    `Completion` objects are returned from :meth:`api.Script.complete`. They
     provide additional information about a completion.
     """
-    def __init__(self, evaluator, name, stack, like_name_length):
-        super(Completion, self).__init__(evaluator, name)
+    def __init__(self, inference_state, name, stack, like_name_length,
+                 is_fuzzy, cached_name=None):
+        super(Completion, self).__init__(inference_state, name)
 
         self._like_name_length = like_name_length
         self._stack = stack
+        self._is_fuzzy = is_fuzzy
+        self._cached_name = cached_name
 
         # Completion objects with the same Completion name (which means
         # duplicate items in the completion)
@@ -400,15 +535,10 @@ class Completion(BaseDefinition):
     def _complete(self, like_name):
         append = ''
         if settings.add_bracket_after_function \
-                and self.type == 'Function':
+                and self.type == 'function':
             append = '('
 
-        if self._name.api_type == 'param' and self._stack is not None:
-            node_names = list(self._stack.get_node_names(self._evaluator.grammar._pgen_grammar))
-            if 'trailer' in node_names and 'argument' not in node_names:
-                append += '='
-
-        name = self._name.string_name
+        name = self._name.get_public_name()
         if like_name:
             name = name[self._like_name_length:]
         return name + append
@@ -416,6 +546,9 @@ class Completion(BaseDefinition):
     @property
     def complete(self):
         """
+        Only works with non-fuzzy completions. Returns None if fuzzy
+        completions are used.
+
         Return the rest of the word, e.g. completing ``isinstance``::
 
             isinstan# <-- Cursor is here
@@ -430,9 +563,9 @@ class Completion(BaseDefinition):
 
         completing ``foo(par`` would give a ``Completion`` which `complete`
         would be `am=`
-
-
         """
+        if self._is_fuzzy:
+            return None
         return self._complete(True)
 
     @property
@@ -455,20 +588,55 @@ class Completion(BaseDefinition):
             # In this case we can just resolve the like name, because we
             # wouldn't load like > 100 Python modules anymore.
             fast = False
+
         return super(Completion, self).docstring(raw=raw, fast=fast)
 
+    def _get_docstring(self):
+        if self._cached_name is not None:
+            return completion_cache.get_docstring(
+                self._cached_name,
+                self._name.get_public_name(),
+                lambda: self._get_cache()
+            )
+        return super(Completion, self)._get_docstring()
+
+    def _get_docstring_signature(self):
+        if self._cached_name is not None:
+            return completion_cache.get_docstring_signature(
+                self._cached_name,
+                self._name.get_public_name(),
+                lambda: self._get_cache()
+            )
+        return super(Completion, self)._get_docstring_signature()
+
+    def _get_cache(self):
+        typ = super(Completion, self).type
+        return (
+            typ,
+            super(Completion, self)._get_docstring_signature(),
+            super(Completion, self)._get_docstring(),
+        )
+
     @property
-    def description(self):
-        """Provide a description of the completion object."""
-        # TODO improve the class structure.
-        return Definition.description.__get__(self)
+    def type(self):
+        # Purely a speed optimization.
+        if self._cached_name is not None:
+            return completion_cache.get_type(
+                self._cached_name,
+                self._name.get_public_name(),
+                lambda: self._get_cache()
+            )
+
+        return super(Completion, self).type
 
     def __repr__(self):
-        return '<%s: %s>' % (type(self).__name__, self._name.string_name)
+        return '<%s: %s>' % (type(self).__name__, self._name.get_public_name())
 
     @memoize_method
     def follow_definition(self):
         """
+        Deprecated!
+
         Return the original definitions. I strongly recommend not using it for
         your completions, because it might slow down |jedi|. If you want to
         read only a few objects (<=20), it might be useful, especially to get
@@ -476,69 +644,21 @@ class Completion(BaseDefinition):
         follows all results. This means with 1000 completions (e.g.  numpy),
         it's just PITA-slow.
         """
-        defs = self._name.infer()
-        return [Definition(self._evaluator, d.name) for d in defs]
+        warnings.warn(
+            "Deprecated since version 0.14.0. Use .infer.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.infer()
 
 
 class Definition(BaseDefinition):
     """
-    *Definition* objects are returned from :meth:`api.Script.goto_assignments`
-    or :meth:`api.Script.goto_definitions`.
+    *Definition* objects are returned from :meth:`api.Script.goto`
+    or :meth:`api.Script.infer`.
     """
-    def __init__(self, evaluator, definition):
-        super(Definition, self).__init__(evaluator, definition)
-
-    @property
-    def description(self):
-        """
-        A description of the :class:`.Definition` object, which is heavily used
-        in testing. e.g. for ``isinstance`` it returns ``def isinstance``.
-
-        Example:
-
-        >>> from jedi import Script
-        >>> source = '''
-        ... def f():
-        ...     pass
-        ...
-        ... class C:
-        ...     pass
-        ...
-        ... variable = f if random.choice([0,1]) else C'''
-        >>> script = Script(source, column=3)  # line is maximum by default
-        >>> defs = script.goto_definitions()
-        >>> defs = sorted(defs, key=lambda d: d.line)
-        >>> defs
-        [<Definition def f>, <Definition class C>]
-        >>> str(defs[0].description)  # strip literals in python2
-        'def f'
-        >>> str(defs[1].description)
-        'class C'
-
-        """
-        typ = self.type
-        tree_name = self._name.tree_name
-        if typ in ('function', 'class', 'module', 'instance') or tree_name is None:
-            if typ == 'function':
-                # For the description we want a short and a pythonic way.
-                typ = 'def'
-            return typ + ' ' + self._name.string_name
-        elif typ == 'param':
-            code = search_ancestor(tree_name, 'param').get_code(
-                include_prefix=False,
-                include_comma=False
-            )
-            return typ + ' ' + code
-
-        definition = tree_name.get_definition() or tree_name
-        # Remove the prefix, because that's not what we want for get_code
-        # here.
-        txt = definition.get_code(include_prefix=False)
-        # Delete comments:
-        txt = re.sub('#[^\n]+\n', ' ', txt)
-        # Delete multi spaces/newlines
-        txt = re.sub('\s+', ' ', txt).strip()
-        return txt
+    def __init__(self, inference_state, definition):
+        super(Definition, self).__init__(inference_state, definition)
 
     @property
     def desc_with_module(self):
@@ -563,7 +683,7 @@ class Definition(BaseDefinition):
         """
         defs = self._name.infer()
         return sorted(
-            unite(defined_names(self._evaluator, d) for d in defs),
+            unite(defined_names(self._inference_state, d.as_context()) for d in defs),
             key=lambda s: s._name.start_pos or (0, 0)
         )
 
@@ -581,26 +701,48 @@ class Definition(BaseDefinition):
         return self._name.start_pos == other._name.start_pos \
             and self.module_path == other.module_path \
             and self.name == other.name \
-            and self._evaluator == other._evaluator
+            and self._inference_state == other._inference_state
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     def __hash__(self):
-        return hash((self._name.start_pos, self.module_path, self.name, self._evaluator))
+        return hash((self._name.start_pos, self.module_path, self.name, self._inference_state))
 
 
-class CallSignature(Definition):
+class BaseSignature(Definition):
     """
-    `CallSignature` objects is the return value of `Script.function_definition`.
+    `BaseSignature` objects is the return value of `Script.function_definition`.
     It knows what functions you are currently in. e.g. `isinstance(` would
     return the `isinstance` function. without `(` it would return nothing.
     """
-    def __init__(self, evaluator, executable_name, bracket_start_pos, index, key_name_str):
-        super(CallSignature, self).__init__(evaluator, executable_name)
-        self._index = index
-        self._key_name_str = key_name_str
-        self._bracket_start_pos = bracket_start_pos
+    def __init__(self, inference_state, signature):
+        super(BaseSignature, self).__init__(inference_state, signature.name)
+        self._signature = signature
+
+    @property
+    def params(self):
+        """
+        :return list of ParamDefinition:
+        """
+        return [ParamDefinition(self._inference_state, n)
+                for n in self._signature.get_param_names(resolve_stars=True)]
+
+    def to_string(self):
+        return self._signature.to_string()
+
+
+class Signature(BaseSignature):
+    """
+    `Signature` objects is the return value of `Script.get_signatures`.
+    It knows what functions you are currently in. e.g. `isinstance(` would
+    return the `isinstance` function with its params. Without `(` it would
+    return nothing.
+    """
+    def __init__(self, inference_state, signature, call_details):
+        super(Signature, self).__init__(inference_state, signature)
+        self._call_details = call_details
+        self._signature = signature
 
     @property
     def index(self):
@@ -608,67 +750,55 @@ class CallSignature(Definition):
         The Param index of the current call.
         Returns None if the index cannot be found in the curent call.
         """
-        if self._key_name_str is not None:
-            for i, param in enumerate(self.params):
-                if self._key_name_str == param.name:
-                    return i
-            if self.params:
-                param_name = self.params[-1]._name
-                if param_name.tree_name is not None:
-                    if param_name.tree_name.get_definition().star_count == 2:
-                        return i
-            return None
-
-        if self._index >= len(self.params):
-            for i, param in enumerate(self.params):
-                tree_name = param._name.tree_name
-                if tree_name is not None:
-                    # *args case
-                    if tree_name.get_definition().star_count == 1:
-                        return i
-            return None
-        return self._index
+        return self._call_details.calculate_index(
+            self._signature.get_param_names(resolve_stars=True)
+        )
 
     @property
     def bracket_start(self):
         """
-        The indent of the bracket that is responsible for the last function
-        call.
+        The line/column of the bracket that is responsible for the last
+        function call.
         """
-        return self._bracket_start_pos
+        return self._call_details.bracket_leaf.start_pos
 
     def __repr__(self):
-        return '<%s: %s index %s>' % \
-            (type(self).__name__, self._name.string_name, self.index)
+        return '<%s: index=%r %s>' % (
+            type(self).__name__,
+            self.index,
+            self._signature.to_string(),
+        )
 
 
-class _Help(object):
-    """
-    Temporary implementation, will be used as `Script.help() or something in
-    the future.
-    """
-    def __init__(self, definition):
-        self._name = definition
-
-    @memoize_method
-    def _get_contexts(self, fast):
-        if isinstance(self._name, ImportName) and fast:
-            return {}
-
-        if self._name.api_type == 'statement':
-            return {}
-
-        return self._name.infer()
-
-    def docstring(self, fast=True, raw=True):
+class ParamDefinition(Definition):
+    def infer_default(self):
         """
-        The docstring ``__doc__`` for any object.
-
-        See :attr:`doc` for example.
+        :return list of Definition:
         """
-        # TODO: Use all of the followed objects as output. Possibly divinding
-        # them by a few dashes.
-        for context in self._get_contexts(fast=fast):
-            return context.py__doc__(include_call_signature=not raw)
+        return _values_to_definitions(self._name.infer_default())
 
-        return ''
+    def infer_annotation(self, **kwargs):
+        """
+        :return list of Definition:
+
+        :param execute_annotation: If False, the values are not executed and
+            you get classes instead of instances.
+        """
+        return _values_to_definitions(self._name.infer_annotation(ignore_stars=True, **kwargs))
+
+    def to_string(self):
+        return self._name.to_string()
+
+    @property
+    def kind(self):
+        """
+        Returns an enum instance. Returns the same values as the builtin
+        :py:attr:`inspect.Parameter.kind`.
+
+        No support for Python < 3.4 anymore.
+        """
+        if sys.version_info < (3, 5):
+            raise NotImplementedError(
+                'Python 2 is end-of-life, the new feature is not available for it'
+            )
+        return self._name.get_kind()

jedi/api/completion.py

@@ -1,74 +1,88 @@
-from parso.python import token
+import re
+from textwrap import dedent
+
+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.evaluate import imports
 from jedi.api import keywords
-from jedi.evaluate.helpers import evaluate_call_of_leaf
-from jedi.evaluate.filters import get_global_filters
-from jedi.parser_utils import get_statement_of_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, ModuleValue
+from jedi.inference.names import ParamNameWrapper
+from jedi.inference.gradual.conversion import convert_values
+from jedi.parser_utils import cut_value_at_position
+from jedi.plugins import plugin_manager
 
 
-def get_call_signature_param_names(call_signatures):
+class ParamNameWithEquals(ParamNameWrapper):
+    def get_public_name(self):
+        return self.string_name + '='
+
+
+def get_signature_param_names(signatures):
     # add named params
-    for call_sig in call_signatures:
+    for call_sig in 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
+                yield ParamNameWithEquals(p._name)
 
 
-def filter_names(evaluator, completion_names, stack, like_name):
-    comp_dct = {}
+def filter_names(inference_state, completion_names, stack, like_name, fuzzy, 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 settings.case_insensitive_completion:
             string = string.lower()
-
-        if string.startswith(like_name):
+        if fuzzy:
+            match = helpers.fuzzy_match(string, like_name)
+        else:
+            match = helpers.start_match(string, like_name)
+        if match:
             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)):
-                        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):
@@ -79,33 +93,76 @@ 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_method):
-        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
         self._like_name = helpers.get_on_completion_name(self._module_node, code_lines, position)
         # The actual cursor position is not what we need to calculate
         # everything. We want the start of the name we're on.
-        self._position = position[0], position[1] - len(self._like_name)
-        self._call_signatures_method = call_signatures_method
+        self._original_position = position
+        self._signatures_callback = signatures_callback
 
-    def completions(self):
-        completion_names = self._get_context_completions()
+        self._fuzzy = fuzzy
 
-        completions = filter_names(self._evaluator, completion_names,
-                                   self.stack, self._like_name)
+    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)
 
-        return sorted(completions, key=lambda x: (x.name.startswith('__'),
-                                                  x.name.startswith('_'),
-                                                  x.name.lower()))
+        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,
+        )
 
-    def _get_context_completions(self):
+        if string is not None and not prefixed_completions:
+            prefixed_completions = list(complete_file_name(
+                self._inference_state, self._module_context, start_leaf, string,
+                self._like_name, self._signatures_callback,
+                self._code_lines, self._original_position,
+                self._fuzzy
+            ))
+        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
+
+        cached_name, completion_names = self._complete_python(leaf)
+
+        completions = list(filter_names(self._inference_state, completion_names,
+                                        self.stack, self._like_name,
+                                        self._fuzzy, cached_name=cached_name))
+
+        return (
+            # Removing duplicates mostly to remove False/True/None duplicates.
+            _remove_duplicates(prefixed_completions, completions)
+            + sorted(completions, key=lambda x: (x.name.startswith('__'),
+                                                 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
@@ -118,26 +175,32 @@ class 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 = helpers.get_stack_at_position(
-                grammar, self._code_lines, self._module_node, self._position
+            self.stack = stack = helpers.get_stack_at_position(
+                grammar, self._code_lines, leaf, self._position
             )
         except helpers.OnErrorLeaf as e:
-            self.stack = None
-            if e.error_leaf.value == '.':
+            value = e.error_leaf.value
+            if value == '.':
                 # After ErrorLeaf's that are dots, we will not do any
                 # completions since this probably just confuses the user.
-                return []
-            # If we don't have a context, just use global completion.
+                return cached_name, []
 
-            return self._global_completions()
+            # If we don't have a value, just use global completion.
+            return cached_name, self._complete_global_scope()
 
-        allowed_keywords, allowed_tokens = \
-            helpers.get_possible_completion_types(grammar._pgen_grammar, self.stack)
+        allowed_transitions = \
+            list(stack._allowed_transition_names_and_token_types())
 
-        if 'if' in allowed_keywords:
+        if 'if' in allowed_transitions:
             leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True)
             previous_leaf = leaf.get_previous_leaf()
 
@@ -163,127 +226,349 @@ class Completion:
                     # Compare indents
                     if stmt.start_pos[1] == indent:
                         if type_ == 'if_stmt':
-                            allowed_keywords += ['elif', 'else']
+                            allowed_transitions += ['elif', 'else']
                         elif type_ == 'try_stmt':
-                            allowed_keywords += ['except', 'finally', 'else']
+                            allowed_transitions += ['except', 'finally', 'else']
                         elif type_ == 'for_stmt':
-                            allowed_keywords.append('else')
+                            allowed_transitions.append('else')
 
-        completion_names = list(self._get_keyword_completion_names(allowed_keywords))
+        completion_names = []
+        current_line = self._code_lines[self._position[0] - 1][:self._position[1]]
 
-        if token.NAME in allowed_tokens or token.INDENT in allowed_tokens:
+        completion_names += self._complete_keywords(
+            allowed_transitions,
+            only_values=not (not current_line or current_line[-1] in ' \t.;'
+                             and current_line[-3:] != '...')
+        )
+
+        if any(t in allowed_transitions for t in (PythonTokenTypes.NAME,
+                                                  PythonTokenTypes.INDENT)):
             # This means that we actually have to do type inference.
 
-            symbol_names = list(self.stack.get_node_names(grammar._pgen_grammar))
-
-            nodes = list(self.stack.get_nodes())
+            nonterminals = [stack_node.nonterminal for stack_node in stack]
 
+            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))
-            elif "import_stmt" in symbol_names:
-                level, names = self._parse_dotted_names(nodes, "import_from" in symbol_names)
+                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)
 
-                only_modules = not ("import_from" in symbol_names and 'import' in nodes)
+                only_modules = not ("import_from" in nonterminals and 'import' in nodes)
                 completion_names += self._get_importer_names(
                     names,
                     level,
                     only_modules=only_modules,
                 )
-            elif symbol_names[-1] in ('trailer', 'dotted_name') and nodes[-1] == '.':
+            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())
+                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)
+                completion_names += self._complete_global_scope()
+                completion_names += self._complete_inherited(is_function=False)
 
-            if 'trailer' in symbol_names:
-                call_signatures = self._call_signatures_method()
-                completion_names += get_call_signature_param_names(call_signatures)
+            # 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)
+                completion_names += get_signature_param_names(signatures)
 
-        return completion_names
+        return cached_name, completion_names
 
-    def _get_keyword_completion_names(self, keywords_):
-        for k in keywords_:
-            yield keywords.KeywordName(self._evaluator, k)
+    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 _global_completions(self):
-        context = get_user_scope(self._module_context, self._position)
+    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.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():
+                if not only_values or k in ('True', 'False', 'None'):
+                    yield keywords.KeywordName(self._inference_state, k)
+
+    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)
+    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')
+
+        # 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)
+
         completion_names = []
-        debug.dbg('trailer completion contexts: %s', contexts)
-        for context in contexts:
-            for filter in context.get_filters(
-                    search_global=False, origin_scope=user_context.tree_node):
+        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 += self._complete_getattr(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 _parse_dotted_names(self, nodes, is_import_from):
-        level = 0
-        names = []
-        for node in nodes[1:]:
-            if node in ('.', '...'):
-                if not names:
-                    level += len(node.value)
-            elif node.type == 'dotted_name':
-                names += node.children[::2]
-            elif node.type == 'name':
-                names.append(node)
-            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 _complete_getattr(self, 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(u'__getattr__')
+                 or instance.get_function_slot_names(u'__getattribute__'))
+        functions = ValueSet.from_sets(
+            name.infer()
+            for name in names
+        )
+        for func in functions:
+            tree_node = func.tree_node
+            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 self._complete_trailer_for_values(objects)
+        return []
 
     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:
             for name in filter.values():
+                # TODO we should probably check here for properties
                 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 = [c or '\n' 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 = ModuleValue(
+            self._inference_state,
+            module_node,
+            code_lines=code_lines,
+        )
+        module_value.parent_context = self._module_context
+        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):
+    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)
+        start = match.group(0)
+        if leaf.line == position[0] and position[1] < leaf.column + match.end():
+            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:
+        if leaf.type == 'error_leaf' and ('"' in leaf.value or "'" in leaf.value):
+            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, None

jedi/api/completion_cache.py

@@ -0,0 +1,25 @@
+_cache = {}
+
+
+def save_entry(module_name, name, cache):
+    try:
+        module_cache = _cache[module_name]
+    except KeyError:
+        module_cache = _cache[module_name] = {}
+    module_cache[name] = cache
+
+
+def _create_get_from_cache(number):
+    def _get_from_cache(module_name, name, get_cache_values):
+        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

@@ -3,27 +3,23 @@ Environments are a way to activate different Python versions or Virtualenvs for
 static analysis. The Python binary in that environment is going to be executed.
 """
 import os
-import re
 import sys
 import hashlib
 import filecmp
-from subprocess import PIPE
 from collections import namedtuple
-# When dropping Python 2.7 support we should consider switching to
-# `shutil.which`.
-from distutils.spawn import find_executable
 
-from jedi._compatibility import GeneralizedPopen
+from jedi._compatibility import highest_pickle_protocol, which
 from jedi.cache import memoize_method, time_cache
-from jedi.evaluate.compiled.subprocess import get_subprocess, \
-    EvaluatorSameProcess, EvaluatorSubprocess
+from jedi.inference.compiled.subprocess import CompiledSubprocess, \
+    InferenceStateSameProcess, InferenceStateSubprocess
 
 import parso
 
 _VersionInfo = namedtuple('VersionInfo', 'major minor micro')
 
-_SUPPORTED_PYTHONS = ['3.6', '3.5', '3.4', '3.3', '2.7']
+_SUPPORTED_PYTHONS = ['3.8', '3.7', '3.6', '3.5', '3.4', '2.7']
 _SAFE_PATHS = ['/usr/bin', '/usr/local/bin']
+_CONDA_VAR = 'CONDA_PREFIX'
 _CURRENT_VERSION = '%s.%s' % (sys.version_info.major, sys.version_info.minor)
 
 
@@ -49,56 +45,73 @@ class _BaseEnvironment(object):
             return self._hash
 
 
+def _get_info():
+    return (
+        sys.executable,
+        sys.prefix,
+        sys.version_info[:3],
+    )
+
+
 class Environment(_BaseEnvironment):
     """
     This class is supposed to be created by internal Jedi architecture. You
     should not create it directly. Please use create_environment or the other
     functions instead. It is then returned by that function.
     """
-    def __init__(self, path, executable):
-        self.path = os.path.abspath(path)
-        """
-        The path to an environment, matches ``sys.prefix``.
-        """
-        self.executable = os.path.abspath(executable)
+    _subprocess = None
+
+    def __init__(self, executable):
+        self._start_executable = executable
+        # Initialize the environment
+        self._get_subprocess()
+
+    def _get_subprocess(self):
+        if self._subprocess is not None and not self._subprocess.is_crashed:
+            return self._subprocess
+
+        try:
+            self._subprocess = CompiledSubprocess(self._start_executable)
+            info = self._subprocess._send(None, _get_info)
+        except Exception as exc:
+            raise InvalidPythonEnvironment(
+                "Could not get version information for %r: %r" % (
+                    self._start_executable,
+                    exc))
+
+        # Since it could change and might not be the same(?) as the one given,
+        # set it here.
+        self.executable = info[0]
         """
         The Python executable, matches ``sys.executable``.
         """
-        self.version_info = self._get_version()
+        self.path = info[1]
+        """
+        The path to an environment, matches ``sys.prefix``.
+        """
+        self.version_info = _VersionInfo(*info[2])
         """
-
         Like ``sys.version_info``. A tuple to show the current Environment's
         Python version.
         """
 
-    def _get_version(self):
-        try:
-            process = GeneralizedPopen([self.executable, '--version'], stdout=PIPE, stderr=PIPE)
-            stdout, stderr = process.communicate()
-            retcode = process.poll()
-            if retcode:
-                raise InvalidPythonEnvironment()
-        except OSError:
-            raise InvalidPythonEnvironment()
+        # py2 sends bytes via pickle apparently?!
+        if self.version_info.major == 2:
+            self.executable = self.executable.decode()
+            self.path = self.path.decode()
 
-        # Until Python 3.4 wthe version string is part of stderr, after that
-        # stdout.
-        output = stdout + stderr
-        match = re.match(br'Python (\d+)\.(\d+)\.(\d+)', output)
-        if match is None:
-            raise InvalidPythonEnvironment("--version not working")
+        # Adjust pickle protocol according to host and client version.
+        self._subprocess._pickle_protocol = highest_pickle_protocol([
+            sys.version_info, self.version_info])
 
-        return _VersionInfo(*[int(m) for m in match.groups()])
+        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_subprocess(self):
-        return get_subprocess(self.executable)
+    def get_inference_state_subprocess(self, inference_state):
+        return InferenceStateSubprocess(inference_state, self._get_subprocess())
 
     @memoize_method
     def get_sys_path(self):
@@ -116,33 +129,42 @@ class Environment(_BaseEnvironment):
         return self._get_subprocess().get_sys_path()
 
 
-class SameEnvironment(Environment):
-    def __init__(self):
-        super(SameEnvironment, self).__init__(sys.prefix, sys.executable)
-
-    def _get_version(self):
-        return _VersionInfo(*sys.version_info[:3])
-
-
-class InterpreterEnvironment(_BaseEnvironment):
+class _SameEnvironmentMixin(object):
     def __init__(self):
+        self._start_executable = self.executable = sys.executable
+        self.path = sys.prefix
         self.version_info = _VersionInfo(*sys.version_info[:3])
 
-    def get_evaluator_subprocess(self, evaluator):
-        return EvaluatorSameProcess(evaluator)
+
+class SameEnvironment(_SameEnvironmentMixin, Environment):
+    pass
+
+
+class InterpreterEnvironment(_SameEnvironmentMixin, _BaseEnvironment):
+    def get_inference_state_subprocess(self, inference_state):
+        return InferenceStateSameProcess(inference_state)
 
     def get_sys_path(self):
         return sys.path
 
 
-def _get_virtual_env_from_var():
-    var = os.environ.get('VIRTUAL_ENV')
-    if var is not None:
-        if var == sys.prefix:
-            return SameEnvironment()
+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(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
+        # /path/to/env so we need to fully resolve the paths in order to
+        # compare them.
+        if os.path.realpath(var) == os.path.realpath(sys.prefix):
+            return _try_get_same_env()
 
         try:
-            return create_environment(var)
+            return create_environment(var, safe=False)
         except InvalidPythonEnvironment:
             pass
 
@@ -157,7 +179,8 @@ 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.
@@ -168,16 +191,69 @@ def get_default_environment():
     if virtual_env is not None:
         return virtual_env
 
-    for environment in find_system_environments():
-        return environment
+    conda_env = _get_virtual_env_from_var(_CONDA_VAR)
+    if conda_env is not None:
+        return conda_env
 
-    # If no Python Environment is found, use the environment we're already
+    return _try_get_same_env()
+
+
+def _try_get_same_env():
+    env = SameEnvironment()
+    if not os.path.basename(env.executable).lower().startswith('python'):
+        # This tries to counter issues with embedding. In some cases (e.g.
+        # VIM's Python Mac/Windows, sys.executable is /foo/bar/vim. This
+        # happens, because for Mac a function called `_NSGetExecutablePath` is
+        # used and for Windows `GetModuleFileNameW`. These are both platform
+        # specific functions. For all other systems sys.executable should be
+        # alright. However here we try to generalize:
+        #
+        # 1. Check if the executable looks like python (heuristic)
+        # 2. In case it's not try to find the executable
+        # 3. In case we don't find it use an interpreter environment.
+        #
+        # The last option will always work, but leads to potential crashes of
+        # Jedi - which is ok, because it happens very rarely and even less,
+        # because the code below should work for most cases.
+        if os.name == 'nt':
+            # The first case would be a virtualenv and the second a normal
+            # Python installation.
+            checks = (r'Scripts\python.exe', 'python.exe')
+        else:
+            # For unix it looks like Python is always in a bin folder.
+            checks = (
+                'bin/python%s.%s' % (sys.version_info[0], sys.version[1]),
+                'bin/python%s' % (sys.version_info[0]),
+                'bin/python',
+            )
+        for check in checks:
+            guess = os.path.join(sys.exec_prefix, check)
+            if os.path.isfile(guess):
+                # Bingo - We think we have our Python.
+                return Environment(guess)
+        # It looks like there is no reasonable Python to be found.
+        return InterpreterEnvironment()
+    # If no virtualenv is found, use the environment we're already
     # using.
-    return SameEnvironment()
+    return env
+
+
+def get_cached_default_environment():
+    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
+    # sys.prefix of the virtualenv is /path/to/env/bin/.. instead of
+    # /path/to/env so we need to fully resolve the paths in order to
+    # compare them.
+    if var and os.path.realpath(var) != os.path.realpath(environment.path):
+        _get_cached_default_environment.clear_cache()
+        return _get_cached_default_environment()
+    return environment
 
 
 @time_cache(seconds=10 * 60)  # 10 Minutes
-def get_cached_default_environment():
+def _get_cached_default_environment():
     return get_default_environment()
 
 
@@ -185,28 +261,37 @@ def find_virtualenvs(paths=None, **kwargs):
     """
     :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`
     """
-    def py27_comp(paths=None, safe=True):
+    def py27_comp(paths=None, safe=True, use_environment_vars=True):
         if paths is None:
             paths = []
 
         _used_paths = set()
 
-        # 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)
+        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)
+
+            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):
@@ -216,13 +301,13 @@ def find_virtualenvs(paths=None, **kwargs):
             for path in os.listdir(directory):
                 path = os.path.join(directory, path)
                 if path in _used_paths:
-                    # A path shouldn't be evaluated twice.
+                    # A path shouldn't be inferred twice.
                     continue
                 _used_paths.add(path)
 
                 try:
                     executable = _get_executable_path(path, safe=safe)
-                    yield Environment(path, executable)
+                    yield Environment(executable)
                 except InvalidPythonEnvironment:
                     pass
 
@@ -246,23 +331,6 @@ def find_system_environments():
             pass
 
 
-# TODO: the logic to find the Python prefix is much more complicated than that.
-# See Modules/getpath.c for UNIX and PC/getpathp.c for Windows in CPython's
-# source code. A solution would be to deduce it by running the Python
-# interpreter and printing the value of sys.prefix.
-def _get_python_prefix(executable):
-    if os.name != 'nt':
-        return os.path.dirname(os.path.dirname(executable))
-    landmark = os.path.join('Lib', 'os.py')
-    prefix = os.path.dirname(executable)
-    while prefix:
-        if os.path.join(prefix, landmark):
-            return prefix
-        prefix = os.path.dirname(prefix)
-    raise InvalidPythonEnvironment(
-        "Cannot find prefix of executable %s." % executable)
-
-
 # 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):
@@ -273,26 +341,33 @@ def get_system_environment(version):
     :raises: :exc:`.InvalidPythonEnvironment`
     :returns: :class:`Environment`
     """
-    exe = find_executable('python' + version)
+    exe = which('python' + version)
     if exe:
         if exe == sys.executable:
             return SameEnvironment()
-        return Environment(_get_python_prefix(exe), exe)
+        return Environment(exe)
 
     if os.name == 'nt':
-        for prefix, exe in _get_executables_from_windows_registry(version):
-            return Environment(prefix, exe)
+        for exe in _get_executables_from_windows_registry(version):
+            try:
+                return Environment(exe)
+            except InvalidPythonEnvironment:
+                pass
     raise InvalidPythonEnvironment("Cannot find executable python%s." % version)
 
 
 def create_environment(path, safe=True):
     """
-    Make it possible to create an environment by hand.
+    Make it possible to manually create an Environment object by specifying a
+    Virtualenv path or an executable path.
 
     :raises: :exc:`.InvalidPythonEnvironment`
     :returns: :class:`Environment`
     """
-    return Environment(path, _get_executable_path(path, safe=safe))
+    if os.path.isfile(path):
+        _assert_safe(path, safe)
+        return Environment(path)
+    return Environment(_get_executable_path(path, safe=safe))
 
 
 def _get_executable_path(path, safe=True):
@@ -307,24 +382,23 @@ def _get_executable_path(path, safe=True):
     if not os.path.exists(python):
         raise InvalidPythonEnvironment("%s seems to be missing." % python)
 
-    if safe and not _is_safe(python):
-        raise InvalidPythonEnvironment("The python binary is potentially unsafe.")
+    _assert_safe(python, safe)
     return python
 
 
 def _get_executables_from_windows_registry(version):
     # The winreg module is named _winreg on Python 2.
     try:
-      import winreg
+        import winreg
     except ImportError:
-      import _winreg as winreg
+        import _winreg as winreg
 
     # TODO: support Python Anaconda.
     sub_keys = [
-      r'SOFTWARE\Python\PythonCore\{version}\InstallPath',
-      r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}\InstallPath',
-      r'SOFTWARE\Python\PythonCore\{version}-32\InstallPath',
-      r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}-32\InstallPath'
+        r'SOFTWARE\Python\PythonCore\{version}\InstallPath',
+        r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}\InstallPath',
+        r'SOFTWARE\Python\PythonCore\{version}-32\InstallPath',
+        r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}-32\InstallPath'
     ]
     for root_key in [winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE]:
         for sub_key in sub_keys:
@@ -334,11 +408,17 @@ def _get_executables_from_windows_registry(version):
                     prefix = winreg.QueryValueEx(key, '')[0]
                     exe = os.path.join(prefix, 'python.exe')
                     if os.path.isfile(exe):
-                        yield prefix, exe
+                        yield exe
             except WindowsError:
                 pass
 
 
+def _assert_safe(executable_path, safe):
+    if safe and not _is_safe(executable_path):
+        raise InvalidPythonEnvironment(
+            "The python binary is potentially unsafe.")
+
+
 def _is_safe(executable_path):
     # Resolve sym links. A venv typically is a symlink to a known Python
     # binary. Only virtualenvs copy symlinks around.
@@ -381,8 +461,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/file_name.py

@@ -0,0 +1,157 @@
+import os
+
+from jedi._compatibility import FileNotFoundError, force_unicode, scandir
+from jedi.api import classes
+from jedi.api.strings import StringName, get_quote_ending
+from jedi.api.helpers import fuzzy_match, start_match
+from jedi.inference.helpers import get_str_or_none
+
+
+class PathName(StringName):
+    api_type = u'path'
+
+
+def complete_file_name(inference_state, module_context, start_leaf, 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))
+
+    addition = _get_string_additions(module_context, start_leaf)
+    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)
+    string = os.path.dirname(string)
+
+    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)
+        if to_be_added is None:
+            is_in_os_path_join = False
+        else:
+            string = to_be_added + string
+    base_path = os.path.join(inference_state.project._path, string)
+    try:
+        listed = sorted(scandir(base_path), key=lambda e: e.name)
+        # OSError: [Errno 36] File name too long: '...'
+    except (FileNotFoundError, OSError):
+        return
+    for entry in listed:
+        name = entry.name
+        if fuzzy:
+            match = fuzzy_match(name, must_start_with)
+        else:
+            match = start_match(name, must_start_with)
+        if match:
+            if is_in_os_path_join or not entry.is_dir():
+                name += get_quote_ending(start_leaf.value, code_lines, position)
+            else:
+                name += os.path.sep
+
+            yield classes.Completion(
+                inference_state,
+                PathName(inference_state, name[len(must_start_with) - like_name_length:]),
+                stack=None,
+                like_name_length=like_name_length,
+                is_fuzzy=fuzzy,
+            )
+
+
+def _get_string_additions(module_context, start_leaf):
+    def iterate_nodes():
+        node = addition.parent
+        was_addition = True
+        for child_node in reversed(node.children[:node.children.index(addition)]):
+            if was_addition:
+                was_addition = False
+                yield child_node
+                continue
+
+            if child_node != '+':
+                break
+            was_addition = True
+
+    addition = start_leaf.get_previous_leaf()
+    if addition != '+':
+        return ''
+    context = module_context.create_context(start_leaf)
+    return _add_strings(context, reversed(list(iterate_nodes())))
+
+
+def _add_strings(context, nodes, add_slash=False):
+    string = ''
+    first = True
+    for child_node in nodes:
+        values = context.infer_node(child_node)
+        if len(values) != 1:
+            return None
+        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)
+        first = False
+    return string
+
+
+def _add_os_path_join(module_context, start_leaf, bracket_start):
+    def check(maybe_bracket, nodes):
+        if maybe_bracket.start_pos != bracket_start:
+            return None
+
+        if not nodes:
+            return ''
+        context = module_context.create_context(nodes[0])
+        return _add_strings(context, nodes, add_slash=True) or ''
+
+    if start_leaf.type == 'error_leaf':
+        # Unfinished string literal, like `join('`
+        value_node = start_leaf.parent
+        index = value_node.children.index(start_leaf)
+        if index > 0:
+            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':
+                    arglist_nodes = error_node.children[-1].children
+                    index -= 1
+                else:
+                    arglist_nodes = []
+
+                return check(error_node.children[index + 1], arglist_nodes[::2])
+        return None
+
+    # Maybe an arglist or some weird error case. Therefore checked below.
+    searched_node_child = start_leaf
+    while searched_node_child.parent is not None \
+            and searched_node_child.parent.type not in ('arglist', 'trailer', 'error_node'):
+        searched_node_child = searched_node_child.parent
+
+    if searched_node_child.get_first_leaf() is not start_leaf:
+        return None
+    searched_node = searched_node_child.parent
+    if searched_node is None:
+        return None
+
+    index = searched_node.children.index(searched_node_child)
+    arglist_nodes = searched_node.children[:index]
+    if searched_node.type == 'arglist':
+        trailer = searched_node.parent
+        if trailer.type == 'error_node':
+            trailer_index = trailer.children.index(searched_node)
+            assert trailer_index >= 2
+            assert trailer.children[trailer_index - 1] == '('
+            return check(trailer.children[trailer_index - 1], arglist_nodes[::2])
+        elif trailer.type == 'trailer':
+            return check(trailer.children[0], arglist_nodes[::2])
+    elif searched_node.type == 'trailer':
+        return check(searched_node.children[0], [])
+    elif searched_node.type == 'error_node':
+        # Stuff like `join(""`
+        return check(arglist_nodes[-1], [])

jedi/api/helpers.py

@@ -4,24 +4,38 @@ Helpers for the API
 import re
 from collections import namedtuple
 from textwrap import dedent
+from functools import wraps
 
 from parso.python.parser import Parser
 from parso.python import tree
 
-from jedi._compatibility import u
-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.evaluate.base_context import ContextSet
-from jedi.cache import call_signature_time_cache
+from jedi._compatibility import u, Parameter
+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
 
 
 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 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))
+    return sorted(defs, key=lambda x: (x.module_path or '', x.line or 0, x.column or 0, x.name))
 
 
 def get_on_completion_name(module_node, lines, position):
@@ -54,8 +68,7 @@ class OnErrorLeaf(Exception):
         return self.args[0]
 
 
-def _get_code_for_stack(code_lines, module_node, position):
-    leaf = module_node.get_leaf_for_position(position, include_prefixes=True)
+def _get_code_for_stack(code_lines, leaf, position):
     # It might happen that we're on whitespace or on a comment. This means
     # that we would not get the right leaf.
     if leaf.start_pos >= position:
@@ -88,14 +101,14 @@ def _get_code_for_stack(code_lines, module_node, 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).
+                # start without value (part of a suite).
                 return u('')
 
         # This is basically getting the relevant lines.
         return _get_code(code_lines, user_stmt.get_start_pos_of_prefix(), position)
 
 
-def get_stack_at_position(grammar, code_lines, module_node, pos):
+def get_stack_at_position(grammar, code_lines, leaf, pos):
     """
     Returns the possible node names (e.g. import_from, xor_test or yield_stmt).
     """
@@ -106,17 +119,20 @@ def get_stack_at_position(grammar, code_lines, module_node, pos):
         # TODO This is for now not an official parso API that exists purely
         #   for Jedi.
         tokens = grammar._tokenize(code)
-        for token_ in tokens:
-            if token_.string == safeword:
+        for token in tokens:
+            if token.string == safeword:
                 raise EndMarkerReached()
-            elif token_.prefix.endswith(safeword):
+            elif token.prefix.endswith(safeword):
                 # This happens with comments.
                 raise EndMarkerReached()
+            elif token.string.endswith(safeword):
+                yield token  # Probably an f-string literal that was not finished.
+                raise EndMarkerReached()
             else:
-                yield token_
+                yield token
 
     # The code might be indedented, just remove it.
-    code = dedent(_get_code_for_stack(code_lines, module_node, pos))
+    code = dedent(_get_code_for_stack(code_lines, leaf, pos))
     # We use a word to tell Jedi when we have reached the start of the
     # completion.
     # Use Z as a prefix because it's not part of a number suffix.
@@ -127,83 +143,188 @@ def get_stack_at_position(grammar, code_lines, module_node, pos):
     try:
         p.parse(tokens=tokenize_without_endmarker(code))
     except EndMarkerReached:
-        return Stack(p.pgen_parser.stack)
-    raise SystemError("This really shouldn't happen. There's a bug in Jedi.")
+        return p.stack
+    raise SystemError(
+        "This really shouldn't happen. There's a bug in Jedi:\n%s"
+        % list(tokenize_without_endmarker(code))
+    )
 
 
-class Stack(list):
-    def get_node_names(self, grammar):
-        for dfa, state, (node_number, nodes) in self:
-            yield grammar.number2symbol[node_number]
-
-    def get_nodes(self):
-        for dfa, state, (node_number, nodes) in self:
-            for node in nodes:
-                yield node
-
-
-def get_possible_completion_types(pgen_grammar, stack):
-    def add_results(label_index):
-        try:
-            grammar_labels.append(inversed_tokens[label_index])
-        except KeyError:
-            try:
-                keywords.append(inversed_keywords[label_index])
-            except KeyError:
-                t, v = pgen_grammar.labels[label_index]
-                assert t >= 256
-                # See if it's a symbol and if we're in its first set
-                inversed_keywords
-                itsdfa = pgen_grammar.dfas[t]
-                itsstates, itsfirst = itsdfa
-                for first_label_index in itsfirst.keys():
-                    add_results(first_label_index)
-
-    inversed_keywords = dict((v, k) for k, v in pgen_grammar.keywords.items())
-    inversed_tokens = dict((v, k) for k, v in pgen_grammar.tokens.items())
-
-    keywords = []
-    grammar_labels = []
-
-    def scan_stack(index):
-        dfa, state, node = stack[index]
-        states, first = dfa
-        arcs = states[state]
-
-        for label_index, new_state in arcs:
-            if label_index == 0:
-                # An accepting state, check the stack below.
-                scan_stack(index - 1)
-            else:
-                add_results(label_index)
-
-    scan_stack(-1)
-
-    return keywords, grammar_labels
-
-
-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_VALUES
     if parent.type == 'atom':
-        return context.eval_node(leaf.parent)
+        # e.g. `(a + b)`
+        definitions = context.infer_node(leaf.parent)
     elif parent.type == 'trailer':
-        return evaluate_call_of_leaf(context, leaf)
+        # e.g. `a()`
+        definitions = infer_call_of_leaf(context, leaf)
     elif isinstance(leaf, tree.Literal):
-        return eval_atom(context, leaf)
+        # e.g. `"foo"` or `1.0`
+        return infer_atom(context, leaf)
     elif leaf.type in ('fstring_string', 'fstring_start', 'fstring_end'):
-        return get_string_context_set(evaluator)
-    return []
+        return get_string_value_set(inference_state)
+    return definitions
 
 
-CallSignatureDetails = namedtuple(
-    'CallSignatureDetails',
-    ['bracket_leaf', 'call_index', 'keyword_name_str']
-)
+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:
+                for new_name in new_names:
+                    yield new_name
+        else:
+            yield name
+
+
+class CallDetails(object):
+    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
+
+    @property
+    def index(self):
+        return _get_index_and_key(self._children, self._position)[0]
+
+    @property
+    def keyword_name_str(self):
+        return _get_index_and_key(self._children, self._position)[1]
+
+    def calculate_index(self, param_names):
+        positional_count = 0
+        used_names = set()
+        star_count = -1
+        args = list(_iter_arguments(self._children, self._position))
+        if not args:
+            if param_names:
+                return 0
+            else:
+                return None
+
+        is_kwarg = False
+        for i, (star_count, key_start, had_equal) in enumerate(args):
+            is_kwarg |= had_equal | (star_count == 2)
+            if star_count:
+                pass  # For now do nothing, we don't know what's in there here.
+            else:
+                if i + 1 != len(args):  # Not last
+                    if had_equal:
+                        used_names.add(key_start)
+                    else:
+                        positional_count += 1
+
+        for i, param_name in enumerate(param_names):
+            kind = param_name.get_kind()
+
+            if not is_kwarg:
+                if kind == Parameter.VAR_POSITIONAL:
+                    return i
+                if kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.POSITIONAL_ONLY):
+                    if i == positional_count:
+                        return i
+
+            if key_start is not None and not star_count == 1 or star_count == 2:
+                if param_name.string_name not in used_names \
+                        and (kind == Parameter.KEYWORD_ONLY
+                             or kind == Parameter.POSITIONAL_OR_KEYWORD
+                             and positional_count <= i):
+                    if star_count:
+                        return i
+                    if had_equal:
+                        if param_name.string_name == key_start:
+                            return i
+                    else:
+                        if param_name.string_name.startswith(key_start):
+                            return i
+
+                if kind == Parameter.VAR_KEYWORD:
+                    return i
+        return None
+
+
+def _iter_arguments(nodes, position):
+    def remove_after_pos(name):
+        if name.type != 'name':
+            return None
+        return name.value[:position[1] - name.start_pos[1]]
+
+    # 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 :(
+        return
+
+    previous_node_yielded = False
+    stars_seen = 0
+    for i, node in enumerate(nodes_before):
+        if node.type == 'argument':
+            previous_node_yielded = True
+            first = node.children[0]
+            second = node.children[1]
+            if second == '=':
+                if second.start_pos < position:
+                    yield 0, first.value, True
+                else:
+                    yield 0, remove_after_pos(first), False
+            elif first in ('*', '**'):
+                yield len(first.value), remove_after_pos(second), False
+            else:
+                # Must be a Comprehension
+                first_leaf = node.get_first_leaf()
+                if first_leaf.type == 'name' and first_leaf.start_pos >= position:
+                    yield 0, remove_after_pos(first_leaf), False
+                else:
+                    yield 0, None, False
+            stars_seen = 0
+        elif node.type in ('testlist', 'testlist_star_expr'):  # testlist is Python 2
+            for n in node.children[::2]:
+                if n.type == 'star_expr':
+                    stars_seen = 1
+                    n = n.children[1]
+                yield stars_seen, remove_after_pos(n), False
+                stars_seen = 0
+            # The count of children is even if there's a comma at the end.
+            previous_node_yielded = bool(len(node.children) % 2)
+        elif isinstance(node, tree.PythonLeaf) and node.value == ',':
+            if not previous_node_yielded:
+                yield stars_seen, '', False
+                stars_seen = 0
+            previous_node_yielded = False
+        elif isinstance(node, tree.PythonLeaf) and node.value in ('*', '**'):
+            stars_seen = len(node.value)
+        elif node == '=' and nodes_before[-1]:
+            previous_node_yielded = True
+            before = nodes_before[i - 1]
+            if before.type == 'name':
+                yield 0, before.value, True
+            else:
+                yield 0, None, False
+            # Just ignore the star that is probably a syntax error.
+            stars_seen = 0
+
+    if not previous_node_yielded:
+        if nodes_before[-1].type == 'name':
+            yield stars_seen, remove_after_pos(nodes_before[-1]), False
+        else:
+            yield stars_seen, '', False
 
 
 def _get_index_and_key(nodes, position):
@@ -212,22 +333,22 @@ def _get_index_and_key(nodes, position):
     """
     nodes_before = [c for c in nodes if c.start_pos < position]
     if nodes_before[-1].type == 'arglist':
-        nodes_before = [c for c in nodes_before[-1].children if c.start_pos < position]
+        return _get_index_and_key(nodes_before[-1].children, position)
 
     key_str = None
 
-    if nodes_before:
-        last = nodes_before[-1]
-        if last.type == 'argument' and last.children[1].end_pos <= position:
-            # Checked if the argument
-            key_str = last.children[0].value
-        elif last == '=':
-            key_str = nodes_before[-2].value
+    last = nodes_before[-1]
+    if last.type == 'argument' and last.children[1] == '=' \
+            and last.children[1].end_pos <= position:
+        # Checked if the argument
+        key_str = last.children[0].value
+    elif last == '=':
+        key_str = nodes_before[-2].value
 
     return nodes_before.count(','), key_str
 
 
-def _get_call_signature_details_from_error_node(node, 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:
@@ -238,53 +359,61 @@ def _get_call_signature_details_from_error_node(node, position):
             if name is None:
                 continue
             if name.type == 'name' or name.parent.type in ('trailer', 'atom'):
-                return CallSignatureDetails(
-                    element,
-                    *_get_index_and_key(children, position)
-                )
+                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 == ')':
-        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.
+            # Don't show signatures if there's stuff before it that just
+            # makes it feel strange to have a signature.
             return None
 
-        for n in node.children[::-1]:
-            if n.start_pos < position and n.type == 'error_node':
-                result = _get_call_signature_details_from_error_node(n, position)
-                if result is not None:
-                    return result
+        additional_children = []
+        for n in reversed(node.children):
+            if n.start_pos < position:
+                if n.type == 'error_node':
+                    result = _get_signature_details_from_error_node(
+                        n, additional_children, position
+                    )
+                    if result is not None:
+                        return result
 
+                    additional_children[0:0] = n.children
+                    continue
+                additional_children.insert(0, n)
+
+        # Find a valid trailer
         if node.type == 'trailer' and node.children[0] == '(':
-            leaf = node.get_previous_leaf()
-            if leaf is None:
-                return None
-            return CallSignatureDetails(
-                node.children[0], *_get_index_and_key(node.children, position))
+            # 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], 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
 
@@ -298,8 +427,31 @@ 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()
+        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 -= 1
+        if 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

jedi/api/interpreter.py

@@ -2,16 +2,15 @@
 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 Context
+from jedi.inference import compiled
+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)
     )
 
 
@@ -20,42 +19,23 @@ class NamespaceObject(object):
         self.__dict__ = dct
 
 
-class MixedModuleContext(Context):
-    type = 'mixed_module'
-
-    def __init__(self, evaluator, tree_module, namespaces, path, code_lines):
-        self.evaluator = evaluator
-        self._namespaces = namespaces
-
+class MixedModuleContext(ModuleContext):
+    def __init__(self, tree_module_value, namespaces):
+        super(MixedModuleContext, self).__init__(tree_module_value)
         self._namespace_objects = [NamespaceObject(n) for n in namespaces]
-        self._module_context = ModuleContext(
-            evaluator, tree_module,
-            path=path,
-            code_lines=code_lines
-        )
-        self.tree_node = tree_module
 
-    def get_node(self):
-        return self.tree_node
+    def _get_mixed_object(self, compiled_value):
+        return mixed.MixedObject(
+            compiled_value=compiled_value,
+            tree_value=self._value
+        )
 
     def get_filters(self, *args, **kwargs):
-        for filter in self._module_context.get_filters(*args, **kwargs):
+        for filter in self._value.as_context().get_filters(*args, **kwargs):
             yield filter
 
         for namespace_obj in self._namespace_objects:
-            compiled_object = _create(self.evaluator, namespace_obj)
-            mixed_object = mixed.MixedObject(
-                self.evaluator,
-                parent_context=self,
-                compiled_object=compiled_object,
-                tree_context=self._module_context
-            )
+            compiled_value = _create(self.inference_state, namespace_obj)
+            mixed_object = self._get_mixed_object(compiled_value)
             for filter in mixed_object.get_filters(*args, **kwargs):
                 yield filter
-
-    @property
-    def code_lines(self):
-        return self._module_context.code_lines
-
-    def __getattr__(self, name):
-        return getattr(self._module_context, name)

jedi/api/keywords.py

@@ -1,7 +1,7 @@
 import pydoc
 
-from jedi.evaluate.utils import ignored
-from jedi.evaluate.filters import AbstractNameDefinition
+from jedi.inference.utils import ignored
+from jedi.inference.names import AbstractArbitraryName
 
 try:
     from pydoc_data import topics as pydoc_topics
@@ -15,40 +15,11 @@ except ImportError:
         pydoc_topics = None
 
 
-def get_operator(evaluator, string, pos):
-    return Keyword(evaluator, string, pos)
-
-
-class KeywordName(AbstractNameDefinition):
+class KeywordName(AbstractArbitraryName):
     api_type = u'keyword'
 
-    def __init__(self, evaluator, name):
-        self.evaluator = evaluator
-        self.string_name = name
-        self.parent_context = evaluator.builtins_module
-
-    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]
-
-    def py__doc__(self, include_call_signature=False):
-        return imitate_pydoc(self.name.string_name)
-
-    def __repr__(self):
-        return '<%s: %s>' % (type(self).__name__, self.name)
+    def py__doc__(self):
+        return imitate_pydoc(self.string_name)
 
 
 def imitate_pydoc(string):
@@ -68,7 +39,9 @@ def imitate_pydoc(string):
         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)
 

jedi/api/project.py

@@ -1,13 +1,13 @@
 import os
 import json
 
-from jedi._compatibility import FileNotFoundError, NotADirectoryError
+from jedi._compatibility import FileNotFoundError, PermissionError, IsADirectoryError
 from jedi.api.environment import SameEnvironment, \
     get_cached_default_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.inference.sys_path import discover_buildout_paths
+from jedi.inference.cache import inference_state_as_method_param_cache
 from jedi.common.utils import traverse_parents
 
 _CONFIG_FOLDER = '.jedi'
@@ -67,7 +67,7 @@ class Project(object):
         """
         def py2_comp(path, environment=None, sys_path=None,
                      smart_sys_path=True, _django=False):
-            self._path = path
+            self._path = os.path.abspath(path)
             if isinstance(environment, SameEnvironment):
                 self._environment = environment
 
@@ -77,7 +77,8 @@ class Project(object):
 
         py2_comp(path, **kwargs)
 
-    def _get_base_sys_path(self, environment=None):
+    @inference_state_as_method_param_cache()
+    def _get_base_sys_path(self, inference_state, environment=None):
         if self._sys_path is not None:
             return self._sys_path
 
@@ -85,15 +86,16 @@ class Project(object):
         if environment is None:
             environment = self.get_environment()
 
-        sys_path = environment.get_sys_path()
+        sys_path = list(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):
+    @inference_state_as_method_param_cache()
+    def _get_sys_path(self, inference_state, environment=None,
+                      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.
@@ -101,24 +103,30 @@ class Project(object):
         suffixed = []
         prefixed = []
 
-        sys_path = list(self._get_base_sys_path(environment))
+        sys_path = list(self._get_base_sys_path(inference_state, environment))
         if self._smart_sys_path:
             prefixed.append(self._path)
 
-            if evaluator.script_path is not None:
-                suffixed += discover_buildout_paths(evaluator, evaluator.script_path)
+            if inference_state.script_path is not None:
+                suffixed += discover_buildout_paths(inference_state, inference_state.script_path)
 
-                traversed = []
-                for parent in traverse_parents(evaluator.script_path):
-                    traversed.append(parent)
-                    if parent == self._path:
-                        # Don't go futher than the project path.
-                        break
+                if add_parent_paths:
+                    # Collect directories in upward search by:
+                    #   1. Skipping directories with __init__.py
+                    #   2. Stopping immediately when above self._path
+                    traversed = []
+                    for parent_path in traverse_parents(inference_state.script_path):
+                        if not parent_path.startswith(self._path):
+                            break
+                        if not add_init_paths \
+                                and os.path.isfile(os.path.join(parent_path, "__init__.py")):
+                            continue
+                        traversed.append(parent_path)
 
-                # AFAIK some libraries have imports like `foo.foo.bar`, which
-                # leads to the conclusion to by default prefer longer paths
-                # rather than shorter ones by default.
-                suffixed += reversed(traversed)
+                    # AFAIK some libraries have imports like `foo.foo.bar`, which
+                    # leads to the conclusion to by default prefer longer paths
+                    # rather than shorter ones by default.
+                    suffixed += reversed(traversed)
 
         if self._django:
             prefixed.append(self._path)
@@ -156,7 +164,7 @@ def _is_django_path(directory):
     try:
         with open(os.path.join(directory, 'manage.py'), 'rb') as f:
             return b"DJANGO_SETTINGS_MODULE" in f.read()
-    except (FileNotFoundError, NotADirectoryError):
+    except (FileNotFoundError, IsADirectoryError, PermissionError):
         return False
 
     return False
@@ -172,7 +180,7 @@ def get_default_project(path=None):
     for dir in traverse_parents(check, include_current=True):
         try:
             return Project.load(dir)
-        except (FileNotFoundError, NotADirectoryError):
+        except (FileNotFoundError, IsADirectoryError, PermissionError):
             pass
 
         if first_no_init_file is None:

jedi/api/replstartup.py

@@ -1,6 +1,8 @@
 """
 To use Jedi completion in Python interpreter, add the following in your shell
-setup (e.g., ``.bashrc``)::
+setup (e.g., ``.bashrc``). This works only on Linux/Mac, because readline is
+not available on Windows. If you still want Jedi autocompletion in your REPL,
+just use IPython instead::
 
     export PYTHONSTARTUP="$(python -m jedi repl)"
 
@@ -19,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,110 @@
+"""
+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._compatibility import unicode
+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 = u'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_bracket_leaf = bracket_leaf.get_previous_leaf()
+        if before_bracket_leaf.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, (unicode, 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 _get_string_quote(string):
+    return _get_string_prefix_and_quote(string)[1]
+
+
+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_quote(string)
+    # 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

@@ -20,38 +20,6 @@ from parso.cache import parser_cache
 _time_caches = {}
 
 
-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):
     """ Jedi caches many things, that should be completed after each completion
     finishes.
@@ -75,7 +43,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.
@@ -126,6 +94,7 @@ def time_cache(seconds):
 
         wrapper.clear_cache = lambda: cache.clear()
         return wrapper
+
     return decorator
 
 

jedi/common/__init__.py

@@ -1 +1 @@
-from jedi.common.context import BaseContextSet, BaseContext
+from jedi.common.value import BaseValueSet, BaseValue

jedi/common/context.py

@@ -1,67 +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, *args):
-        self._set = set(args)
-
-    @classmethod
-    def from_iterable(cls, iterable):
-        return cls.from_set(set(iterable))
-
-    @classmethod
-    def from_set(cls, set_):
-        self = cls()
-        self._set = set_
-        return self
-
-    @classmethod
-    def from_sets(cls, sets):
-        """
-        Used to work with an iterable of set.
-        """
-        aggregated = set()
-        sets = list(sets)
-        for set_ in sets:
-            if isinstance(set_, BaseContextSet):
-                aggregated |= set_._set
-            else:
-                aggregated |= set_
-        return cls.from_set(aggregated)
-
-    def __or__(self, other):
-        return type(self).from_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)' % (self.__class__.__name__, ', '.join(str(s) for s in self._set))
-
-    def filter(self, filter_func):
-        return type(self).from_iterable(filter(filter_func, self._set))
-
-    def __getattr__(self, name):
-        def mapper(*args, **kwargs):
-            return type(self).from_sets(
-                getattr(context, name)(*args, **kwargs)
-                for context in self._set
-            )
-        return mapper

jedi/common/utils.py

@@ -1,4 +1,5 @@
 import os
+from contextlib import contextmanager
 
 
 def traverse_parents(path, include_current=False):
@@ -10,3 +11,16 @@ def traverse_parents(path, include_current=False):
         yield path
         previous = path
         path = os.path.dirname(path)
+
+
+@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)

jedi/common/value.py

@@ -0,0 +1,76 @@
+class BaseValue(object):
+    def __init__(self, inference_state, parent_context=None):
+        self.inference_state = inference_state
+        self.parent_context = parent_context
+
+    def get_root_context(self):
+        value = self
+        while True:
+            if value.parent_context is None:
+                return value
+            value = value.parent_context
+
+
+class BaseValueSet(object):
+    def __init__(self, iterable):
+        self._set = frozenset(iterable)
+        for value in iterable:
+            assert not isinstance(value, BaseValueSet)
+
+    @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_, BaseValueSet):
+                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(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)

jedi/debug.py

@@ -1,17 +1,20 @@
-from jedi._compatibility import encoding, is_py3, u
 import os
 import time
+from contextlib import contextmanager
+
+from jedi._compatibility import encoding, is_py3, u
+
+_inited = False
+
 
 def _lazy_colorama_init():
     """
-    Lazily init colorama if necessary, not to screw up stdout is debug not
-    enabled.
+    Lazily init colorama if necessary, not to screw up stdout if debugging is
+    not enabled.
 
     This version of the function does nothing.
     """
-    pass
 
-_inited=False
 
 try:
     if os.name == 'nt':
@@ -21,7 +24,8 @@ try:
         # Use colorama for nicer console output.
         from colorama import Fore, init
         from colorama import initialise
-        def _lazy_colorama_init():
+
+        def _lazy_colorama_init():  # noqa: F811
             """
             Lazily init colorama if necessary, not to screw up stdout is
             debug not enabled.
@@ -49,6 +53,7 @@ except ImportError:
         YELLOW = ''
         MAGENTA = ''
         RESET = ''
+        BLUE = ''
 
 NOTICE = object()
 WARNING = object()
@@ -73,15 +78,25 @@ def reset_time():
 def increase_indent(func):
     """Decorator for makin """
     def wrapper(*args, **kwargs):
-        global _debug_indent
-        _debug_indent += 1
-        try:
+        with increase_indent_cm():
             return func(*args, **kwargs)
-        finally:
-            _debug_indent -= 1
     return wrapper
 
 
+@contextmanager
+def increase_indent_cm(title=None):
+    global _debug_indent
+    if title:
+        dbg('Start: ' + title, color='MAGENTA')
+    _debug_indent += 1
+    try:
+        yield
+    finally:
+        _debug_indent -= 1
+        if title:
+            dbg('End: ' + title, color='MAGENTA')
+
+
 def dbg(message, *args, **kwargs):
     """ Looks at the stack, to see if a debug message should be printed. """
     # Python 2 compatibility, because it doesn't understand default args

jedi/evaluate/__init__.py

@@ -1,386 +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 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 compiled
-from jedi.evaluate import helpers
-from jedi.evaluate.filters 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
-
-
-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.6')
-        self.memoize_cache = {}  # for memoize decorators
-        self.module_cache = imports.ModuleCache()  # does the job of `sys.modules`.
-        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.reset_recursion_limitations()
-        self.allow_different_encoding = True
-
-    @property
-    @evaluator_function_cache()
-    def builtins_module(self):
-        return compiled.get_special_object(self, u'BUILTINS')
-
-    def reset_recursion_limitations(self):
-        self.recursion_detector = recursion.RecursionDetector()
-        self.execution_recursion_detector = recursion.ExecutionRecursionDetector(self)
-
-    def get_sys_path(self):
-        """Convenience function"""
-        return self.project._get_sys_path(self, environment=self.environment)
-
-    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 = ContextSet()
-                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
-            if type_ == 'classdef':
-                return [ClassContext(self, context, name.parent)]
-            elif type_ == 'funcdef':
-                return [FunctionContext(self, context, name.parent)]
-
-            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)
-
-        return helpers.evaluate_call_of_leaf(context, name)
-
-    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 ('funcdef', 'classdef'):
-                return [TreeNameDefinition(context, name)]
-            elif type_ in ('import_from', 'import_name'):
-                module_names = imports.infer_import(context, name, is_goto=True)
-                return module_names
-
-        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:
-                    try:
-                        get_param_names = context.get_param_names
-                    except AttributeError:
-                        pass
-                    else:
-                        for param_name in 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 unite(
-                value.py__getattribute__(name, name_context=context, is_goto=True)
-                for value in values
-            )
-        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 == '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 == 'comp_for':
-                            return n
-
-        def from_scope_node(scope_node, child_is_funcdef=None, 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, child_is_funcdef=is_funcdef)
-
-            if is_funcdef:
-                if isinstance(parent_context, AnonymousInstance):
-                    func = BoundMethod(
-                        self, parent_context, parent_context.class_context,
-                        parent_context.parent_context, scope_node
-                    )
-                else:
-                    func = FunctionContext(
-                        self,
-                        parent_context,
-                        scope_node
-                    )
-                if is_nested and not node_is_object:
-                    return func.get_function_execution()
-                return func
-            elif scope_node.type == 'classdef':
-                class_context = ClassContext(self, parent_context, scope_node)
-                if child_is_funcdef:
-                    # anonymous instance
-                    return AnonymousInstance(self, parent_context, class_context)
-                else:
-                    return class_context
-            elif scope_node.type == '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:
-            if node.parent.type in ('funcdef', 'classdef') and node.parent.name == node:
-                # When we're on class/function names/leafs that define the
-                # object itself and not its contents.
-                node = node.parent
-            scope_node = parent_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, **kwargs):
-        if self.allow_different_encoding:
-            if code is None:
-                with open(path, 'rb') as f:
-                    code = f.read()
-            code = python_bytes_to_unicode(code, errors='replace')
-
-        return self.grammar.parse(code=code, path=path, **kwargs), code
-
-    def parse(self, *args, **kwargs):
-        return self.parse_and_get_code(*args, **kwargs)[0]

jedi/evaluate/arguments.py

@@ -1,252 +0,0 @@
-from parso.python import tree
-
-from jedi._compatibility import zip_longest
-from jedi import debug
-from jedi.evaluate import analysis
-from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \
-    LazyTreeContext, get_merged_lazy_context
-from jedi.evaluate.filters import ParamName
-from jedi.evaluate.base_context import NO_CONTEXTS
-from jedi.evaluate.context import iterable
-from jedi.evaluate.param import get_params, ExecutedParam
-
-
-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.
-        return
-
-    for typ in types:
-        try:
-            f = typ.py__iter__
-        except AttributeError:
-            pass
-        else:
-            for lazy_context in f():
-                try_iter_content(lazy_context.infer(), depth + 1)
-
-
-class AbstractArguments(object):
-    context = None
-    argument_node = None
-    trailer = None
-
-    def eval_argument_clinic(self, parameters):
-        """Uses a list with argument clinic information (see PEP 436)."""
-        iterator = self.unpack()
-        for i, (name, optional, allow_kwargs) in enumerate(parameters):
-            key, argument = next(iterator, (None, None))
-            if key is not None:
-                raise NotImplementedError
-            if argument is None and not optional:
-                debug.warning('TypeError: %s expected at least %s arguments, got %s',
-                              name, len(parameters), i)
-                raise ValueError
-            values = NO_CONTEXTS if argument is None else argument.infer()
-
-            if not values 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.
-                debug.warning('argument_clinic "%s" not resolvable.', name)
-                raise ValueError
-            yield values
-
-    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)
-
-    def get_calling_nodes(self):
-        raise NotImplementedError
-
-    def unpack(self, funcdef=None):
-        raise NotImplementedError
-
-    def get_params(self, execution_context):
-        return get_params(execution_context, self)
-
-
-class AnonymousArguments(AbstractArguments):
-    def get_params(self, execution_context):
-        from jedi.evaluate.dynamic import search_params
-        return search_params(
-            execution_context.evaluator,
-            execution_context,
-            execution_context.tree_node
-        )
-
-
-class TreeArguments(AbstractArguments):
-    def __init__(self, evaluator, 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.trailer = trailer  # Can be None, e.g. in a class definition.
-
-    def _split(self):
-        if self.argument_node is None:
-            return
-
-        # Allow testlist here as well for Python2's class inheritance
-        # definitions.
-        if not (self.argument_node.type in ('arglist', 'testlist') or (
-                # in python 3.5 **arg is an argument, not arglist
-                (self.argument_node.type == 'argument') and
-                 self.argument_node.children[0] in ('*', '**'))):
-            yield 0, self.argument_node
-            return
-
-        iterator = iter(self.argument_node.children)
-        for child in iterator:
-            if child == ',':
-                continue
-            elif child in ('*', '**'):
-                yield len(child.value), next(iterator)
-            elif child.type == 'argument' and \
-                    child.children[0] in ('*', '**'):
-                assert len(child.children) == 2
-                yield len(child.children[0].value), child.children[1]
-            else:
-                yield 0, child
-
-    def unpack(self, funcdef=None):
-        named_args = []
-        for star_count, el in self._split():
-            if star_count == 1:
-                arrays = self.context.eval_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(
-                        [v for v in values if v is not None]
-                    )
-            elif star_count == 2:
-                arrays = self.context.eval_node(el)
-                for dct in arrays:
-                    for key, values in _star_star_dict(self.context, dct, el, funcdef):
-                        yield key, values
-            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]),))
-                    else:  # Generator comprehension.
-                        # Include the brackets with the parent.
-                        comp = iterable.GeneratorComprehension(
-                            self._evaluator, self.context, self.argument_node.parent)
-                        yield None, LazyKnownContext(comp)
-                else:
-                    yield None, LazyTreeContext(self.context, el)
-
-        # Reordering var_args 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
-
-    def as_tree_tuple_objects(self):
-        for star_count, argument in self._split():
-            if argument.type == 'argument':
-                argument, default = argument.children[::2]
-            else:
-                default = None
-            yield argument, default, star_count
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self.argument_node)
-
-    def get_calling_nodes(self):
-        from jedi.evaluate.dynamic import MergedExecutedParams
-        old_arguments_list = []
-        arguments = self
-
-        while arguments not in old_arguments_list:
-            if not isinstance(arguments, TreeArguments):
-                break
-
-            old_arguments_list.append(arguments)
-            for name, default, star_count in reversed(list(arguments.as_tree_tuple_objects())):
-                if not star_count or not isinstance(name, tree.Name):
-                    continue
-
-                names = self._evaluator.goto(arguments.context, name)
-                if len(names) != 1:
-                    break
-                if not isinstance(names[0], ParamName):
-                    break
-                param = names[0].get_param()
-                if isinstance(param, MergedExecutedParams):
-                    # 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
-                break
-
-        if arguments.argument_node is not None:
-            return [arguments.argument_node]
-        if arguments.trailer is not None:
-            return [arguments.trailer]
-        return []
-
-
-class ValuesArguments(AbstractArguments):
-    def __init__(self, values_list):
-        self._values_list = values_list
-
-    def unpack(self, funcdef=None):
-        for values in self._values_list:
-            yield None, LazyKnownContexts(values)
-
-    def get_calling_nodes(self):
-        return []
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self._values_list)
-
-
-def _iterate_star_args(context, array, input_node, funcdef=None):
-    try:
-        iter_ = array.py__iter__
-    except AttributeError:
-        if funcdef is not None:
-            # TODO this funcdef should not be needed.
-            m = "TypeError: %s() argument after * must be a sequence, not %s" \
-                % (funcdef.name.value, array)
-            analysis.add(context, 'type-error-star', input_node, message=m)
-    else:
-        for lazy_context in iter_():
-            yield lazy_context
-
-
-def _star_star_dict(context, array, input_node, funcdef):
-    from jedi.evaluate.context.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.
-        return {}
-    elif isinstance(array, iterable.Sequence) and array.array_type == 'dict':
-        return array.exact_key_items()
-    else:
-        if funcdef is not None:
-            m = "TypeError: %s argument after ** must be a mapping, not %s" \
-                % (funcdef.name.value, array)
-            analysis.add(context, 'type-error-star-star', input_node, message=m)
-        return {}

jedi/evaluate/base_context.py

@@ -1,272 +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 parso.python.tree import ExprStmt, CompFor
-
-from jedi import debug
-from jedi._compatibility import Python3Method, zip_longest, unicode
-from jedi.parser_utils import clean_scope_docstring, get_doc_with_call_signature
-from jedi.common import BaseContextSet, BaseContext
-
-
-class Context(BaseContext):
-    """
-    Should be defined, otherwise the API returns empty types.
-    """
-
-    predefined_names = {}
-    tree_node = None
-    """
-    To be defined by subclasses.
-    """
-
-    @property
-    def api_type(self):
-        # By default just lower name of the class. Can and should be
-        # overwritten.
-        return self.__class__.__name__.lower()
-
-    @debug.increase_indent
-    def execute(self, arguments):
-        """
-        In contrast to py__call__ this function is always available.
-
-        `hasattr(x, py__call__)` can also be checked to see if a context is
-        executable.
-        """
-        if self.evaluator.is_analysis:
-            arguments.eval_all()
-
-        debug.dbg('execute: %s %s', self, arguments)
-        from jedi.evaluate import stdlib
-        try:
-            # Some stdlib functions like super(), namedtuple(), etc. have been
-            # hard-coded in Jedi to support them.
-            return stdlib.execute(self.evaluator, self, arguments)
-        except stdlib.NotInStdLib:
-            pass
-
-        try:
-            func = self.py__call__
-        except AttributeError:
-            debug.warning("no execution possible %s", self)
-            return NO_CONTEXTS
-        else:
-            context_set = func(arguments)
-            debug.dbg('execute result: %s in %s', context_set, self)
-            return context_set
-
-        return self.evaluator.execute(self, arguments)
-
-    def execute_evaluated(self, *value_list):
-        """
-        Execute a function with already executed arguments.
-        """
-        from jedi.evaluate.arguments import ValuesArguments
-        arguments = ValuesArguments([ContextSet(value) for value in value_list])
-        return self.execute(arguments)
-
-    def iterate(self, contextualized_node=None, is_async=False):
-        debug.dbg('iterate %s', self)
-        try:
-            if is_async:
-                iter_method = self.py__aiter__
-            else:
-                iter_method = self.py__iter__
-        except AttributeError:
-            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([])
-        else:
-            return iter_method()
-
-    def get_item(self, index_contexts, contextualized_node):
-        from jedi.evaluate.compiled import CompiledObject
-        from jedi.evaluate.context.iterable import Slice, Sequence
-        result = ContextSet()
-
-        for index in index_contexts:
-            if isinstance(index, Slice):
-                index = index.obj
-            if isinstance(index, CompiledObject):
-                try:
-                    index = index.get_safe_value()
-                except ValueError:
-                    pass
-
-            if type(index) not in (float, int, str, unicode, slice, bytes):
-                # If the index is not clearly defined, we have to get all the
-                # possiblities.
-                if isinstance(self, Sequence) and self.array_type == 'dict':
-                    result |= self.dict_values()
-                else:
-                    result |= iterate_contexts(ContextSet(self))
-                continue
-
-            # The actual getitem call.
-            try:
-                getitem = self.py__getitem__
-            except AttributeError:
-                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
-                )
-            else:
-                try:
-                    result |= getitem(index)
-                except IndexError:
-                    result |= iterate_contexts(ContextSet(self))
-                except KeyError:
-                    # Must be a dict. Lists don't raise KeyErrors.
-                    result |= self.dict_values()
-        return result
-
-    def eval_node(self, node):
-        return self.evaluator.eval_element(self, node)
-
-    @Python3Method
-    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 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 is_class(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, include_call_signature=False):
-        try:
-            self.tree_node.get_doc_node
-        except AttributeError:
-            return ''
-        else:
-            if include_call_signature:
-                return get_doc_with_call_signature(self.tree_node)
-            else:
-                return clean_scope_docstring(self.tree_node)
-        return None
-
-
-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 TreeContext(Context):
-    def __init__(self, evaluator, parent_context=None):
-        super(TreeContext, self).__init__(evaluator, parent_context)
-        self.predefined_names = {}
-
-    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)
-
-
-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)]``.
-        """
-        indexes = []
-        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:
-                        indexes.insert(0, (int(i / 2), node))
-                        break
-                else:
-                    raise LookupError("Couldn't find the assignment.")
-            elif isinstance(node, (ExprStmt, CompFor)):
-                break
-
-            compare = node
-            node = node.parent
-        return indexes
-
-
-class ContextSet(BaseContextSet):
-    def py__class__(self):
-        return ContextSet.from_iterable(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]
-            )
-
-
-NO_CONTEXTS = ContextSet()
-
-
-def iterator_to_context_set(func):
-    def wrapper(*args, **kwargs):
-        return ContextSet.from_iterable(func(*args, **kwargs))
-
-    return wrapper

jedi/evaluate/cache.py

@@ -1,77 +0,0 @@
-"""
-- the popular ``_memoize_default`` works like a typical memoize and returns the
-  default otherwise.
-- ``CachedMetaClass`` uses ``_memoize_default`` to do the same with classes.
-"""
-
-_NO_DEFAULT = object()
-
-
-def _memoize_default(default=_NO_DEFAULT, evaluator_is_first_arg=False, second_arg_is_evaluator=False):
-    """ This is a typical memoization decorator, BUT there is one difference:
-    To prevent recursion it sets defaults.
-
-    Preventing recursion is in this case the much bigger use than speed. I
-    don't think, that there is a big speed difference, but there are many cases
-    where recursion could happen (think about a = b; b = a).
-    """
-    def func(function):
-        def wrapper(obj, *args, **kwargs):
-            # TODO These checks are kind of ugly and slow.
-            if evaluator_is_first_arg:
-                cache = obj.memoize_cache
-            elif second_arg_is_evaluator:
-                cache = args[0].memoize_cache  # needed for meta classes
-            else:
-                cache = obj.evaluator.memoize_cache
-
-            try:
-                memo = cache[function]
-            except KeyError:
-                memo = {}
-                cache[function] = memo
-
-            key = (obj, args, frozenset(kwargs.items()))
-            if key in memo:
-                return memo[key]
-            else:
-                if default is not _NO_DEFAULT:
-                    memo[key] = default
-                rv = function(obj, *args, **kwargs)
-                memo[key] = rv
-                return rv
-        return wrapper
-
-    return func
-
-
-def evaluator_function_cache(default=_NO_DEFAULT):
-    def decorator(func):
-        return _memoize_default(default=default, evaluator_is_first_arg=True)(func)
-
-    return decorator
-
-
-def evaluator_method_cache(default=_NO_DEFAULT):
-    def decorator(func):
-        return _memoize_default(default=default)(func)
-
-    return decorator
-
-
-def evaluator_as_method_param_cache():
-    def decorator(call):
-        return _memoize_default(second_arg_is_evaluator=True)(call)
-
-    return decorator
-
-
-class CachedMetaClass(type):
-    """
-    This is basically almost the same than the decorator above, it just caches
-    class initializations. Either you do it this way or with decorators, but
-    with decorators you lose class access (isinstance, etc).
-    """
-    @evaluator_as_method_param_cache()
-    def __call__(self, *args, **kwargs):
-        return super(CachedMetaClass, self).__call__(*args, **kwargs)

jedi/evaluate/compiled/__init__.py

@@ -1,39 +0,0 @@
-from jedi._compatibility import unicode
-from jedi.evaluate.compiled.context import CompiledObject, CompiledName, \
-    CompiledObjectFilter, CompiledContextName, create_from_access_path, \
-    create_from_name
-
-
-def builtin_from_name(evaluator, string):
-    builtins = evaluator.builtins_module
-    return create_from_name(evaluator, builtins, string)
-
-
-def create_simple_object(evaluator, obj):
-    """
-    Only allows creations of objects that are easily picklable across Python
-    versions.
-    """
-    assert isinstance(obj, (int, float, str, bytes, unicode, slice, complex))
-    return create_from_access_path(
-        evaluator,
-        evaluator.compiled_subprocess.create_simple_object(obj)
-    )
-
-
-def get_special_object(evaluator, identifier):
-    return create_from_access_path(
-        evaluator,
-        evaluator.compiled_subprocess.get_special_object(identifier)
-    )
-
-
-def get_string_context_set(evaluator):
-    return builtin_from_name(evaluator, u'str').execute_evaluated()
-
-
-def load_module(evaluator, **kwargs):
-    access_path = evaluator.compiled_subprocess.load_module(**kwargs)
-    if access_path is None:
-        return None
-    return create_from_access_path(evaluator, access_path)

jedi/evaluate/compiled/context.py

@@ -1,474 +0,0 @@
-"""
-Imitate the parser representation.
-"""
-import re
-from functools import partial
-
-from jedi import debug
-from jedi._compatibility import force_unicode, Parameter
-from jedi.cache import underscore_memoization, memoize_method
-from jedi.evaluate.filters import AbstractFilter, AbstractNameDefinition, \
-    ContextNameMixin
-from jedi.evaluate.base_context import Context, ContextSet
-from jedi.evaluate.lazy_context import LazyKnownContext
-from jedi.evaluate.compiled.access import _sentinel
-from jedi.evaluate.cache import evaluator_function_cache
-from . import fake
-
-
-class CheckAttribute(object):
-    """Raises an AttributeError if the attribute X isn't available."""
-    def __init__(self, func):
-        self.func = func
-        # Remove the py in front of e.g. py__call__.
-        self.check_name = force_unicode(func.__name__[2:])
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-
-        # This might raise an AttributeError. That's wanted.
-        if self.check_name == '__iter__':
-            # 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 instance.access_handle.has_iter():
-                raise AttributeError
-        else:
-            instance.access_handle.getattr(self.check_name)
-        return partial(self.func, instance)
-
-
-class CompiledObject(Context):
-    def __init__(self, evaluator, access_handle, parent_context=None, faked_class=None):
-        super(CompiledObject, self).__init__(evaluator, parent_context)
-        self.access_handle = access_handle
-        # This attribute will not be set for most classes, except for fakes.
-        self.tree_node = faked_class
-
-    @CheckAttribute
-    def py__call__(self, params):
-        if self.tree_node is not None and self.tree_node.type == 'funcdef':
-            from jedi.evaluate.context.function import FunctionContext
-            return FunctionContext(
-                self.evaluator,
-                parent_context=self.parent_context,
-                funcdef=self.tree_node
-            ).py__call__(params)
-        if self.access_handle.is_class():
-            from jedi.evaluate.context import CompiledInstance
-            return ContextSet(CompiledInstance(self.evaluator, self.parent_context, self, params))
-        else:
-            return ContextSet.from_iterable(self._execute_function(params))
-
-    @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__()
-        )
-
-    def py__bool__(self):
-        return self.access_handle.py__bool__()
-
-    def py__file__(self):
-        return self.access_handle.py__file__()
-
-    def is_class(self):
-        return self.access_handle.is_class()
-
-    def py__doc__(self, include_call_signature=False):
-        return self.access_handle.py__doc__()
-
-    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()
-            tokens = params_str.split(',')
-            if self.access_handle.ismethoddescriptor():
-                tokens.insert(0, 'self')
-            for p in tokens:
-                parts = p.strip().split('=')
-                yield UnresolvableParamName(self, parts[0])
-        else:
-            for signature_param in signature_params:
-                yield SignatureParamName(self, signature_param)
-
-    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
-    def py__getitem__(self, index):
-        access = self.access_handle.py__getitem__(index)
-        if access is None:
-            return ContextSet()
-
-        return ContextSet(create_from_access_path(self.evaluator, access))
-
-    @CheckAttribute
-    def py__iter__(self):
-        for access in self.access_handle.py__iter__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(name)
-            except AttributeError:
-                continue
-            else:
-                bltn_obj = builtin_from_name(self.evaluator, name)
-                for result in bltn_obj.execute(params):
-                    yield result
-        for type_ in docstrings.infer_return_types(self):
-            yield type_
-
-    def dict_values(self):
-        return ContextSet.from_iterable(
-            create_from_access_path(self.evaluator, access)
-            for access in self.access_handle.dict_values()
-        )
-
-    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 is_super_class(self, exception):
-        return self.access_handle.is_super_class(exception)
-
-
-class CompiledName(AbstractNameDefinition):
-    def __init__(self, evaluator, parent_context, name):
-        self._evaluator = evaluator
-        self.parent_context = parent_context
-        self.string_name = 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):
-        return next(iter(self.infer())).api_type
-
-    @underscore_memoization
-    def infer(self):
-        return ContextSet(create_from_name(
-            self._evaluator, self.parent_context, self.string_name
-        ))
-
-
-class SignatureParamName(AbstractNameDefinition):
-    api_type = u'param'
-
-    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 get_kind(self):
-        return getattr(Parameter, self._signature_param.kind_name)
-
-    def is_keyword_param(self):
-        return self._signature_param
-
-    def infer(self):
-        p = self._signature_param
-        evaluator = self.parent_context.evaluator
-        contexts = ContextSet()
-        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(AbstractNameDefinition):
-    api_type = u'param'
-
-    def __init__(self, compiled_obj, name):
-        self.parent_context = compiled_obj.parent_context
-        self.string_name = name
-
-    def get_kind(self):
-        return Parameter.POSITIONAL_ONLY
-
-    def infer(self):
-        return ContextSet()
-
-
-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 ContextSet()
-
-
-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 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)
-
-
-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):
-    faked = None
-    try:
-        faked = fake.get_faked_with_parent_context(compiled_object, name)
-    except fake.FakeDoesNotExist:
-        pass
-
-    access = compiled_object.access_handle.getattr(name, default=None)
-    return create_cached_compiled_object(
-        evaluator, access, parent_context=compiled_object, faked=faked
-    )
-
-
-def _normalize_create_args(func):
-    """The cache doesn't care about keyword vs. normal args."""
-    def wrapper(evaluator, obj, parent_context=None, faked=None):
-        return func(evaluator, obj, parent_context, faked)
-    return wrapper
-
-
-def create_from_access_path(evaluator, access_path):
-    parent_context = None
-    for name, access in access_path.accesses:
-        try:
-            if parent_context is None:
-                faked = fake.get_faked_module(evaluator, access_path.accesses[0][0])
-            else:
-                faked = fake.get_faked_with_parent_context(parent_context, name)
-        except fake.FakeDoesNotExist:
-            faked = None
-
-        parent_context = create_cached_compiled_object(evaluator, access, parent_context, faked)
-    return parent_context
-
-
-@_normalize_create_args
-@evaluator_function_cache()
-def create_cached_compiled_object(evaluator, access_handle, parent_context, faked):
-    return CompiledObject(evaluator, access_handle, parent_context, faked)

jedi/evaluate/compiled/fake.py

@@ -1,82 +0,0 @@
-"""
-Loads functions that are mixed in to the standard library. E.g. builtins are
-written in C (binaries), but my autocompletion only understands Python code. By
-mixing in Python code, the autocompletion should work much better for builtins.
-"""
-
-import os
-from itertools import chain
-
-from jedi._compatibility import unicode
-
-fake_modules = {}
-
-
-def _get_path_dict():
-    path = os.path.dirname(os.path.abspath(__file__))
-    base_path = os.path.join(path, 'fake')
-    dct = {}
-    for file_name in os.listdir(base_path):
-        if file_name.endswith('.pym'):
-            dct[file_name[:-4]] = os.path.join(base_path, file_name)
-    return dct
-
-
-_path_dict = _get_path_dict()
-
-
-class FakeDoesNotExist(Exception):
-    pass
-
-
-def _load_faked_module(evaluator, module_name):
-    try:
-        return fake_modules[module_name]
-    except KeyError:
-        pass
-
-    check_module_name = module_name
-    if module_name == '__builtin__' and evaluator.environment.version_info.major == 2:
-        check_module_name = 'builtins'
-
-    try:
-        path = _path_dict[check_module_name]
-    except KeyError:
-        fake_modules[module_name] = None
-        return
-
-    with open(path) as f:
-        source = f.read()
-
-    fake_modules[module_name] = m = evaluator.latest_grammar.parse(unicode(source))
-
-    if check_module_name != module_name:
-        # There are two implementations of `open` for either python 2/3.
-        # -> Rename the python2 version (`look at fake/builtins.pym`).
-        open_func = _search_scope(m, 'open')
-        open_func.children[1].value = 'open_python3'
-        open_func = _search_scope(m, 'open_python2')
-        open_func.children[1].value = 'open'
-    return m
-
-
-def _search_scope(scope, obj_name):
-    for s in chain(scope.iter_classdefs(), scope.iter_funcdefs()):
-        if s.name.value == obj_name:
-            return s
-
-
-def get_faked_with_parent_context(parent_context, name):
-    if parent_context.tree_node is not None:
-        # Try to search in already clearly defined stuff.
-        found = _search_scope(parent_context.tree_node, name)
-        if found is not None:
-            return found
-    raise FakeDoesNotExist
-
-
-def get_faked_module(evaluator, string_name):
-    module = _load_faked_module(evaluator, string_name)
-    if module is None:
-        raise FakeDoesNotExist
-    return module

jedi/evaluate/compiled/fake/_functools.pym

@@ -1,9 +0,0 @@
-class partial():
-    def __init__(self, func, *args, **keywords):
-        self.__func = func
-        self.__args = args
-        self.__keywords = keywords
-
-    def __call__(self, *args, **kwargs):
-        # TODO should be **dict(self.__keywords, **kwargs)
-        return self.__func(*(self.__args + args), **self.__keywords)

jedi/evaluate/compiled/fake/_sqlite3.pym

@@ -1,26 +0,0 @@
-def connect(database, timeout=None, isolation_level=None, detect_types=None, factory=None):
-    return Connection()
-
-
-class Connection():
-    def cursor(self):
-        return Cursor()
-
-
-class Cursor():
-    def cursor(self):
-        return Cursor()
-
-    def fetchone(self):
-        return Row()
-
-    def fetchmany(self, size=cursor.arraysize):
-        return [self.fetchone()]
-
-    def fetchall(self):
-        return [self.fetchone()]
-
-
-class Row():
-    def keys(self):
-        return ['']

jedi/evaluate/compiled/fake/_sre.pym

@@ -1,99 +0,0 @@
-def compile():
-    class SRE_Match():
-        endpos = int()
-        lastgroup = int()
-        lastindex = int()
-        pos = int()
-        string = str()
-        regs = ((int(), int()),)
-
-        def __init__(self, pattern):
-            self.re = pattern
-
-        def start(self):
-            return int()
-
-        def end(self):
-            return int()
-
-        def span(self):
-            return int(), int()
-
-        def expand(self):
-            return str()
-
-        def group(self, nr):
-            return str()
-
-        def groupdict(self):
-            return {str(): str()}
-
-        def groups(self):
-            return (str(),)
-
-    class SRE_Pattern():
-        flags = int()
-        groupindex = {}
-        groups = int()
-        pattern = str()
-
-        def findall(self, string, pos=None, endpos=None):
-            """
-            findall(string[, pos[, endpos]]) --> list.
-            Return a list of all non-overlapping matches of pattern in string.
-            """
-            return [str()]
-
-        def finditer(self, string, pos=None, endpos=None):
-            """
-            finditer(string[, pos[, endpos]]) --> iterator.
-            Return an iterator over all non-overlapping matches for the
-            RE pattern in string. For each match, the iterator returns a
-            match object.
-            """
-            yield SRE_Match(self)
-
-        def match(self, string, pos=None, endpos=None):
-            """
-            match(string[, pos[, endpos]]) --> match object or None.
-            Matches zero or more characters at the beginning of the string
-            pattern
-            """
-            return SRE_Match(self)
-
-        def scanner(self, string, pos=None, endpos=None):
-            pass
-
-        def search(self, string, pos=None, endpos=None):
-            """
-            search(string[, pos[, endpos]]) --> match object or None.
-            Scan through string looking for a match, and return a corresponding
-            MatchObject instance. Return None if no position in the string matches.
-            """
-            return SRE_Match(self)
-
-        def split(self, string, maxsplit=0]):
-            """
-            split(string[, maxsplit = 0])  --> list.
-            Split string by the occurrences of pattern.
-            """
-            return [str()]
-
-        def sub(self, repl, string, count=0):
-            """
-            sub(repl, string[, count = 0]) --> newstring
-            Return the string obtained by replacing the leftmost non-overlapping
-            occurrences of pattern in string by the replacement repl.
-            """
-            return str()
-
-        def subn(self, repl, string, count=0):
-            """
-            subn(repl, string[, count = 0]) --> (newstring, number of subs)
-            Return the tuple (new_string, number_of_subs_made) found by replacing
-            the leftmost non-overlapping occurrences of pattern with the
-            replacement repl.
-            """
-            return (str(), int())
-
-    return SRE_Pattern()

jedi/evaluate/compiled/fake/_weakref.pym

@@ -1,9 +0,0 @@
-def proxy(object, callback=None):
-    return object
-
-class ref():
-    def __init__(self, object, callback=None):
-        self.__object = object
-
-    def __call__(self):
-        return self.__object

jedi/evaluate/compiled/fake/builtins.pym

@@ -1,277 +0,0 @@
-"""
-Pure Python implementation of some builtins.
-This code is not going to be executed anywhere.
-These implementations are not always correct, but should work as good as
-possible for the auto completion.
-"""
-
-
-def next(iterator, default=None):
-    if random.choice([0, 1]):
-        if hasattr("next"):
-            return iterator.next()
-        else:
-            return iterator.__next__()
-    else:
-        if default is not None:
-            return default
-
-
-def iter(collection, sentinel=None):
-    if sentinel:
-        yield collection()
-    else:
-        for c in collection:
-            yield c
-
-
-def range(start, stop=None, step=1):
-    return [0]
-
-
-class file():
-    def __iter__(self):
-        yield ''
-
-    def next(self):
-        return ''
-
-    def readlines(self):
-        return ['']
-
-    def __enter__(self):
-        return self
-
-
-class xrange():
-    # Attention: this function doesn't exist in Py3k (there it is range).
-    def __iter__(self):
-        yield 1
-
-    def count(self):
-        return 1
-
-    def index(self):
-        return 1
-
-
-def open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True):
-    import io
-    return io.TextIOWrapper(file, mode, buffering, encoding, errors, newline, closefd)
-
-
-def open_python2(name, mode=None, buffering=None):
-    return file(name, mode, buffering)
-
-
-#--------------------------------------------------------
-# descriptors
-#--------------------------------------------------------
-class property():
-    def __init__(self, fget, fset=None, fdel=None, doc=None):
-        self.fget = fget
-        self.fset = fset
-        self.fdel = fdel
-        self.__doc__ = doc
-
-    def __get__(self, obj, cls):
-        return self.fget(obj)
-
-    def __set__(self, obj, value):
-        self.fset(obj, value)
-
-    def __delete__(self, obj):
-        self.fdel(obj)
-
-    def setter(self, func):
-        self.fset = func
-        return self
-
-    def getter(self, func):
-        self.fget = func
-        return self
-
-    def deleter(self, func):
-        self.fdel = func
-        return self
-
-
-class staticmethod():
-    def __init__(self, func):
-        self.__func = func
-
-    def __get__(self, obj, cls):
-        return self.__func
-
-
-class classmethod():
-    def __init__(self, func):
-        self.__func = func
-
-    def __get__(self, obj, cls):
-        def _method(*args, **kwargs):
-            return self.__func(cls, *args, **kwargs)
-        return _method
-
-
-#--------------------------------------------------------
-# array stuff
-#--------------------------------------------------------
-class list():
-    def __init__(self, iterable=[]):
-        self.__iterable = []
-        for i in iterable:
-            self.__iterable += [i]
-
-    def __iter__(self):
-        for i in self.__iterable:
-            yield i
-
-    def __getitem__(self, y):
-        return self.__iterable[y]
-
-    def pop(self):
-        return self.__iterable[int()]
-
-
-class tuple():
-    def __init__(self, iterable=[]):
-        self.__iterable = []
-        for i in iterable:
-            self.__iterable += [i]
-
-    def __iter__(self):
-        for i in self.__iterable:
-            yield i
-
-    def __getitem__(self, y):
-        return self.__iterable[y]
-
-    def index(self):
-        return 1
-
-    def count(self):
-        return 1
-
-
-class set():
-    def __init__(self, iterable=[]):
-        self.__iterable = iterable
-
-    def __iter__(self):
-        for i in self.__iterable:
-            yield i
-
-    def pop(self):
-        return list(self.__iterable)[-1]
-
-    def copy(self):
-        return self
-
-    def difference(self, other):
-        return self - other
-
-    def intersection(self, other):
-        return self & other
-
-    def symmetric_difference(self, other):
-        return self ^ other
-
-    def union(self, other):
-        return self | other
-
-
-class frozenset():
-    def __init__(self, iterable=[]):
-        self.__iterable = iterable
-
-    def __iter__(self):
-        for i in self.__iterable:
-            yield i
-
-    def copy(self):
-        return self
-
-
-class dict():
-    def __init__(self, **elements):
-        self.__elements = elements
-
-    def clear(self):
-        # has a strange docstr
-        pass
-
-    def __getitem__(self, obj):
-        return self.__elements[obj]
-
-    def get(self, k, d=None):
-        # TODO implement
-        try:
-            return self.__elements[k]
-            pass
-        except KeyError:
-            return d
-
-    def values(self):
-        return self.__elements.values()
-
-    def setdefault(self, k, d):
-        # TODO maybe also return the content
-        return d
-
-
-class enumerate():
-    def __init__(self, sequence, start=0):
-        self.__sequence = sequence
-
-    def __iter__(self):
-        for i in self.__sequence:
-            yield 1, i
-
-    def __next__(self):
-        return next(self.__iter__())
-
-    def next(self):
-        return next(self.__iter__())
-
-
-class reversed():
-    def __init__(self, sequence):
-        self.__sequence = sequence
-
-    def __iter__(self):
-        for i in self.__sequence:
-            yield i
-
-    def __next__(self):
-        return next(self.__iter__())
-
-    def next(self):
-        return next(self.__iter__())
-
-
-def sorted(iterable, cmp=None, key=None, reverse=False):
-    return iterable
-
-
-#--------------------------------------------------------
-# basic types
-#--------------------------------------------------------
-class int():
-    def __init__(self, x, base=None):
-        pass
-
-
-class str():
-    def __init__(self, obj):
-        pass
-
-    def strip(self):
-        return str()
-
-    def split(self):
-        return [str()]
-
-class type():
-    def mro():
-        return [object]

jedi/evaluate/compiled/fake/datetime.pym

@@ -1,4 +0,0 @@
-class datetime():
-    @staticmethod
-    def now():
-        return datetime()

jedi/evaluate/compiled/fake/io.pym

@@ -1,12 +0,0 @@
-class TextIOWrapper():
-    def __next__(self):
-        return str()
-
-    def __iter__(self):
-        yield str()
-
-    def readlines(self):
-        return ['']
-
-    def __enter__(self):
-        return self

jedi/evaluate/compiled/fake/operator.pym

@@ -1,33 +0,0 @@
-# Just copied this code from Python 3.6.
-
-class itemgetter:
-    """
-    Return a callable object that fetches the given item(s) from its operand.
-    After f = itemgetter(2), the call f(r) returns r[2].
-    After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])
-    """
-    __slots__ = ('_items', '_call')
-
-    def __init__(self, item, *items):
-        if not items:
-            self._items = (item,)
-            def func(obj):
-                return obj[item]
-            self._call = func
-        else:
-            self._items = items = (item,) + items
-            def func(obj):
-                return tuple(obj[i] for i in items)
-            self._call = func
-
-    def __call__(self, obj):
-        return self._call(obj)
-
-    def __repr__(self):
-        return '%s.%s(%s)' % (self.__class__.__module__,
-                              self.__class__.__name__,
-                              ', '.join(map(repr, self._items)))
-
-    def __reduce__(self):
-        return self.__class__, self._items
-

jedi/evaluate/compiled/fake/posix.pym

@@ -1,5 +0,0 @@
-def getcwd():
-    return ''
-
-def getcwdu():
-    return ''

jedi/evaluate/compiled/mixed.py

@@ -1,239 +0,0 @@
-"""
-Used only for REPL Completion.
-"""
-
-import inspect
-import os
-
-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.evaluate import imports
-from jedi.evaluate.base_context import Context, ContextSet
-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
-from jedi.evaluate.compiled.context import create_cached_compiled_object
-
-
-class MixedObject(object):
-    """
-    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, evaluator, parent_context, compiled_object, tree_context):
-        self.evaluator = evaluator
-        self.parent_context = parent_context
-        self.compiled_object = compiled_object
-        self._context = tree_context
-        self.access_handle = compiled_object.access_handle
-
-    # We have to overwrite everything that has to do with trailers, name
-    # lookups and filters to make it possible to route name lookups towards
-    # compiled objects and the rest towards tree node contexts.
-    def py__getattribute__(*args, **kwargs):
-        return Context.py__getattribute__(*args, **kwargs)
-
-    def get_filters(self, *args, **kwargs):
-        yield MixedObjectFilter(self.evaluator, self)
-
-    def __repr__(self):
-        return '<%s: %s>' % (type(self).__name__, self.access_handle.get_repr())
-
-    def __getattr__(self, name):
-        return getattr(self._context, name)
-
-
-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):
-        access_handle = self.parent_context.access_handle
-        # TODO use logic from compiled.CompiledObjectFilter
-        access_handle = access_handle.getattr(self.string_name, default=None)
-        return ContextSet(
-            _create(self._evaluator, access_handle, parent_context=self.parent_context)
-        )
-
-    @property
-    def api_type(self):
-        return next(iter(self.infer())).api_type
-
-
-class MixedObjectFilter(compiled.CompiledObjectFilter):
-    name_class = MixedName
-
-    def __init__(self, evaluator, mixed_object, is_instance=False):
-        super(MixedObjectFilter, self).__init__(
-            evaluator, mixed_object, is_instance)
-        self._mixed_object = mixed_object
-
-    #def _create(self, name):
-        #return MixedName(self._evaluator, self._compiled_object, name)
-
-
-@evaluator_function_cache()
-def _load_module(evaluator, path):
-    module_node = evaluator.grammar.parse(
-        path=path,
-        cache=True,
-        diff_cache=True,
-        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 (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, access_handle):
-    # 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
-    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
-
-    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, path, 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)
-    try:
-        names = module_node.get_used_names()[name_str]
-    except KeyError:
-        return None
-    names = [n for n in names if n.is_definition()]
-
-    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.
-    return module_node, names[-1].parent, path, 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.compiled_object)
-
-    result = _find_syntax_node_name(evaluator, access_handle)
-    if result is None:
-        return compiled_object
-
-    module_node, tree_node, path, code_lines = result
-
-    if parent_context.tree_node.get_root_node() == module_node:
-        module_context = parent_context.get_root_context()
-    else:
-        module_context = ModuleContext(
-            evaluator, module_node,
-            path=path,
-            code_lines=code_lines,
-        )
-        # TODO this __name__ is probably wrong.
-        name = compiled_object.get_root_context().py__name__()
-        if name is not None:
-            imports.add_module_to_cache(evaluator, name, module_context)
-
-    tree_context = 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_context, = tree_context.execute_evaluated()
-
-    return MixedObject(
-        evaluator,
-        parent_context,
-        compiled_object,
-        tree_context=tree_context
-    )

jedi/evaluate/compiled/subprocess/functions.py

@@ -1,113 +0,0 @@
-import sys
-import os
-
-from jedi._compatibility import find_module, cast_path, force_unicode, \
-    iter_modules, all_suffixes, print_to_stderr
-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 get_special_object(evaluator, identifier):
-    return access.get_special_object(evaluator, identifier)
-
-
-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):
-    if sys_path is not None:
-        sys.path, temp = sys_path, sys.path
-    try:
-        module_file, module_path, is_pkg = find_module(full_name=full_name, **kwargs)
-    except ImportError:
-        return None, None, None
-    finally:
-        if sys_path is not None:
-            sys.path = temp
-
-    code = None
-    if is_pkg:
-        # In this case, we don't have a file yet. Search for the
-        # __init__ file.
-        if module_path.endswith(('.zip', '.egg')):
-            code = module_file.loader.get_source(full_name)
-        else:
-            module_path = _get_init_path(module_path)
-    elif module_file:
-        if module_path.endswith(('.zip', '.egg')):
-            # Unfortunately we are reading unicode here already, not byes.
-            # It seems however 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.
-            code = module_file.read()
-        else:
-            # Read the code with a binary file, because the binary file
-            # might not be proper unicode. This is handled by the parser
-            # wrapper.
-            with open(module_path, 'rb') as f:
-                code = f.read()
-
-        module_file.close()
-
-    return code, cast_path(module_path), is_pkg
-
-
-def list_module_names(evaluator, search_path):
-    return [
-        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_to_stderr(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,5 +0,0 @@
-from jedi.evaluate.context.module import ModuleContext
-from jedi.evaluate.context.klass import ClassContext
-from jedi.evaluate.context.function import FunctionContext, FunctionExecutionContext
-from jedi.evaluate.context.instance import AnonymousInstance, BoundMethod, \
-    CompiledInstance, AbstractInstanceContext, TreeInstance

jedi/evaluate/context/asynchronous.py

@@ -1,38 +0,0 @@
-from jedi.evaluate.filters import publish_method, BuiltinOverwrite
-from jedi.evaluate.base_context import ContextSet
-
-
-class AsyncBase(BuiltinOverwrite):
-    def __init__(self, evaluator, func_execution_context):
-        super(AsyncBase, self).__init__(evaluator)
-        self.func_execution_context = func_execution_context
-
-    @property
-    def name(self):
-        return self.get_object().name
-
-    def __repr__(self):
-        return "<%s of %s>" % (type(self).__name__, self.func_execution_context)
-
-
-class Coroutine(AsyncBase):
-    special_object_identifier = u'COROUTINE'
-
-    @publish_method('__await__')
-    def _await(self):
-        return ContextSet(CoroutineWrapper(self.evaluator, self.func_execution_context))
-
-
-class CoroutineWrapper(AsyncBase):
-    special_object_identifier = u'COROUTINE_WRAPPER'
-
-    def py__stop_iteration_returns(self):
-        return self.func_execution_context.get_return_values()
-
-
-class AsyncGenerator(AsyncBase):
-    """Handling of `yield` functions."""
-    special_object_identifier = u'ASYNC_GENERATOR'
-
-    def py__aiter__(self):
-        return self.func_execution_context.get_yield_lazy_contexts(is_async=True)

jedi/evaluate/context/function.py

@@ -1,244 +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 pep0484
-from jedi.evaluate import flow_analysis
-from jedi.evaluate import helpers
-from jedi.evaluate.arguments import AnonymousArguments
-from jedi.evaluate.filters import ParserTreeFilter, FunctionExecutionFilter, \
-    ContextName, AbstractNameDefinition, ParamName
-from jedi.evaluate.base_context import ContextualizedNode, NO_CONTEXTS, \
-    ContextSet, TreeContext
-from jedi.evaluate.lazy_context import LazyKnownContexts, LazyKnownContext, \
-    LazyTreeContext
-from jedi.evaluate.context import iterable
-from jedi.evaluate.context import asynchronous
-from jedi import parser_utils
-from jedi.evaluate.parser_cache import get_yield_exprs
-
-
-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 FunctionContext(use_metaclass(CachedMetaClass, TreeContext)):
-    """
-    Needed because of decorators. Decorators are evaluated here.
-    """
-    api_type = u'function'
-
-    def __init__(self, evaluator, parent_context, funcdef):
-        """ This should not be called directly """
-        super(FunctionContext, self).__init__(evaluator, parent_context)
-        self.tree_node = funcdef
-
-    def get_filters(self, search_global, until_position=None, origin_scope=None):
-        if search_global:
-            yield ParserTreeFilter(
-                self.evaluator,
-                context=self,
-                until_position=until_position,
-                origin_scope=origin_scope
-            )
-        else:
-            scope = self.py__class__()
-            for filter in scope.get_filters(search_global=False, origin_scope=origin_scope):
-                yield filter
-
-    def infer_function_execution(self, function_execution):
-        """
-        Created to be used by inheritance.
-        """
-        is_coroutine = self.tree_node.parent.type == 'async_stmt'
-        is_generator = bool(get_yield_exprs(self.evaluator, self.tree_node))
-
-        if is_coroutine:
-            if is_generator:
-                if self.evaluator.environment.version_info < (3, 6):
-                    return NO_CONTEXTS
-                return ContextSet(asynchronous.AsyncGenerator(self.evaluator, function_execution))
-            else:
-                if self.evaluator.environment.version_info < (3, 5):
-                    return NO_CONTEXTS
-                return ContextSet(asynchronous.Coroutine(self.evaluator, function_execution))
-        else:
-            if is_generator:
-                return ContextSet(iterable.Generator(self.evaluator, function_execution))
-            else:
-                return function_execution.get_return_values()
-
-    def get_function_execution(self, arguments=None):
-        if arguments is None:
-            arguments = AnonymousArguments()
-
-        return FunctionExecutionContext(self.evaluator, self.parent_context, self, arguments)
-
-    def py__call__(self, arguments):
-        function_execution = self.get_function_execution(arguments)
-        return self.infer_function_execution(function_execution)
-
-    def py__class__(self):
-        # This differentiation is only necessary for Python2. Python3 does not
-        # use a different method class.
-        if isinstance(parser_utils.get_parent_scope(self.tree_node), tree.Class):
-            name = u'METHOD_CLASS'
-        else:
-            name = u'FUNCTION_CLASS'
-        return compiled.get_special_object(self.evaluator, name)
-
-    @property
-    def name(self):
-        if self.tree_node.type == 'lambdef':
-            return LambdaName(self)
-        return ContextName(self, self.tree_node.name)
-
-    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()]
-
-
-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)
-        self.function_context = function_context
-        self.tree_node = function_context.tree_node
-        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()
-            context_set = docstrings.infer_return_types(self.function_context)
-            context_set |= pep0484.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 get_filters(self, search_global, 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_params(self):
-        return self.var_args.get_params(self)

jedi/evaluate/context/instance.py

@@ -1,452 +0,0 @@
-from abc import abstractproperty
-
-from jedi import debug
-from jedi.evaluate import compiled
-from jedi.evaluate import filters
-from jedi.evaluate.base_context import Context, NO_CONTEXTS, ContextSet, \
-    iterator_to_context_set
-from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.arguments import AbstractArguments, AnonymousArguments
-from jedi.cache import memoize_method
-from jedi.evaluate.context.function import FunctionExecutionContext, FunctionContext
-from jedi.evaluate.context.klass import ClassContext, apply_py__get__
-from jedi.evaluate.context import iterable
-from jedi.parser_utils import get_parent_scope
-
-
-class BaseInstanceFunctionExecution(FunctionExecutionContext):
-    def __init__(self, instance, *args, **kwargs):
-        self.instance = instance
-        super(BaseInstanceFunctionExecution, self).__init__(
-            instance.evaluator, *args, **kwargs)
-
-
-class InstanceFunctionExecution(BaseInstanceFunctionExecution):
-    def __init__(self, instance, parent_context, function_context, var_args):
-        var_args = InstanceVarArgs(self, var_args)
-
-        super(InstanceFunctionExecution, self).__init__(
-            instance, parent_context, function_context, var_args)
-
-
-class AnonymousInstanceFunctionExecution(BaseInstanceFunctionExecution):
-    function_execution_filter = filters.AnonymousInstanceFunctionExecutionFilter
-
-    def __init__(self, instance, parent_context, function_context, var_args):
-        super(AnonymousInstanceFunctionExecution, self).__init__(
-            instance, parent_context, function_context, var_args)
-
-
-class AbstractInstanceContext(Context):
-    """
-    This class is used to evaluate instances.
-    """
-    api_type = u'instance'
-    function_execution_cls = InstanceFunctionExecution
-
-    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_class(self):
-        return False
-
-    @property
-    def py__call__(self):
-        names = self.get_function_slot_names(u'__call__')
-        if not names:
-            # Means the Instance is not callable.
-            raise AttributeError
-
-        def execute(arguments):
-            return ContextSet.from_sets(name.execute(arguments) for name in names)
-
-        return execute
-
-    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.execute_evaluated(*evaluated_args)
-            for name in names
-        )
-
-    def py__get__(self, obj):
-        # 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 isinstance(obj, AbstractInstanceContext):
-                return self.execute_function_slots(names, obj, obj.class_context)
-            else:
-                none_obj = compiled.builtin_from_name(self.evaluator, u'None')
-                return self.execute_function_slots(names, none_obj, obj)
-        else:
-            return ContextSet(self)
-
-    def get_filters(self, search_global=None, until_position=None,
-                    origin_scope=None, include_self_names=True):
-        if include_self_names:
-            for cls in self.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)
-
-        for cls in self.class_context.py__mro__():
-            if isinstance(cls, compiled.CompiledObject):
-                yield CompiledInstanceClassFilter(self.evaluator, self, cls)
-            else:
-                yield InstanceClassFilter(self.evaluator, self, cls, origin_scope)
-
-    def py__getitem__(self, index):
-        try:
-            names = self.get_function_slot_names(u'__getitem__')
-        except KeyError:
-            debug.warning('No __getitem__, cannot access the array.')
-            return NO_CONTEXTS
-        else:
-            index_obj = compiled.create_simple_object(self.evaluator, index)
-            return self.execute_function_slots(names, index_obj)
-
-    def py__iter__(self):
-        iter_slot_names = self.get_function_slot_names(u'__iter__')
-        if not iter_slot_names:
-            debug.warning('No __iter__ on %s.' % self)
-            return
-
-        for generator in self.execute_function_slots(iter_slot_names):
-            if isinstance(generator, AbstractInstanceContext):
-                # `__next__` logic.
-                if self.evaluator.environment.version_info.major == 2:
-                    name = u'next'
-                else:
-                    name = u'__next__'
-                iter_slot_names = generator.get_function_slot_names(name)
-                if iter_slot_names:
-                    yield LazyKnownContexts(
-                        generator.execute_function_slots(iter_slot_names)
-                    )
-                else:
-                    debug.warning('Instance has no __next__ function in %s.', generator)
-            else:
-                for lazy_context in generator.py__iter__():
-                    yield lazy_context
-
-    @abstractproperty
-    def name(self):
-        pass
-
-    def _create_init_execution(self, class_context, func_node):
-        bound_method = BoundMethod(
-            self.evaluator, self, class_context, self.parent_context, func_node
-        )
-        return self.function_execution_cls(
-            self,
-            class_context.parent_context,
-            bound_method,
-            self.var_args
-        )
-
-    def create_init_executions(self):
-        for name in self.get_function_slot_names(u'__init__'):
-            if isinstance(name, SelfName):
-                yield self._create_init_execution(name.class_context, name.tree_name.parent)
-
-    @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':
-                if scope.name.value == '__init__' and parent_context == class_context:
-                    return self._create_init_execution(class_context, scope)
-                else:
-                    bound_method = BoundMethod(
-                        self.evaluator, self, class_context,
-                        parent_context, scope
-                    )
-                    return bound_method.get_function_execution()
-            elif scope.type == 'classdef':
-                class_context = ClassContext(self.evaluator, parent_context, scope)
-                return class_context
-            elif scope.type == '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 __repr__(self):
-        return "<%s of %s(%s)>" % (self.__class__.__name__, self.class_context,
-                                   self.var_args)
-
-
-class CompiledInstance(AbstractInstanceContext):
-    def __init__(self, *args, **kwargs):
-        super(CompiledInstance, self).__init__(*args, **kwargs)
-        # I don't think that dynamic append lookups should happen here. That
-        # sounds more like something that should go to py__iter__.
-        self._original_var_args = self.var_args
-
-        if self.class_context.name.string_name in ['list', 'set'] \
-                and self.parent_context.get_root_context() == self.evaluator.builtins_module:
-            # compare the module path with the builtin name.
-            self.var_args = iterable.get_dynamic_array_instance(self)
-
-    @property
-    def name(self):
-        return compiled.CompiledContextName(self, self.class_context.name.string_name)
-
-    def create_instance_context(self, class_context, node):
-        if get_parent_scope(node).type == 'classdef':
-            return class_context
-        else:
-            return super(CompiledInstance, self).create_instance_context(class_context, node)
-
-    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()
-
-
-class TreeInstance(AbstractInstanceContext):
-    def __init__(self, evaluator, parent_context, class_context, 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 filters.ContextName(self, self.class_context.name.tree_name)
-
-
-class AnonymousInstance(TreeInstance):
-    function_execution_cls = AnonymousInstanceFunctionExecution
-
-    def __init__(self, evaluator, parent_context, class_context):
-        super(AnonymousInstance, self).__init__(
-            evaluator,
-            parent_context,
-            class_context,
-            var_args=AnonymousArguments(),
-        )
-
-
-class CompiledInstanceName(compiled.CompiledName):
-    def __init__(self, evaluator, instance, parent_context, name):
-        super(CompiledInstanceName, self).__init__(evaluator, parent_context, name)
-        self._instance = instance
-
-    @iterator_to_context_set
-    def infer(self):
-        for result_context in super(CompiledInstanceName, self).infer():
-            is_function = result_context.api_type == 'function'
-            if result_context.tree_node is not None and is_function:
-                parent_context = result_context.parent_context
-                while parent_context.is_class():
-                    parent_context = parent_context.parent_context
-
-                yield BoundMethod(
-                    result_context.evaluator, self._instance, self.parent_context,
-                    parent_context, result_context.tree_node
-                )
-            else:
-                if is_function:
-                    yield CompiledBoundMethod(result_context)
-                else:
-                    yield result_context
-
-
-class CompiledInstanceClassFilter(compiled.CompiledObjectFilter):
-    name_class = CompiledInstanceName
-
-    def __init__(self, evaluator, instance, compiled_object):
-        super(CompiledInstanceClassFilter, self).__init__(
-            evaluator,
-            compiled_object,
-            is_instance=True,
-        )
-        self._instance = instance
-
-    def _create_name(self, name):
-        return self.name_class(
-            self._evaluator, self._instance, self._compiled_object, name)
-
-
-class BoundMethod(FunctionContext):
-    def __init__(self, evaluator, instance, class_context, *args, **kwargs):
-        super(BoundMethod, self).__init__(evaluator, *args, **kwargs)
-        self._instance = instance
-        self._class_context = class_context
-
-    def get_function_execution(self, arguments=None):
-        if arguments is None:
-            arguments = AnonymousArguments()
-            return AnonymousInstanceFunctionExecution(
-                self._instance, self.parent_context, self, arguments)
-        else:
-            return InstanceFunctionExecution(
-                self._instance, self.parent_context, self, arguments)
-
-
-class CompiledBoundMethod(compiled.CompiledObject):
-    def __init__(self, func):
-        super(CompiledBoundMethod, self).__init__(
-            func.evaluator, func.access_handle, func.parent_context, func.tree_node)
-
-    def get_param_names(self):
-        return list(super(CompiledBoundMethod, self).get_param_names())[1:]
-
-
-class InstanceNameDefinition(filters.TreeNameDefinition):
-    def infer(self):
-        return super(InstanceNameDefinition, self).infer()
-
-
-class SelfName(filters.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(SelfName):
-    @iterator_to_context_set
-    def infer(self):
-        for result_context in super(LazyInstanceClassName, self).infer():
-            if isinstance(result_context, FunctionContext):
-                # Classes are never used to resolve anything within the
-                # functions. Only other functions and modules will resolve
-                # those things.
-                parent_context = result_context.parent_context
-                while parent_context.is_class():
-                    parent_context = parent_context.parent_context
-
-                yield BoundMethod(
-                    result_context.evaluator, self._instance, self.class_context,
-                    parent_context, result_context.tree_node
-                )
-            else:
-                for c in apply_py__get__(result_context, self._instance):
-                    yield c
-
-
-class InstanceClassFilter(filters.ParserTreeFilter):
-    name_class = LazyInstanceClassName
-
-    def __init__(self, evaluator, context, class_context, origin_scope):
-        super(InstanceClassFilter, self).__init__(
-            evaluator=evaluator,
-            context=context,
-            node_context=class_context,
-            origin_scope=origin_scope
-        )
-        self._class_context = class_context
-
-    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_parent_scope(node)
-        return False
-
-    def _access_possible(self, name):
-        return not name.value.startswith('__') or name.value.endswith('__') \
-            or self._equals_origin_scope()
-
-    def _filter(self, names):
-        names = super(InstanceClassFilter, self)._filter(names)
-        return [name for name in names if self._access_possible(name)]
-
-    def _convert_names(self, names):
-        return [self.name_class(self.context, self._class_context, name) for name in names]
-
-
-class SelfAttributeFilter(InstanceClassFilter):
-    """
-    This class basically filters all the use cases where `self.*` was assigned.
-    """
-    name_class = SelfName
-
-    def _filter(self, names):
-        names = self._filter_self_names(names)
-        if isinstance(self._parser_scope, compiled.CompiledObject) and False:
-            # This would be for builtin skeletons, which are not yet supported.
-            return list(names)
-        else:
-            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.children) == 2 \
-                    and trailer.children[0] == '.':
-                if name.is_definition() and self._access_possible(name):
-                    yield name
-
-    def _check_flows(self, names):
-        return names
-
-
-class InstanceVarArgs(AbstractArguments):
-    def __init__(self, execution_context, var_args):
-        self._execution_context = execution_context
-        self._var_args = var_args
-
-    @memoize_method
-    def _get_var_args(self):
-        return self._var_args
-
-    @property
-    def argument_node(self):
-        return self._var_args.argument_node
-
-    @property
-    def trailer(self):
-        return self._var_args.trailer
-
-    def unpack(self, func=None):
-        yield None, LazyKnownContext(self._execution_context.instance)
-        for values in self._get_var_args().unpack(func):
-            yield values
-
-    def get_calling_nodes(self):
-        return self._get_var_args().get_calling_nodes()

jedi/evaluate/context/iterable.py

@@ -1,702 +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.
-"""
-from jedi import debug
-from jedi import settings
-from jedi._compatibility import force_unicode, is_py3
-from jedi.cache import memoize_method
-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
-from jedi.evaluate.utils import safe_property
-from jedi.evaluate.utils import to_list
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.filters import ParserTreeFilter, BuiltinOverwrite, \
-    publish_method
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, Context, \
-    TreeContext, ContextualizedNode
-from jedi.parser_utils import get_comp_fors
-
-
-class IterableMixin(object):
-    def py__stop_iteration_returns(self):
-        return ContextSet(compiled.builtin_from_name(self.evaluator, u'None'))
-
-
-class GeneratorBase(BuiltinOverwrite, IterableMixin):
-    array_type = None
-    special_object_identifier = u'GENERATOR_OBJECT'
-
-    @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__())
-
-    @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):
-        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 __init__(self, evaluator, parent_context, comp_for):
-        super(CompForContext, self).__init__(evaluator, parent_context)
-        self.tree_node = comp_for
-
-    def get_node(self):
-        return self.tree_node
-
-    def get_filters(self, search_global, until_position=None, origin_scope=None):
-        yield ParserTreeFilter(self.evaluator, self)
-
-
-def comprehension_from_atom(evaluator, context, atom):
-    bracket = atom.children[0]
-    if bracket == '{':
-        if atom.children[1].children[1] == ':':
-            cls = DictComprehension
-        else:
-            cls = SetComprehension
-    elif bracket == '(':
-        cls = GeneratorComprehension
-    elif bracket == '[':
-        cls = ListComprehension
-    return cls(evaluator, context, atom)
-
-
-class ComprehensionMixin(object):
-    def __init__(self, evaluator, defining_context, atom):
-        super(ComprehensionMixin, self).__init__(evaluator)
-        self._defining_context = defining_context
-        self._atom = atom
-
-    def _get_comprehension(self):
-        "return 'a for a in b'"
-        # The atom contains a testlist_comp
-        return self._atom.children[1]
-
-    def _get_comp_for(self):
-        "return CompFor('for a in b')"
-        return self._get_comprehension().children[1]
-
-    def _eval_node(self, index=0):
-        """
-        The first part `x + 1` of the list comprehension:
-
-            [x + 1 for x in foo]
-        """
-        return self._get_comprehension().children[index]
-
-    @evaluator_method_cache()
-    def _get_comp_for_context(self, parent_context, comp_for):
-        # TODO shouldn't this be part of create_context?
-        return CompForContext.from_comp_for(parent_context, comp_for)
-
-    def _nested(self, comp_fors, parent_context=None):
-        comp_for = comp_fors[0]
-
-        is_async = 'async' == comp_for.children[comp_for.children.index('for') - 1]
-
-        input_node = comp_for.children[comp_for.children.index('in') + 1]
-        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[comp_for.children.index('for') + 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._eval_node())
-                    if self.array_type == 'dict':
-                        yield iterated, context_.eval_node(self._eval_node(2))
-                    else:
-                        yield iterated
-
-    @evaluator_method_cache(default=[])
-    @to_list
-    def _iterate(self):
-        comp_fors = tuple(get_comp_fors(self._get_comp_for()))
-        for result in self._nested(comp_fors):
-            yield result
-
-    def py__iter__(self):
-        for set_ in self._iterate():
-            yield LazyKnownContexts(set_)
-
-    def __repr__(self):
-        return "<%s of %s>" % (type(self).__name__, self._atom)
-
-
-class Sequence(BuiltinOverwrite, IterableMixin):
-    api_type = u'instance'
-
-    @property
-    def name(self):
-        return compiled.CompiledContextName(self, self.array_type)
-
-    @memoize_method
-    def get_object(self):
-        compiled_obj = compiled.builtin_from_name(self.evaluator, self.array_type)
-        only_obj, = compiled_obj.execute_evaluated(self)
-        return only_obj
-
-    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 dict_values(self):
-        return ContextSet.from_sets(
-            self._defining_context.eval_node(v)
-            for k, v in self._items()
-        )
-
-
-class ListComprehension(ComprehensionMixin, Sequence):
-    array_type = u'list'
-
-    def py__getitem__(self, index):
-        if isinstance(index, slice):
-            return ContextSet(self)
-
-        all_types = list(self.py__iter__())
-        return all_types[index].infer()
-
-
-class SetComprehension(ComprehensionMixin, Sequence):
-    array_type = u'set'
-
-
-class DictComprehension(ComprehensionMixin, Sequence):
-    array_type = u'dict'
-
-    def _get_comp_for(self):
-        return self._get_comprehension().children[3]
-
-    def py__iter__(self):
-        for keys, values in self._iterate():
-            yield LazyKnownContexts(keys)
-
-    def py__getitem__(self, index):
-        for keys, values in self._iterate():
-            for k in keys:
-                if isinstance(k, compiled.CompiledObject):
-                    if k.get_safe_value(default=object()) == index:
-                        return values
-        return self.dict_values()
-
-    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):
-        items = ContextSet.from_iterable(
-            FakeSequence(
-                self.evaluator, u'tuple'
-                (LazyKnownContexts(keys), LazyKnownContexts(values))
-            ) for keys, values in self._iterate()
-        )
-
-        return create_evaluated_sequence_set(self.evaluator, items, sequence_type=u'list')
-
-
-class GeneratorComprehension(ComprehensionMixin, GeneratorBase):
-    pass
-
-
-class SequenceLiteralContext(Sequence):
-    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 ('testlist_star_expr', 'testlist'):
-            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__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._items():
-                for k in self._defining_context.eval_node(key):
-                    if isinstance(k, compiled.CompiledObject) \
-                            and k.execute_operation(compiled_obj_index, u'==').get_safe_value():
-                        return self._defining_context.eval_node(value)
-            raise KeyError('No key found in dictionary %s.' % self)
-
-        # Can raise an IndexError
-        if isinstance(index, slice):
-            return ContextSet(self)
-        else:
-            return self._defining_context.eval_node(self._items()[index])
-
-    def py__iter__(self):
-        """
-        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 = ContextSet()
-            for k, _ in self._items():
-                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._items():
-                yield LazyTreeContext(self._defining_context, node)
-
-            for addition in check_array_additions(self._defining_context, self):
-                yield addition
-
-    def _values(self):
-        """Returns a list of a list of node."""
-        if self.array_type == u'dict':
-            return ContextSet.from_sets(v for k, v in self._items())
-        else:
-            return self._items()
-
-    def _items(self):
-        c = self.atom.children
-
-        if self.atom.type in ('testlist_star_expr', 'testlist'):
-            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':
-            return array_node.children[::2]
-        elif array_node.type == 'dictorsetmaker':
-            kv = []
-            iterator = iter(array_node.children)
-            for key in iterator:
-                op = next(iterator, None)
-                if op is None or op == ',':
-                    kv.append(key)  # A set.
-                else:
-                    assert op == ':'  # A dict.
-                    kv.append((key, next(iterator)))
-                    next(iterator, None)  # Possible comma.
-            return kv
-        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._items():
-            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(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._items()
-        ]
-
-        return ContextSet(FakeSequence(self.evaluator, u'list', lazy_contexts))
-
-
-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__getitem__(self, index):
-        return self._lazy_context_list[index].infer()
-
-    def py__iter__(self):
-        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(_FakeArray):
-    def __init__(self, evaluator, dct):
-        super(FakeDict, self).__init__(evaluator, dct, u'dict')
-        self._dct = dct
-
-    def py__iter__(self):
-        for key in self._dct:
-            yield LazyKnownContext(compiled.create_simple_object(self.evaluator, key))
-
-    def py__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
-
-        return self._dct[index].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 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):
-        for array in self._arrays:
-            for lazy_context in array.py__iter__():
-                yield lazy_context
-
-    def py__getitem__(self, index):
-        return ContextSet.from_sets(lazy_context.infer() for lazy_context in self.py__iter__())
-
-    def _items(self):
-        for array in self._arrays:
-            for a in array._items():
-                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 ContextSet()
-
-    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, whatever in params:
-                result.add(whatever)
-        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):
-    """Used for set() and list() instances."""
-    if not settings.dynamic_array_additions:
-        return instance.var_args
-
-    ai = _ArrayInstance(instance)
-    from jedi.evaluate import arguments
-    return arguments.ValuesArguments([ContextSet(ai)])
-
-
-class _ArrayInstance(object):
-    """
-    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.
-
-    In contrast to Array, ListComprehension and all other iterable types, this
-    is something that is only used inside `evaluate/compiled/fake/builtins.py`
-    and therefore doesn't need filters, `py__bool__` and so on, because
-    we don't use these operations in `builtins.py`.
-    """
-    def __init__(self, instance):
-        self.instance = instance
-        self.var_args = instance.var_args
-
-    def py__iter__(self):
-        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__()
-
-
-class Slice(Context):
-    def __init__(self, context, start, stop, step):
-        super(Slice, self).__init__(
-            context.evaluator,
-            parent_context=context.evaluator.builtins_module
-        )
-        self._context = context
-        # all of them are either a Precedence or None.
-        self._start = start
-        self._stop = stop
-        self._step = step
-
-    @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,197 +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__(params: 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__mro__()                            Returns a list of classes (the mro).
-py__iter__()                           Returns a generator of a set of types.
-py__class__()                          Returns the class of an instance.
-py__getitem__(index: int/str)          Returns a a set of types of the index.
-                                       Can raise an IndexError/KeyError.
-py__file__()                           Only on modules. Returns None if does
-                                       not exist.
-py__package__()                        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__(include_call_signature:      Returns the docstring for a context.
-          bool)
-====================================== ========================================
-
-"""
-from jedi._compatibility import use_metaclass
-from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass
-from jedi.evaluate import compiled
-from jedi.evaluate.lazy_context import LazyKnownContext
-from jedi.evaluate.filters import ParserTreeFilter, TreeNameDefinition, \
-    ContextName, AnonymousInstanceParamName
-from jedi.evaluate.base_context import ContextSet, iterator_to_context_set, \
-    TreeContext
-
-
-def apply_py__get__(context, base_context):
-    try:
-        method = context.py__get__
-    except AttributeError:
-        yield context
-    else:
-        for descriptor_context in method(base_context):
-            yield descriptor_context
-
-
-class ClassName(TreeNameDefinition):
-    def __init__(self, parent_context, tree_name, name_context):
-        super(ClassName, self).__init__(parent_context, tree_name)
-        self._name_context = name_context
-
-    @iterator_to_context_set
-    def infer(self):
-        # TODO this _name_to_types might get refactored and be a part of the
-        # parent class. Once it is, we can probably just overwrite method to
-        # achieve this.
-        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:
-            for c in apply_py__get__(result_context, self.parent_context):
-                yield c
-
-
-class ClassFilter(ParserTreeFilter):
-    name_class = ClassName
-
-    def _convert_names(self, names):
-        return [self.name_class(self.context, name, self._node_context)
-                for name in names]
-
-
-class ClassContext(use_metaclass(CachedMetaClass, TreeContext)):
-    """
-    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'
-
-    def __init__(self, evaluator, parent_context, classdef):
-        super(ClassContext, self).__init__(evaluator, parent_context=parent_context)
-        self.tree_node = classdef
-
-    @evaluator_method_cache(default=())
-    def py__mro__(self):
-        def add(cls):
-            if cls not in mro:
-                mro.append(cls)
-
-        mro = [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)
-                    """
-                    pass
-                else:
-                    add(cls)
-                    for cls_new in mro_method():
-                        add(cls_new)
-        return tuple(mro)
-
-    @evaluator_method_cache(default=())
-    def py__bases__(self):
-        arglist = self.tree_node.get_super_arglist()
-        if arglist:
-            from jedi.evaluate import arguments
-            args = arguments.TreeArguments(self.evaluator, self.parent_context, arglist)
-            return [value for key, value in args.unpack() if key is None]
-        else:
-            return [LazyKnownContext(compiled.builtin_from_name(self.evaluator, u'object'))]
-
-    def py__call__(self, params):
-        from jedi.evaluate.context import TreeInstance
-        return ContextSet(TreeInstance(self.evaluator, self.parent_context, self, params))
-
-    def py__class__(self):
-        return compiled.builtin_from_name(self.evaluator, u'type')
-
-    def get_params(self):
-        from jedi.evaluate.context import AnonymousInstance
-        anon = AnonymousInstance(self.evaluator, self.parent_context, self)
-        return [AnonymousInstanceParamName(anon, param.name) for param in self.funcdef.get_params()]
-
-    def get_filters(self, search_global, until_position=None, origin_scope=None, is_instance=False):
-        if search_global:
-            yield ParserTreeFilter(
-                self.evaluator,
-                context=self,
-                until_position=until_position,
-                origin_scope=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)
-
-    def is_class(self):
-        return True
-
-    def get_function_slot_names(self, name):
-        for filter in self.get_filters(search_global=False):
-            names = filter.get(name)
-            if names:
-                return names
-        return []
-
-    def get_param_names(self):
-        for name in self.get_function_slot_names(u'__init__'):
-            for context_ in name.infer():
-                try:
-                    method = context_.get_param_names
-                except AttributeError:
-                    pass
-                else:
-                    return list(method())[1:]
-        return []
-
-    @property
-    def name(self):
-        return ContextName(self, self.tree_node.name)

jedi/evaluate/context/module.py

@@ -1,212 +0,0 @@
-import re
-import os
-
-from parso import python_bytes_to_unicode
-
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi._compatibility import iter_modules, all_suffixes
-from jedi.evaluate.filters import GlobalNameFilter, ContextNameMixin, \
-    AbstractNameDefinition, ParserTreeFilter, DictFilter, MergedFilter
-from jedi.evaluate import compiled
-from jedi.evaluate.base_context import TreeContext
-from jedi.evaluate.imports import SubModuleName, infer_import
-
-
-class _ModuleAttributeName(AbstractNameDefinition):
-    """
-    For module attributes like __file__, __str__ and so on.
-    """
-    api_type = u'instance'
-
-    def __init__(self, parent_module, string_name):
-        self.parent_context = parent_module
-        self.string_name = string_name
-
-    def infer(self):
-        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
-
-
-class ModuleContext(TreeContext):
-    api_type = u'module'
-    parent_context = None
-
-    def __init__(self, evaluator, module_node, path, code_lines):
-        super(ModuleContext, self).__init__(evaluator, parent_context=None)
-        self.tree_node = module_node
-        self._path = path
-        self.code_lines = code_lines
-
-    def get_filters(self, search_global, 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_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):
-        modules = []
-        for i in self.tree_node.iter_imports():
-            if i.is_star_import():
-                name = i.get_paths()[-1][-1]
-                new = infer_import(self, name)
-                for module in new:
-                    if isinstance(module, ModuleContext):
-                        modules += module.star_imports()
-                modules += new
-        return modules
-
-    @evaluator_method_cache()
-    def _module_attributes_dict(self):
-        names = ['__file__', '__package__', '__doc__', '__name__']
-        # All the additional module attributes are strings.
-        return dict((n, _ModuleAttributeName(self, n)) for n in names)
-
-    @property
-    def _string_name(self):
-        """ This is used for the goto functions. """
-        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__)?(\.py|\.so)?$' % sep, self._path)
-            # Remove PEP 3149 names
-            return re.sub(r'\.[a-z]+-\d{2}[mud]{0,3}$', '', r.group(1))
-
-    @property
-    @evaluator_method_cache()
-    def name(self):
-        return ModuleName(self, self._string_name)
-
-    def _get_init_directory(self):
-        """
-        :return: The path to the directory of a package. None in case it's not
-                 a package.
-        """
-        for suffix in all_suffixes():
-            ending = '__init__' + suffix
-            py__file__ = self.py__file__()
-            if py__file__ is not None and py__file__.endswith(ending):
-                # Remove the ending, including the separator.
-                return self.py__file__()[:-len(ending) - 1]
-        return None
-
-    def py__name__(self):
-        for name, module in self.evaluator.module_cache.iterate_modules_with_names():
-            if module == self and name != '':
-                return name
-
-        return '__main__'
-
-    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._get_init_directory() is None:
-            return re.sub(r'\.?[^.]+$', '', self.py__name__())
-        else:
-            return self.py__name__()
-
-    def _py__path__(self):
-        search_path = self.evaluator.get_sys_path()
-        init_path = self.py__file__()
-        if os.path.basename(init_path) == '__init__.py':
-            with open(init_path, 'rb') as f:
-                content = python_bytes_to_unicode(f.read(), errors='replace')
-                # 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 content or options[1] in content:
-                    # 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 search_path:
-                        other = os.path.join(s, self.name.string_name)
-                        if os.path.isdir(other):
-                            paths.add(other)
-                    if paths:
-                        return list(paths)
-                    # TODO I'm not sure if this is how nested namespace
-                    # packages work. The tests are not really good enough to
-                    # show that.
-        # Default to this.
-        return [self._get_init_directory()]
-
-    @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.
-        """
-        path = self._get_init_directory()
-
-        if path is None:
-            raise AttributeError('Only packages have __path__ attributes.')
-        else:
-            return self._py__path__
-
-    @evaluator_method_cache()
-    def _sub_modules_dict(self):
-        """
-        Lists modules in the directory of this module (if this module is a
-        package).
-        """
-        path = self._path
-        names = {}
-        if path is not None and path.endswith(os.path.sep + '__init__.py'):
-            mods = iter_modules([os.path.dirname(path)])
-            for module_loader, name, is_pkg in mods:
-                # It's obviously a relative import to the current module.
-                names[name] = SubModuleName(self, name)
-
-        # TODO add something like this in the future, its cleaner than the
-        #   import hacks.
-        # ``os.path`` is a hardcoded exception, because it's a
-        # ``sys.modules`` modification.
-        # if str(self.name) == 'os':
-        #     names.append(Name('path', parent_context=self))
-
-        return names
-
-    def py__class__(self):
-        return compiled.get_special_object(self.evaluator, u'MODULE_CLASS')
-
-    def __repr__(self):
-        return "<%s: %s@%s-%s>" % (
-            self.__class__.__name__, self._string_name,
-            self.tree_node.start_pos[0], self.tree_node.end_pos[0])

jedi/evaluate/context/namespace.py

@@ -1,76 +0,0 @@
-import os
-from itertools import chain
-
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate import imports
-from jedi.evaluate.filters import DictFilter, AbstractNameDefinition
-from jedi.evaluate.base_context import TreeContext, ContextSet
-
-
-class ImplicitNSName(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.parent_context = implicit_ns_context
-        self.string_name = string_name
-
-    def infer(self):
-        return ContextSet(self.parent_context)
-
-    def get_root_context(self):
-        return self.parent_context
-
-
-class ImplicitNamespaceContext(TreeContext):
-    """
-    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, until_position=None, origin_scope=None):
-        yield DictFilter(self._sub_modules_dict())
-
-    @property
-    @evaluator_method_cache()
-    def name(self):
-        string_name = self.py__package__().rpartition('.')[-1]
-        return ImplicitNSName(self, string_name)
-
-    def py__file__(self):
-        return None
-
-    def py__package__(self):
-        """Return the fullname
-        """
-        return self._fullname
-
-    @property
-    def py__path__(self):
-        return lambda: [self.paths]
-
-    @evaluator_method_cache()
-    def _sub_modules_dict(self):
-        names = {}
-
-        file_names = chain.from_iterable(os.listdir(path) for path in self.paths)
-        mods = [
-            file_name.rpartition('.')[0] if '.' in file_name else file_name
-            for file_name in file_names
-            if file_name != '__pycache__'
-        ]
-
-        for name in mods:
-            names[name] = imports.SubModuleName(self, name)
-        return names

jedi/evaluate/dynamic.py

@@ -1,223 +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 parso.python import tree
-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
-
-
-
-MAX_PARAM_SEARCHES = 20
-
-
-class MergedExecutedParams(object):
-    """
-    Simulates being a parameter while actually just being multiple params.
-    """
-    def __init__(self, executed_params):
-        self._executed_params = executed_params
-
-    def infer(self):
-        return ContextSet.from_sets(p.infer() for p in self._executed_params)
-
-
-@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_params()
-                    for function_execution in function_executions
-                ))
-                params = [MergedExecutedParams(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 isinstance(cls, tree.Class):
-            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_params()
-            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,515 +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
-
-from parso.tree import search_ancestor
-
-from jedi._compatibility import use_metaclass, Parameter
-from jedi.cache import memoize_method
-from jedi.evaluate import flow_analysis
-from jedi.evaluate.base_context import ContextSet, Context
-from jedi.parser_utils import get_parent_scope
-from jedi.evaluate.utils import to_list
-
-
-class AbstractNameDefinition(object):
-    start_pos = None
-    string_name = None
-    parent_context = None
-    tree_name = None
-
-    @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_root_context(self):
-        return self.parent_context.get_root_context()
-
-    def __repr__(self):
-        if self.start_pos is None:
-            return '<%s: %s>' % (self.__class__.__name__, self.string_name)
-        return '<%s: %s@%s>' % (self.__class__.__name__, self.string_name, self.start_pos)
-
-    def execute(self, arguments):
-        return self.infer().execute(arguments)
-
-    def execute_evaluated(self, *args, **kwargs):
-        return self.infer().execute_evaluated(*args, **kwargs)
-
-    def is_import(self):
-        return False
-
-    @property
-    def api_type(self):
-        return self.parent_context.api_type
-
-
-class AbstractTreeName(AbstractNameDefinition):
-    def __init__(self, parent_context, tree_name):
-        self.parent_context = parent_context
-        self.tree_name = tree_name
-
-    def goto(self):
-        return self.parent_context.evaluator.goto(self.parent_context, self.tree_name)
-
-    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_root_context(self):
-        if self.parent_context is None:
-            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
-
-
-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
-        return tree_name_to_contexts(self.parent_context.evaluator, self.parent_context, 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 ParamName(AbstractTreeName):
-    api_type = u'param'
-
-    def __init__(self, parent_context, tree_name):
-        self.parent_context = parent_context
-        self.tree_name = tree_name
-
-    def get_kind(self):
-        tree_param = search_ancestor(self.tree_name, 'param')
-        if tree_param.star_count == 1:  # *args
-            return Parameter.VAR_POSITIONAL
-        if tree_param.star_count == 2:  # **kwargs
-            return Parameter.VAR_KEYWORD
-
-        parent = tree_param.parent
-        for p in parent.children:
-            if p.type == 'param':
-                if p.star_count:
-                    return Parameter.KEYWORD_ONLY
-                if p == tree_param:
-                    break
-        return Parameter.POSITIONAL_OR_KEYWORD
-
-    def infer(self):
-        return self.get_param().infer()
-
-    def get_param(self):
-        params = self.parent_context.get_params()
-        param_node = search_ancestor(self.tree_name, 'param')
-        return params[param_node.position_index]
-
-
-class AnonymousInstanceParamName(ParamName):
-    def infer(self):
-        param_node = search_ancestor(self.tree_name, 'param')
-        # TODO I think this should not belong here. It's not even really true,
-        #      because classmethod and other descriptors can change it.
-        if param_node.position_index == 0:
-            # This is a speed optimization, to return the self param (because
-            # it's known). This only affects anonymous instances.
-            return ContextSet(self.parent_context.instance)
-        else:
-            return self.get_param().infer()
-
-
-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 AbstractUsedNamesFilter(AbstractFilter):
-    name_class = TreeNameDefinition
-
-    def __init__(self, context, parser_scope):
-        self._parser_scope = parser_scope
-        self._used_names = self._parser_scope.get_root_node().get_used_names()
-        self.context = context
-
-    def get(self, name):
-        try:
-            names = self._used_names[name]
-        except KeyError:
-            return []
-
-        return self._convert_names(self._filter(names))
-
-    def _convert_names(self, names):
-        return [self.name_class(self.context, name) for name in names]
-
-    def values(self):
-        return self._convert_names(name for name_list in self._used_names.values()
-                                   for name in self._filter(name_list))
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self.context)
-
-
-class ParserTreeFilter(AbstractUsedNamesFilter):
-    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):
-        if not name.is_definition():
-            return False
-        parent = name.parent
-        if parent.type == 'trailer':
-            return False
-        base_node = parent if parent.type in ('classdef', 'funcdef') else name
-        return get_parent_scope(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 AnonymousInstanceFunctionExecutionFilter(FunctionExecutionFilter):
-    param_name = AnonymousInstanceParamName
-
-
-class GlobalNameFilter(AbstractUsedNamesFilter):
-    def __init__(self, context, parser_scope):
-        super(GlobalNameFilter, self).__init__(context, parser_scope)
-
-    @to_list
-    def _filter(self, names):
-        for name in names:
-            if name.parent.type == 'global_stmt':
-                yield name
-
-
-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
-
-
-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, params):
-        # 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 AbstractObjectOverwrite(use_metaclass(_OverwriteMeta, object)):
-    def get_object(self):
-        raise NotImplementedError
-
-    def get_filters(self, search_global, *args, **kwargs):
-        yield SpecialMethodFilter(self, self.overwritten_methods, self.get_object())
-
-        for filter in self.get_object().get_filters(search_global):
-            yield filter
-
-
-class BuiltinOverwrite(Context, AbstractObjectOverwrite):
-    special_object_identifier = None
-
-    def __init__(self, evaluator):
-        super(BuiltinOverwrite, self).__init__(evaluator, evaluator.builtins_module)
-
-    @memoize_method
-    def get_object(self):
-        from jedi.evaluate import compiled
-        assert self.special_object_identifier
-        return compiled.get_special_object(self.evaluator, self.special_object_identifier)
-
-    def py__class__(self):
-        return self.get_object().py__class__()
-
-
-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())
-    ['<TreeNameDefinition: func@(3, 4)>', '<TreeNameDefinition: x@(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__', '__file__', '__name__', '__package__']
-
-    Finally, it yields the builtin filter, if `include_builtin` is
-    true (default).
-
-    >>> filters[3].values()                              #doctest: +ELLIPSIS
-    [<CompiledName: ...>, ...]
-    """
-    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.
-    for filter in evaluator.builtins_module.get_filters(search_global=True):
-        yield filter

jedi/evaluate/finder.py

@@ -1,278 +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.context import AbstractInstanceContext
-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, TreeNameDefinition
-from jedi.evaluate.base_context import ContextSet
-from jedi.parser_utils import is_scope, get_parent_scope
-
-
-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
-
-    @debug.increase_indent
-    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 ContextSet()
-            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 < 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._context.get_filters(search_global, self._position, origin_scope=origin_scope)
-
-    def filter_name(self, filters):
-        """
-        Searches names that are defined in a scope (the different
-        ``filters``), until a name fits.
-        """
-        names = []
-        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"):
-                    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:
-                            if self._name.get_definition().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 isinstance(self._context, AbstractInstanceContext):
-            # 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 isinstance(self._name_context, AbstractInstanceContext):
-            flow_scope = self._name
-            base_node = self._name_context.tree_node
-            if base_node.type == 'comp_for':
-                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 == base_node:
-                    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 = ContextSet()
-    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__():
-                for context in lazy_context.infer():
-                    context_set |= context.execute_evaluated()
-        else:
-            context_set |= cls_or_tup.execute_evaluated()
-    return context_set

jedi/evaluate/imports.py

@@ -1,571 +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 unicode, ImplicitNSInfo, force_unicode
-from jedi import debug
-from jedi import settings
-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, dotted_from_fs_path
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.filters import AbstractNameDefinition
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-
-
-class ModuleCache(object):
-    def __init__(self):
-        self._path_cache = {}
-        self._name_cache = {}
-
-    def add(self, module, name):
-        path = module.py__file__()
-        self._path_cache[path] = module
-        self._name_cache[name] = module
-
-    def iterate_modules_with_names(self):
-        return self._name_cache.items()
-
-    def get(self, name):
-        return self._name_cache[name]
-
-    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.from_set(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=None):
-    # Should be a name, not a string!
-    if message is None:
-        name_str = str(name.value) if isinstance(name, tree.Name) else name
-        message = 'No module named ' + name_str
-    if hasattr(name, 'parent'):
-        analysis.add(context, 'import-error', name, message)
-    else:
-        debug.warning('ImportError without origin: ' + message)
-
-
-class ImportName(AbstractNameDefinition):
-    start_pos = (1, 0)
-    _level = 0
-
-    def __init__(self, parent_context, string_name):
-        self.parent_context = parent_context
-        self.string_name = string_name
-
-    def infer(self):
-        return Importer(
-            self.parent_context.evaluator,
-            [self.string_name],
-            self.parent_context,
-            level=self._level,
-        ).follow()
-
-    def goto(self):
-        return [m.name for m in self.infer()]
-
-    def get_root_context(self):
-        # Not sure if this is correct.
-        return self.parent_context.get_root_context()
-
-    @property
-    def api_type(self):
-        return 'module'
-
-
-class SubModuleName(ImportName):
-    _level = 1
-
-
-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' % (import_path,))
-        self._evaluator = evaluator
-        self.level = level
-        self.module_context = module_context
-        try:
-            self.file_path = module_context.py__file__()
-        except AttributeError:
-            # Can be None for certain compiled modules like 'builtins'.
-            self.file_path = None
-
-        if level:
-            base = module_context.py__package__().split('.')
-            if base == [''] or base == ['__main__']:
-                base = []
-            if level > len(base):
-                path = module_context.py__file__()
-                if path is not None:
-                    import_path = list(import_path)
-                    p = path
-                    for i in range(level):
-                        p = os.path.dirname(p)
-                    dir_name = os.path.basename(p)
-                    # This is not the proper way to do relative imports. However, since
-                    # Jedi cannot be sure about the entry point, we just calculate an
-                    # absolute path here.
-                    if dir_name:
-                        # TODO those sys.modules modifications are getting
-                        # really stupid. this is the 3rd time that we're using
-                        # this. We should probably refactor.
-                        if path.endswith(os.path.sep + 'os.py'):
-                            import_path.insert(0, 'os')
-                        else:
-                            import_path.insert(0, dir_name)
-                    else:
-                        _add_error(
-                            module_context, import_path[-1],
-                            message='Attempted relative import beyond top-level package.'
-                        )
-                        import_path = []
-                # If no path is defined in the module we have no ideas where we
-                # are in the file system. Therefore we cannot know what to do.
-                # In this case we just let the path there and ignore that it's
-                # a relative path. Not sure if that's a good idea.
-            else:
-                # Here we basically rewrite the level to 0.
-                base = tuple(base)
-                if level > 1:
-                    base = base[:-level + 1]
-
-                import_path = base + tuple(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):
-        sys_path_mod = self._evaluator.get_sys_path() \
-                       + sys_path.check_sys_path_modifications(self.module_context)
-
-        if self.import_path and self.file_path is not None \
-                and self._evaluator.environment.version_info.major == 2:
-            # Python2 uses an old strange way of importing relative imports.
-            sys_path_mod.append(force_unicode(os.path.dirname(self.file_path)))
-
-        return sys_path_mod
-
-    def follow(self):
-        if not self.import_path:
-            return NO_CONTEXTS
-        return self._do_import(self.import_path, self.sys_path_with_modifications())
-
-    def _do_import(self, import_path, sys_path):
-        """
-        This method is very similar to importlib's `_gcd_import`.
-        """
-        import_parts = [
-            force_unicode(i.value if isinstance(i, tree.Name) else i)
-            for i in import_path
-        ]
-
-        # Handle "magic" Flask extension imports:
-        # ``flask.ext.foo`` is really ``flask_foo`` or ``flaskext.foo``.
-        if len(import_path) > 2 and import_parts[:2] == ['flask', 'ext']:
-            # New style.
-            ipath = ('flask_' + str(import_parts[2]),) + import_path[3:]
-            modules = self._do_import(ipath, sys_path)
-            if modules:
-                return modules
-            else:
-                # Old style
-                return self._do_import(('flaskext',) + import_path[2:], sys_path)
-
-        module_name = '.'.join(import_parts)
-        try:
-            return ContextSet(self._evaluator.module_cache.get(module_name))
-        except KeyError:
-            pass
-
-        if len(import_path) > 1:
-            # This is a recursive way of importing that works great with
-            # the module cache.
-            bases = self._do_import(import_path[:-1], sys_path)
-            if not bases:
-                return NO_CONTEXTS
-            # We can take the first element, because only the os special
-            # case yields multiple modules, which is not important for
-            # further imports.
-            parent_module = list(bases)[0]
-
-            # 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``.
-            if import_parts == ['os', 'path']:
-                return parent_module.py__getattribute__('path')
-
-            try:
-                method = parent_module.py__path__
-            except AttributeError:
-                # The module is not a package.
-                _add_error(self.module_context, import_path[-1])
-                return NO_CONTEXTS
-            else:
-                paths = method()
-                debug.dbg('search_module %s in paths %s', module_name, paths)
-                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]
-                    code, module_path, is_pkg = self._evaluator.compiled_subprocess.get_module_info(
-                        string=import_parts[-1],
-                        path=path,
-                        full_name=module_name
-                    )
-                    if module_path is not None:
-                        break
-                else:
-                    _add_error(self.module_context, import_path[-1])
-                    return NO_CONTEXTS
-        else:
-            debug.dbg('search_module %s in %s', import_parts[-1], self.file_path)
-            # Override the sys.path. It works only good that way.
-            # Injecting the path directly into `find_module` did not work.
-            code, module_path, is_pkg = self._evaluator.compiled_subprocess.get_module_info(
-                string=import_parts[-1],
-                full_name=module_name,
-                sys_path=sys_path,
-            )
-            if module_path is None:
-                # The module is not a package.
-                _add_error(self.module_context, import_path[-1])
-                return NO_CONTEXTS
-
-        module = _load_module(
-            self._evaluator, module_path, code, sys_path,
-            module_name=module_name,
-            safe_module_name=True,
-        )
-
-        if module is None:
-            # The file might raise an ImportError e.g. and therefore not be
-            # importable.
-            return NO_CONTEXTS
-
-        return ContextSet(module)
-
-    def _generate_name(self, name, in_module=None):
-        # Create a pseudo import to be able to follow them.
-        if in_module is None:
-            return ImportName(self.module_context, name)
-        return SubModuleName(in_module, name)
-
-    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.
-        """
-        sub = self._evaluator.compiled_subprocess
-
-        names = []
-        # add builtin module names
-        if search_path is None and in_module is None:
-            names += [self._generate_name(name) for name in sub.get_builtin_module_names()]
-
-        if search_path is None:
-            search_path = self.sys_path_with_modifications()
-
-        for name in sub.list_module_names(search_path):
-            names.append(self._generate_name(name, in_module=in_module))
-        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.
-        """
-        from jedi.evaluate.context import ModuleContext
-        from jedi.evaluate.context.namespace import ImplicitNamespaceContext
-        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(self._generate_name(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])
-
-            for context in self.follow():
-                # Non-modules are not completable.
-                if context.api_type != 'module':  # not a module
-                    continue
-                # namespace packages
-                if isinstance(context, ModuleContext) and context.py__file__().endswith('__init__.py'):
-                    paths = context.py__path__()
-                    names += self._get_module_names(paths, in_module=context)
-
-                # implicit namespace packages
-                elif isinstance(context, ImplicitNamespaceContext):
-                    paths = context.paths
-                    names += self._get_module_names(paths, in_module=context)
-
-                if only_modules:
-                    # In the case of an import like `from x.` we don't need to
-                    # add all the variables.
-                    if ('os',) == self.str_import_path and not self.level:
-                        # os.path is a hardcoded exception, because it's a
-                        # ``sys.modules`` modification.
-                        names.append(self._generate_name('path', context))
-
-                    continue
-
-                for filter in context.get_filters(search_global=False):
-                    names += filter.values()
-        else:
-            # Empty import path=completion after import
-            if not self.level:
-                names += self._get_module_names()
-
-            if self.file_path is not None:
-                path = os.path.abspath(self.file_path)
-                for i in range(self.level - 1):
-                    path = os.path.dirname(path)
-                names += self._get_module_names([path])
-
-        return names
-
-
-def _load_module(evaluator, path=None, code=None, sys_path=None,
-                 module_name=None, safe_module_name=False):
-    try:
-        return evaluator.module_cache.get(module_name)
-    except KeyError:
-        pass
-    try:
-        return evaluator.module_cache.get_from_path(path)
-    except KeyError:
-        pass
-
-    if isinstance(path, ImplicitNSInfo):
-        from jedi.evaluate.context.namespace import ImplicitNamespaceContext
-        module = ImplicitNamespaceContext(
-            evaluator,
-            fullname=path.name,
-            paths=path.paths,
-        )
-    else:
-        if sys_path is None:
-            sys_path = evaluator.get_sys_path()
-
-        dotted_path = path and dotted_from_fs_path(path, sys_path)
-        if path is not None and path.endswith(('.py', '.zip', '.egg')) \
-                and dotted_path not in settings.auto_import_modules:
-
-            module_node = evaluator.parse(
-                code=code, path=path, cache=True, diff_cache=True,
-                cache_path=settings.cache_directory)
-
-            from jedi.evaluate.context import ModuleContext
-            module = ModuleContext(
-                evaluator, module_node,
-                path=path,
-                code_lines=get_cached_code_lines(evaluator.grammar, path),
-            )
-        else:
-            module = compiled.load_module(evaluator, path=path, sys_path=sys_path)
-
-    if module is not None and module_name is not None:
-        add_module_to_cache(evaluator, module_name, module, safe=safe_module_name)
-
-    return module
-
-
-def add_module_to_cache(evaluator, module_name, module, safe=False):
-    if not safe and '.' not in module_name:
-        # We cannot add paths with dots, because that would collide with
-        # the sepatator dots for nested packages. Therefore we return
-        # `__main__` in ModuleWrapper.py__name__(), which is similar to
-        # Python behavior.
-        return
-    evaluator.module_cache.add(module, module_name)
-
-
-def get_modules_containing_name(evaluator, modules, name):
-    """
-    Search a name in the directories of modules.
-    """
-    def check_directories(paths):
-        for p in paths:
-            if p is not None:
-                # We need abspath, because the seetings paths might not already
-                # have been converted to absolute paths.
-                d = os.path.dirname(os.path.abspath(p))
-                for file_name in os.listdir(d):
-                    path = os.path.join(d, file_name)
-                    if file_name.endswith('.py'):
-                        yield path
-
-    def check_fs(path):
-        with open(path, 'rb') as f:
-            code = python_bytes_to_unicode(f.read(), errors='replace')
-            if name in code:
-                e_sys_path = evaluator.get_sys_path()
-                module_name = sys_path.dotted_path_in_sys_path(e_sys_path, path)
-                module = _load_module(
-                    evaluator, path, code,
-                    sys_path=e_sys_path, module_name=module_name
-                )
-                return module
-
-    # skip non python modules
-    used_mod_paths = set()
-    for m in modules:
-        try:
-            path = m.py__file__()
-        except AttributeError:
-            pass
-        else:
-            used_mod_paths.add(path)
-        yield m
-
-    if not settings.dynamic_params_for_other_modules:
-        return
-
-    additional = set(os.path.abspath(p) for p in settings.additional_dynamic_modules)
-    # Check the directories of used modules.
-    paths = (additional | set(check_directories(used_mod_paths))) \
-            - used_mod_paths
-
-    # Sort here to make issues less random.
-    for p in sorted(paths):
-        # make testing easier, sort it - same results on every interpreter
-        m = check_fs(p)
-        if m is not None and not isinstance(m, compiled.CompiledObject):
-            yield m

jedi/evaluate/jedi_typing.py

@@ -1,100 +0,0 @@
-"""
-This module is not intended to be used in jedi, rather it will be fed to the
-jedi-parser to replace classes in the typing module
-"""
-
-try:
-    from collections import abc
-except ImportError:
-    # python 2
-    import collections as abc
-
-
-def factory(typing_name, indextypes):
-    class Iterable(abc.Iterable):
-        def __iter__(self):
-            while True:
-                yield indextypes[0]()
-
-    class Iterator(Iterable, abc.Iterator):
-        def next(self):
-            """ needed for python 2 """
-            return self.__next__()
-
-        def __next__(self):
-            return indextypes[0]()
-
-    class Sequence(abc.Sequence):
-        def __getitem__(self, index):
-            return indextypes[0]()
-
-    class MutableSequence(Sequence, abc.MutableSequence):
-        pass
-
-    class List(MutableSequence, list):
-        pass
-
-    class Tuple(Sequence, tuple):
-        def __getitem__(self, index):
-            if indextypes[1] == Ellipsis:
-                # https://www.python.org/dev/peps/pep-0484/#the-typing-module
-                # Tuple[int, ...] means a tuple of ints of indetermined length
-                return indextypes[0]()
-            else:
-                return indextypes[index]()
-
-    class AbstractSet(Iterable, abc.Set):
-        pass
-
-    class MutableSet(AbstractSet, abc.MutableSet):
-        pass
-
-    class KeysView(Iterable, abc.KeysView):
-        pass
-
-    class ValuesView(abc.ValuesView):
-        def __iter__(self):
-            while True:
-                yield indextypes[1]()
-
-    class ItemsView(abc.ItemsView):
-        def __iter__(self):
-            while True:
-                yield (indextypes[0](), indextypes[1]())
-
-    class Mapping(Iterable, abc.Mapping):
-        def __getitem__(self, item):
-            return indextypes[1]()
-
-        def keys(self):
-            return KeysView()
-
-        def values(self):
-            return ValuesView()
-
-        def items(self):
-            return ItemsView()
-
-    class MutableMapping(Mapping, abc.MutableMapping):
-        pass
-
-    class Dict(MutableMapping, dict):
-        pass
-
-    dct = {
-        "Sequence": Sequence,
-        "MutableSequence": MutableSequence,
-        "List": List,
-        "Iterable": Iterable,
-        "Iterator": Iterator,
-        "AbstractSet": AbstractSet,
-        "MutableSet": MutableSet,
-        "Mapping": Mapping,
-        "MutableMapping": MutableMapping,
-        "Tuple": Tuple,
-        "KeysView": KeysView,
-        "ItemsView": ItemsView,
-        "ValuesView": ValuesView,
-        "Dict": Dict,
-    }
-    return dct[typing_name]

jedi/evaluate/lazy_context.py

@@ -1,61 +0,0 @@
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
-
-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):
-        old, self._context.predefined_names = \
-            self._context.predefined_names, self._predefined_names
-        try:
-            return self._context.eval_node(self.data)
-        finally:
-            self._context.predefined_names = old
-
-
-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/param.py

@@ -1,194 +0,0 @@
-from collections import defaultdict
-
-from jedi.evaluate.utils import PushBackIterator
-from jedi.evaluate import analysis
-from jedi.evaluate.lazy_context import LazyKnownContext, \
-    LazyTreeContext, LazyUnknownContext
-from jedi.evaluate import docstrings
-from jedi.evaluate import pep0484
-from jedi.evaluate.context import iterable
-
-
-def _add_argument_issue(parent_context, error_name, lazy_context, message):
-    if isinstance(lazy_context, LazyTreeContext):
-        node = lazy_context.data
-        if node.parent.type == 'argument':
-            node = node.parent
-        analysis.add(parent_context, error_name, node, message)
-
-
-class ExecutedParam(object):
-    """Fake a param and give it values."""
-    def __init__(self, execution_context, param_node, lazy_context):
-        self._execution_context = execution_context
-        self._param_node = param_node
-        self._lazy_context = lazy_context
-        self.string_name = param_node.name.value
-
-    def infer(self):
-        pep0484_hints = pep0484.infer_param(self._execution_context, self._param_node)
-        doc_params = docstrings.infer_param(self._execution_context, self._param_node)
-        if pep0484_hints or doc_params:
-            return pep0484_hints | doc_params
-
-        return self._lazy_context.infer()
-
-    @property
-    def var_args(self):
-        return self._execution_context.var_args
-
-    def __repr__(self):
-        return '<%s: %s>' % (self.__class__.__name__, self.string_name)
-
-
-def get_params(execution_context, var_args):
-    result_params = []
-    param_dict = {}
-    funcdef = execution_context.tree_node
-    parent_context = execution_context.parent_context
-
-    for param in funcdef.get_params():
-        param_dict[param.name.value] = param
-    unpacked_va = list(var_args.unpack(funcdef))
-    var_arg_iterator = PushBackIterator(iter(unpacked_va))
-
-    non_matching_keys = defaultdict(lambda: [])
-    keys_used = {}
-    keys_only = False
-    had_multiple_value_error = False
-    for param in funcdef.get_params():
-        # The value and key can both be null. There, the defaults apply.
-        # args / kwargs will just be empty arrays / dicts, respectively.
-        # Wrong value count is just ignored. If you try to test cases that are
-        # not allowed in Python, Jedi will maybe not show any completions.
-        key, argument = next(var_arg_iterator, (None, None))
-        while key is not None:
-            keys_only = True
-            try:
-                key_param = param_dict[key]
-            except KeyError:
-                non_matching_keys[key] = argument
-            else:
-                if key in keys_used:
-                    had_multiple_value_error = True
-                    m = ("TypeError: %s() got multiple values for keyword argument '%s'."
-                         % (funcdef.name, key))
-                    for node in var_args.get_calling_nodes():
-                        analysis.add(parent_context, 'type-error-multiple-values',
-                                     node, message=m)
-                else:
-                    keys_used[key] = ExecutedParam(execution_context, key_param, argument)
-            key, argument = next(var_arg_iterator, (None, None))
-
-        try:
-            result_params.append(keys_used[param.name.value])
-            continue
-        except KeyError:
-            pass
-
-        if param.star_count == 1:
-            # *args param
-            lazy_context_list = []
-            if argument is not None:
-                lazy_context_list.append(argument)
-                for key, argument in var_arg_iterator:
-                    # Iterate until a key argument is found.
-                    if key:
-                        var_arg_iterator.push_back((key, argument))
-                        break
-                    lazy_context_list.append(argument)
-            seq = iterable.FakeSequence(execution_context.evaluator, u'tuple', lazy_context_list)
-            result_arg = LazyKnownContext(seq)
-        elif param.star_count == 2:
-            # **kwargs param
-            dct = iterable.FakeDict(execution_context.evaluator, dict(non_matching_keys))
-            result_arg = LazyKnownContext(dct)
-            non_matching_keys = {}
-        else:
-            # normal param
-            if argument is None:
-                # No value: Return an empty container
-                if param.default is None:
-                    result_arg = LazyUnknownContext()
-                    if not keys_only:
-                        for node in var_args.get_calling_nodes():
-                            m = _error_argument_count(funcdef, len(unpacked_va))
-                            analysis.add(parent_context, 'type-error-too-few-arguments',
-                                         node, message=m)
-                else:
-                    result_arg = LazyTreeContext(parent_context, param.default)
-            else:
-                result_arg = argument
-
-        result_params.append(ExecutedParam(execution_context, param, result_arg))
-        if not isinstance(result_arg, LazyUnknownContext):
-            keys_used[param.name.value] = result_params[-1]
-
-    if keys_only:
-        # All arguments should be handed over to the next function. It's not
-        # about the values inside, it's about the names. Jedi needs to now that
-        # there's nothing to find for certain names.
-        for k in set(param_dict) - set(keys_used):
-            param = param_dict[k]
-
-            if not (non_matching_keys or had_multiple_value_error or
-                    param.star_count or param.default):
-                # add a warning only if there's not another one.
-                for node in var_args.get_calling_nodes():
-                    m = _error_argument_count(funcdef, len(unpacked_va))
-                    analysis.add(parent_context, 'type-error-too-few-arguments',
-                                 node, message=m)
-
-    for key, lazy_context in non_matching_keys.items():
-        m = "TypeError: %s() got an unexpected keyword argument '%s'." \
-            % (funcdef.name, key)
-        _add_argument_issue(
-            parent_context,
-            'type-error-keyword-argument',
-            lazy_context,
-            message=m
-        )
-
-    remaining_arguments = list(var_arg_iterator)
-    if remaining_arguments:
-        m = _error_argument_count(funcdef, len(unpacked_va))
-        # Just report an error for the first param that is not needed (like
-        # cPython).
-        first_key, lazy_context = remaining_arguments[0]
-        if var_args.get_calling_nodes():
-            # There might not be a valid calling node so check for that first.
-            _add_argument_issue(parent_context, 'type-error-too-many-arguments', lazy_context, message=m)
-    return result_params
-
-
-def _error_argument_count(funcdef, actual_count):
-    params = funcdef.get_params()
-    default_arguments = sum(1 for p in params if p.default or p.star_count)
-
-    if default_arguments == 0:
-        before = 'exactly '
-    else:
-        before = 'from %s to ' % (len(params) - default_arguments)
-    return ('TypeError: %s() takes %s%s arguments (%s given).'
-            % (funcdef.name, before, len(params), actual_count))
-
-
-def _create_default_param(execution_context, param):
-    if param.star_count == 1:
-        result_arg = LazyKnownContext(
-            iterable.FakeSequence(execution_context.evaluator, u'tuple', [])
-        )
-    elif param.star_count == 2:
-        result_arg = LazyKnownContext(
-            iterable.FakeDict(execution_context.evaluator, {})
-        )
-    elif param.default is None:
-        result_arg = LazyUnknownContext()
-    else:
-        result_arg = LazyTreeContext(execution_context.parent_context, param.default)
-    return ExecutedParam(execution_context, param, result_arg)
-
-
-def create_default_params(execution_context, funcdef):
-    return [_create_default_param(execution_context, p)
-            for p in funcdef.get_params()]

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/pep0484.py

@@ -1,330 +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.
-
-The (initial / probably incomplete) implementation todo list for pep-0484:
-v Function parameter annotations with builtin/custom type classes
-v Function returntype annotations with builtin/custom type classes
-v Function parameter annotations with strings (forward reference)
-v Function return type annotations with strings (forward reference)
-v Local variable type hints
-v Assigned types: `Url = str\ndef get(url:Url) -> str:`
-v Type hints in `with` statements
-x Stub files support
-x support `@no_type_check` and `@no_type_check_decorator`
-x support for typing.cast() operator
-x support for type hint comments for functions, `# type: (int, str) -> int`.
-    See comment from Guido https://github.com/davidhalter/jedi/issues/662
-"""
-
-import os
-import re
-
-from parso import ParserSyntaxError, parse, split_lines
-from parso.python import tree
-
-from jedi._compatibility import unicode, force_unicode
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate import compiled
-from jedi.evaluate.base_context import NO_CONTEXTS, ContextSet
-from jedi.evaluate.lazy_context import LazyTreeContext
-from jedi.evaluate.context import ModuleContext
-from jedi.evaluate.helpers import is_string
-from jedi import debug
-from jedi import parser_utils
-
-
-def _evaluate_for_annotation(context, annotation, index=None):
-    """
-    Evaluates a string-node, looking for an annotation
-    If index is not None, the annotation is expected to be a tuple
-    and we're interested in that index
-    """
-    context_set = context.eval_node(_fix_forward_reference(context, annotation))
-    return context_set.execute_evaluated()
-
-
-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'
-                            and len(list(context.py__iter__())) >= index
-        ).py__getitem__(index)
-    return context_set.execute_evaluated()
-
-
-def _fix_forward_reference(context, node):
-    evaled_nodes = context.eval_node(node)
-    if len(evaled_nodes) != 1:
-        debug.warning("Eval'ed typing index %s should lead to 1 object, "
-                      " not %s" % (node, evaled_nodes))
-        return node
-
-    evaled_context = list(evaled_nodes)[0]
-    if is_string(evaled_context):
-        result = _get_forward_reference_node(context, evaled_context.get_safe_value())
-        if result is not None:
-            return result
-
-    return node
-
-
-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):
-    """
-    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 BaseInstanceFunctionExecution
-        if isinstance(execution_context, BaseInstanceFunctionExecution):
-            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.get_root_context(),
-            param_comment
-        )
-    module_context = execution_context.get_root_context()
-    return _evaluate_for_annotation(module_context, annotation)
-
-
-def py__annotations__(funcdef):
-    return_annotation = funcdef.annotation
-    if return_annotation:
-        dct = {'return': return_annotation}
-    else:
-        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 dct
-
-
-@evaluator_method_cache()
-def infer_return_types(function_context):
-    """
-    Infers the type of a function's return value,
-    according to type annotations.
-    """
-    annotation = py__annotations__(function_context.tree_node).get("return", None)
-    if annotation is None:
-        # If there is no Python 3-type annotation, look for a Python 2-type annotation
-        node = function_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_context.get_root_context(),
-            match.group(1).strip()
-        )
-
-    module_context = function_context.get_root_context()
-    return _evaluate_for_annotation(module_context, annotation)
-
-
-_typing_module = None
-_typing_module_code_lines = None
-
-
-def _get_typing_replacement_module(grammar):
-    """
-    The idea is to return our jedi replacement for the PEP-0484 typing module
-    as discussed at https://github.com/davidhalter/jedi/issues/663
-    """
-    global _typing_module, _typing_module_code_lines
-    if _typing_module is None:
-        typing_path = \
-            os.path.abspath(os.path.join(__file__, "../jedi_typing.py"))
-        with open(typing_path) as f:
-            code = unicode(f.read())
-        _typing_module = grammar.parse(code)
-        _typing_module_code_lines = split_lines(code, keepends=True)
-    return _typing_module, _typing_module_code_lines
-
-
-def py__getitem__(context, typ, node):
-    if not typ.get_root_context().name.string_name == "typing":
-        return None
-    # we assume that any class using [] in a module called
-    # "typing" with a name for which we have a replacement
-    # should be replaced by that class. This is not 100%
-    # airtight but I don't have a better idea to check that it's
-    # actually the PEP-0484 typing module and not some other
-    if node.type == "subscriptlist":
-        nodes = node.children[::2]  # skip the commas
-    else:
-        nodes = [node]
-    del node
-
-    nodes = [_fix_forward_reference(context, node) for node in nodes]
-    type_name = typ.name.string_name
-
-    # hacked in Union and Optional, since it's hard to do nicely in parsed code
-    if type_name in ("Union", '_Union'):
-        # In Python 3.6 it's still called typing.Union but it's an instance
-        # called _Union.
-        return ContextSet.from_sets(context.eval_node(node) for node in nodes)
-    if type_name in ("Optional", '_Optional'):
-        # Here we have the same issue like in Union. Therefore we also need to
-        # check for the instance typing._Optional (Python 3.6).
-        return context.eval_node(nodes[0])
-
-    module_node, code_lines = _get_typing_replacement_module(context.evaluator.latest_grammar)
-    typing = ModuleContext(
-        context.evaluator,
-        module_node=module_node,
-        path=None,
-        code_lines=code_lines,
-    )
-    factories = typing.py__getattribute__("factory")
-    assert len(factories) == 1
-    factory = list(factories)[0]
-    assert factory
-    function_body_nodes = factory.tree_node.children[4].children
-    valid_classnames = set(child.name.value
-                           for child in function_body_nodes
-                           if isinstance(child, tree.Class))
-    if type_name not in valid_classnames:
-        return None
-    compiled_classname = compiled.create_simple_object(context.evaluator, type_name)
-
-    from jedi.evaluate.context.iterable import FakeSequence
-    args = FakeSequence(
-        context.evaluator,
-        u'tuple',
-        [LazyTreeContext(context, n) for n in nodes]
-    )
-
-    result = factory.execute_evaluated(compiled_classname, args)
-    return result
-
-
-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)

jedi/evaluate/stdlib.py

@@ -1,343 +0,0 @@
-"""
-Implementations of standard library functions, because it's not possible to
-understand them with Jedi.
-
-To add a new implementation, create a function and add it to the
-``_implemented`` dict at the bottom of this module.
-
-Note that this module exists only to implement very specific functionality in
-the standard library. The usual way to understand the standard library is the
-compiled module that returns the types for C-builtins.
-"""
-import re
-
-import parso
-
-from jedi._compatibility import force_unicode
-from jedi import debug
-from jedi.evaluate.arguments import ValuesArguments
-from jedi.evaluate import analysis
-from jedi.evaluate import compiled
-from jedi.evaluate.context.instance import InstanceFunctionExecution, \
-    AbstractInstanceContext, CompiledInstance, BoundMethod, \
-    AnonymousInstanceFunctionExecution
-from jedi.evaluate.base_context import ContextualizedNode, \
-    NO_CONTEXTS, ContextSet
-from jedi.evaluate.context import ClassContext, ModuleContext
-from jedi.evaluate.context import iterable
-from jedi.evaluate.lazy_context import LazyTreeContext
-from jedi.evaluate.syntax_tree import is_string
-
-# Now this is all part of fake tuples in Jedi. However super doesn't work on
-# __init__ and __new__ doesn't work at all. So adding this to nametuples is
-# just the easiest way.
-_NAMEDTUPLE_INIT = """
-    def __init__(_cls, {arg_list}):
-        'A helper function for namedtuple.'
-        self.__iterable = ({arg_list})
-
-    def __iter__(self):
-        for i in self.__iterable:
-            yield i
-
-    def __getitem__(self, y):
-        return self.__iterable[y]
-
-"""
-
-
-class NotInStdLib(LookupError):
-    pass
-
-
-def execute(evaluator, obj, arguments):
-    if isinstance(obj, BoundMethod):
-        raise NotInStdLib()
-
-    try:
-        obj_name = obj.name.string_name
-    except AttributeError:
-        pass
-    else:
-        if obj.parent_context == evaluator.builtins_module:
-            module_name = 'builtins'
-        elif isinstance(obj.parent_context, ModuleContext):
-            module_name = obj.parent_context.name.string_name
-        else:
-            module_name = ''
-
-        # for now we just support builtin functions.
-        try:
-            func = _implemented[module_name][obj_name]
-        except KeyError:
-            pass
-        else:
-            return func(evaluator, obj, arguments)
-    raise NotInStdLib()
-
-
-def _follow_param(evaluator, arguments, index):
-    try:
-        key, lazy_context = list(arguments.unpack())[index]
-    except IndexError:
-        return NO_CONTEXTS
-    else:
-        return lazy_context.infer()
-
-
-def argument_clinic(string, want_obj=False, want_context=False, want_arguments=False):
-    """
-    Works like Argument Clinic (PEP 436), to validate function params.
-    """
-    clinic_args = []
-    allow_kwargs = False
-    optional = False
-    while string:
-        # Optional arguments have to begin with a bracket. And should always be
-        # at the end of the arguments. This is therefore not a proper argument
-        # clinic implementation. `range()` for exmple allows an optional start
-        # value at the beginning.
-        match = re.match('(?:(?:(\[),? ?|, ?|)(\w+)|, ?/)\]*', string)
-        string = string[len(match.group(0)):]
-        if not match.group(2):  # A slash -> allow named arguments
-            allow_kwargs = True
-            continue
-        optional = optional or bool(match.group(1))
-        word = match.group(2)
-        clinic_args.append((word, optional, allow_kwargs))
-
-    def f(func):
-        def wrapper(evaluator, obj, arguments):
-            debug.dbg('builtin start %s' % obj, color='MAGENTA')
-            result = NO_CONTEXTS
-            try:
-                lst = list(arguments.eval_argument_clinic(clinic_args))
-            except ValueError:
-                pass
-            else:
-                kwargs = {}
-                if want_context:
-                    kwargs['context'] = arguments.context
-                if want_obj:
-                    kwargs['obj'] = obj
-                if want_arguments:
-                    kwargs['arguments'] = arguments
-                result = func(evaluator, *lst, **kwargs)
-            finally:
-                debug.dbg('builtin end: %s', result, color='MAGENTA')
-            return result
-
-        return wrapper
-    return f
-
-
-@argument_clinic('iterator[, default], /')
-def builtins_next(evaluator, iterators, defaults):
-    """
-    TODO this function is currently not used. It's a stab at implementing next
-    in a different way than fake objects. This would be a bit more flexible.
-    """
-    if evaluator.environment.version_info.major == 2:
-        name = 'next'
-    else:
-        name = '__next__'
-
-    context_set = NO_CONTEXTS
-    for iterator in iterators:
-        if isinstance(iterator, AbstractInstanceContext):
-            context_set = ContextSet.from_sets(
-                n.infer()
-                for filter in iterator.get_filters(include_self_names=True)
-                for n in filter.get(name)
-            ).execute_evaluated()
-    if context_set:
-        return context_set
-    return defaults
-
-
-@argument_clinic('object, name[, default], /')
-def builtins_getattr(evaluator, objects, names, defaults=None):
-    # follow the first param
-    for obj in objects:
-        for name in names:
-            if is_string(name):
-                return obj.py__getattribute__(force_unicode(name.get_safe_value()))
-            else:
-                debug.warning('getattr called without str')
-                continue
-    return NO_CONTEXTS
-
-
-@argument_clinic('object[, bases, dict], /')
-def builtins_type(evaluator, objects, bases, dicts):
-    if bases or dicts:
-        # It's a type creation... maybe someday...
-        return NO_CONTEXTS
-    else:
-        return objects.py__class__()
-
-
-class SuperInstance(AbstractInstanceContext):
-    """To be used like the object ``super`` returns."""
-    def __init__(self, evaluator, cls):
-        su = cls.py_mro()[1]
-        super().__init__(evaluator, su and su[0] or self)
-
-
-@argument_clinic('[type[, obj]], /', want_context=True)
-def builtins_super(evaluator, types, objects, context):
-    # TODO make this able to detect multiple inheritance super
-    if isinstance(context, (InstanceFunctionExecution,
-                            AnonymousInstanceFunctionExecution)):
-        su = context.instance.py__class__().py__bases__()
-        return su[0].infer().execute_evaluated()
-    return NO_CONTEXTS
-
-
-@argument_clinic('sequence, /', want_obj=True, want_arguments=True)
-def builtins_reversed(evaluator, sequences, obj, arguments):
-    # While we could do without this variable (just by using sequences), we
-    # want static analysis to work well. Therefore we need to generated the
-    # values again.
-    key, lazy_context = next(arguments.unpack())
-    cn = None
-    if isinstance(lazy_context, LazyTreeContext):
-        # TODO access private
-        cn = ContextualizedNode(lazy_context._context, lazy_context.data)
-    ordered = list(sequences.iterate(cn))
-
-    rev = list(reversed(ordered))
-    # Repack iterator values and then run it the normal way. This is
-    # necessary, because `reversed` is a function and autocompletion
-    # would fail in certain cases like `reversed(x).__iter__` if we
-    # just returned the result directly.
-    seq = iterable.FakeSequence(evaluator, u'list', rev)
-    arguments = ValuesArguments([ContextSet(seq)])
-    return ContextSet(CompiledInstance(evaluator, evaluator.builtins_module, obj, arguments))
-
-
-@argument_clinic('obj, type, /', want_arguments=True)
-def builtins_isinstance(evaluator, objects, types, arguments):
-    bool_results = set()
-    for o in objects:
-        cls = o.py__class__()
-        try:
-            mro_func = cls.py__mro__
-        except AttributeError:
-            # This is temporary. Everything should have a class attribute in
-            # Python?! Maybe we'll leave it here, because some numpy objects or
-            # whatever might not.
-            bool_results = set([True, False])
-            break
-
-        mro = mro_func()
-
-        for cls_or_tup in types:
-            if cls_or_tup.is_class():
-                bool_results.add(cls_or_tup in mro)
-            elif cls_or_tup.name.string_name == 'tuple' \
-                    and cls_or_tup.get_root_context() == evaluator.builtins_module:
-                # Check for tuples.
-                classes = ContextSet.from_sets(
-                    lazy_context.infer()
-                    for lazy_context in cls_or_tup.iterate()
-                )
-                bool_results.add(any(cls in mro for cls in classes))
-            else:
-                _, lazy_context = list(arguments.unpack())[1]
-                if isinstance(lazy_context, LazyTreeContext):
-                    node = lazy_context.data
-                    message = 'TypeError: isinstance() arg 2 must be a ' \
-                              'class, type, or tuple of classes and types, ' \
-                              'not %s.' % cls_or_tup
-                    analysis.add(lazy_context._context, 'type-error-isinstance', node, message)
-
-    return ContextSet.from_iterable(
-        compiled.builtin_from_name(evaluator, force_unicode(str(b)))
-        for b in bool_results
-    )
-
-
-def collections_namedtuple(evaluator, obj, arguments):
-    """
-    Implementation of the namedtuple function.
-
-    This has to be done by processing the namedtuple class template and
-    evaluating the result.
-
-    """
-    collections_context = obj.parent_context
-    _class_template_set = collections_context.py__getattribute__(u'_class_template')
-    if not _class_template_set:
-        # Namedtuples are not supported on Python 2.6, early 2.7, because the
-        # _class_template variable is not defined, there.
-        return NO_CONTEXTS
-
-    # Process arguments
-    # TODO here we only use one of the types, we should use all.
-    # TODO this is buggy, doesn't need to be a string
-    name = list(_follow_param(evaluator, arguments, 0))[0].get_safe_value()
-    _fields = list(_follow_param(evaluator, arguments, 1))[0]
-    if isinstance(_fields, compiled.CompiledObject):
-        fields = _fields.get_safe_value().replace(',', ' ').split()
-    elif isinstance(_fields, iterable.Sequence):
-        fields = [
-            v.get_safe_value()
-            for lazy_context in _fields.py__iter__()
-            for v in lazy_context.infer() if is_string(v)
-        ]
-    else:
-        return NO_CONTEXTS
-
-    def get_var(name):
-        x, = collections_context.py__getattribute__(name)
-        return x.get_safe_value()
-
-    base = next(iter(_class_template_set)).get_safe_value()
-    base += _NAMEDTUPLE_INIT
-    # Build source code
-    code = base.format(
-        typename=name,
-        field_names=tuple(fields),
-        num_fields=len(fields),
-        arg_list=repr(tuple(fields)).replace("u'", "").replace("'", "")[1:-1],
-        repr_fmt=', '.join(get_var(u'_repr_template').format(name=name) for name in fields),
-        field_defs='\n'.join(get_var(u'_field_template').format(index=index, name=name)
-                             for index, name in enumerate(fields))
-    )
-
-    # Parse source code
-    module = evaluator.grammar.parse(code)
-    generated_class = next(module.iter_classdefs())
-    parent_context = ModuleContext(
-        evaluator, module, None,
-        code_lines=parso.split_lines(code, keepends=True),
-    )
-    return ContextSet(ClassContext(evaluator, parent_context, generated_class))
-
-
-@argument_clinic('first, /')
-def _return_first_param(evaluator, firsts):
-    return firsts
-
-
-_implemented = {
-    'builtins': {
-        'getattr': builtins_getattr,
-        'type': builtins_type,
-        'super': builtins_super,
-        'reversed': builtins_reversed,
-        'isinstance': builtins_isinstance,
-    },
-    'copy': {
-        'copy': _return_first_param,
-        'deepcopy': _return_first_param,
-    },
-    'json': {
-        'load': lambda *args: NO_CONTEXTS,
-        'loads': lambda *args: NO_CONTEXTS,
-    },
-    'collections': {
-        'namedtuple': collections_namedtuple,
-    },
-}

jedi/evaluate/syntax_tree.py

@@ -1,659 +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 import compiled
-from jedi.evaluate import pep0484
-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.pep0484 import _evaluate_for_annotation
-from jedi.evaluate.context import ClassContext, FunctionContext
-from jedi.evaluate.context import iterable
-from jedi.evaluate.context import TreeInstance, CompiledInstance
-from jedi.evaluate.finder import NameFinder
-from jedi.evaluate.helpers import is_string, is_literal, is_number, is_compiled
-from jedi.evaluate.compiled.access import COMPARISON_OPERATORS
-
-
-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 = ContextSet()
-    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', element, element.start_pos)
-    evaluator = context.evaluator
-    typ = element.type
-    if typ in ('name', 'number', 'string', 'atom', 'strings'):
-        return eval_atom(context, element)
-    elif typ == 'keyword':
-        # For False/True/None
-        if element.value in ('False', 'True', 'None'):
-            return ContextSet(compiled.builtin_from_name(evaluator, element.value))
-        # else: print e.g. could be evaluated like this in Python 2.7
-        return NO_CONTEXTS
-    elif typ == 'lambdef':
-        return ContextSet(FunctionContext(evaluator, 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 = eval_atom(context, first_child)
-        for trailer in children:
-            if trailer == '**':  # has a power operation.
-                right = context.eval_node(children[1])
-                context_set = _eval_comparison(
-                    evaluator,
-                    context,
-                    context_set,
-                    trailer,
-                    right
-                )
-                break
-            context_set = eval_trailer(context, context_set, trailer)
-
-        if had_await:
-            await_context_set = context_set.py__getattribute__(u"__await__")
-            if not await_context_set:
-                debug.warning('Tried to run py__await__ on context %s', context)
-            context_set = ContextSet()
-            return _py__stop_iteration_returns(await_context_set.execute_evaluated())
-        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 pep0484._evaluate_for_annotation(context, element.children[1])
-    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)
-            return _py__stop_iteration_returns(generators)
-
-        # Generator.send() is not implemented.
-        return NO_CONTEXTS
-    else:
-        return eval_or_test(context, element)
-
-
-def eval_trailer(context, base_contexts, trailer):
-    trailer_op, node = trailer.children[:2]
-    if node == ')':  # `arglist` is optional.
-        node = None
-
-    if trailer_op == '[':
-        trailer_op, node, _ = trailer.children
-
-        # TODO It's kind of stupid to cast this from a context set to a set.
-        foo = set(base_contexts)
-        # special case: PEP0484 typing module, see
-        # https://github.com/davidhalter/jedi/issues/663
-        result = ContextSet()
-        for typ in list(foo):
-            if isinstance(typ, (ClassContext, TreeInstance)):
-                typing_module_types = pep0484.py__getitem__(context, typ, node)
-                if typing_module_types is not None:
-                    foo.remove(typ)
-                    result |= typing_module_types
-
-        return result | base_contexts.get_item(
-            eval_subscript_list(context.evaluator, context, node),
-            ContextualizedNode(context, trailer)
-        )
-    else:
-        debug.dbg('eval_trailer: %s in %s', trailer, base_contexts)
-        if trailer_op == '.':
-            return base_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 base_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':
-        # This is the first global lookup.
-        stmt = tree.search_ancestor(
-            atom, 'expr_stmt', 'lambdef'
-        ) or atom
-        if stmt.type == 'lambdef':
-            stmt = atom
-        return context.py__getattribute__(
-            name_or_str=atom,
-            position=stmt.start_pos,
-            search_global=True
-        )
-
-    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
-    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 == '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):
-            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.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_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 _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 is_compiled(left) and is_compiled(right):
-            # 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_))
-
-        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, CompiledInstance) 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))
-
-    return ContextSet(left, right)
-
-
-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 = \
-        pep0484.find_type_from_comment_hint_assign(context, stmt, name)
-    if pep0484_contexts:
-        return pep0484_contexts
-
-    return eval_expr_stmt(context, stmt, seek_name=name)
-
-
-def tree_name_to_contexts(evaluator, context, tree_name):
-
-    context_set = ContextSet()
-    module_node = context.get_root_context().tree_node
-    if module_node is not None:
-        names = module_node.get_used_names().get(tree_name.value, [])
-        for name in names:
-            expr_stmt = name.parent
-
-            correct_scope = parser_utils.get_parent_scope(name) == context.tree_node
-
-            if expr_stmt.type == "expr_stmt" and expr_stmt.children[1].type == "annassign" and correct_scope:
-                context_set |= _evaluate_for_annotation(context, expr_stmt.children[1].children[1])
-
-    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'):
-            raise ValueError("Should not happen. type: %s", node.type)
-
-    typ = node.type
-    if typ == 'for_stmt':
-        types = pep0484.find_type_from_comment_hint_for(context, node, tree_name)
-        if types:
-            return types
-    if typ == 'with_stmt':
-        types = pep0484.find_type_from_comment_hint_with(context, node, tree_name)
-        if types:
-            return types
-
-    if typ in ('for_stmt', '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()
-    else:
-        raise ValueError("Should not happen. type: %s" % typ)
-    return types
-
-
-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,
-            classdef=node
-        )
-    else:
-        decoratee_context = FunctionContext(
-            context.evaluator,
-            parent_context=context,
-            funcdef=node
-        )
-    initial = values = ContextSet(decoratee_context)
-    for dec in reversed(node.get_decorators()):
-        debug.dbg('decorator: %s %s', dec, values)
-        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):
-            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)
-    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)
-        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 ContextSet()
-        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 NO_CONTEXTS
-
-    # No slices
-    return context.eval_node(index)

jedi/evaluate/usages.py

@@ -1,62 +0,0 @@
-from jedi.evaluate import imports
-from jedi.evaluate.filters import TreeNameDefinition
-from jedi.evaluate.context import ModuleContext
-
-
-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 isinstance(m, ModuleContext))
-
-    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

@@ -0,0 +1,80 @@
+import os
+
+from parso import file_io
+
+
+class AbstractFolderIO(object):
+    def __init__(self, path):
+        self.path = path
+
+    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))
+
+    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(object):
+    def get_parent_folder(self):
+        return FolderIO(os.path.dirname(self.path))
+
+
+class ZipFileIO(file_io.KnownContentFileIO, FileIOFolderMixin):
+    """For .zip and .egg archives"""
+    def __init__(self, path, code, zip_path):
+        super(ZipFileIO, self).__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
+            return None
+
+
+class FileIO(file_io.FileIO, FileIOFolderMixin):
+    pass
+
+
+class KnownContentFileIO(file_io.KnownContentFileIO, FileIOFolderMixin):
+    pass

jedi/inference/__init__.py

@@ -0,0 +1,198 @@
+"""
+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 parso import python_bytes_to_unicode
+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(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_inference_state_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[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.is_analysis = False
+        self.project = project
+        self.access_cache = {}
+        self.allow_descriptor_getattr = 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
+
+    @property
+    @inference_state_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
+    @inference_state_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 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)
+        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, encoding='utf-8',
+                           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 = python_bytes_to_unicode(code, encoding=encoding, 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

@@ -5,8 +5,7 @@ from parso.python import tree
 
 from jedi._compatibility import force_unicode
 from jedi import debug
-from jedi.evaluate.compiled import CompiledObject
-from jedi.evaluate.helpers import is_string
+from jedi.inference.helpers import is_string
 
 
 CODES = {
@@ -59,8 +58,8 @@ class Error(object):
         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)
@@ -86,50 +85,45 @@ def add(node_context, error_name, node, message=None, typ=Error, payload=None):
     # TODO this path is probably not right
     module_context = node_context.get_root_context()
     module_path = module_context.py__file__()
-    instance = typ(error_name, module_path, node.start_pos, message)
-    debug.warning(str(instance), format=False)
-    node_context.evaluator.analysis.append(instance)
+    issue_instance = typ(error_name, module_path, node.start_pos, message)
+    debug.warning(str(issue_instance), format=False)
+    node_context.inference_state.analysis.append(issue_instance)
+    return issue_instance
 
 
 def _check_for_setattr(instance):
     """
     Check if there's any setattr method inside an instance. If so, return True.
     """
-    from jedi.evaluate.context import ModuleContext
     module = instance.get_root_context()
-    if not isinstance(module, ModuleContext):
+    node = module.tree_node
+    if node is None:
+        # If it's a compiled module or doesn't have a tree_node
         return False
 
-    node = module.tree_node
     try:
-        stmts = node.get_used_names()['setattr']
+        stmt_names = node.get_used_names()['setattr']
     except KeyError:
         return False
 
-    return any(node.start_pos < stmt.start_pos < node.end_pos
-               for stmt in stmts)
+    return any(node.start_pos < n.start_pos < node.end_pos
+               # Check if it's a function called setattr.
+               and not (n.parent.type == 'funcdef' and n.parent.name == n)
+               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 AbstractInstanceContext, 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 isinstance(lookup_context, AbstractInstanceContext):
-        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)
 
 
@@ -142,16 +136,20 @@ def _check_for_exception_catch(node_context, jedi_name, exception, payload=None)
     Returns True if the exception was catched.
     """
     def check_match(cls, exception):
-        try:
-            return isinstance(cls, CompiledObject) and cls.is_super_class(exception)
-        except TypeError:
+        if not cls.is_class():
             return False
 
+        for python_cls in exception.mro():
+            if cls.py__name__() == python_cls.__name__ \
+                    and cls.parent_context.is_builtins_module():
+                return True
+        return False
+
     def check_try_for_except(obj, exception):
         # 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):
@@ -161,14 +159,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:
@@ -185,20 +183,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
 
             # 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

@@ -0,0 +1,356 @@
+import re
+
+from parso.python import tree
+
+from jedi._compatibility import zip_longest
+from jedi import debug
+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
+        # CompiledValue). Therefore don't loop infinitely.
+        return
+
+    for typ in types:
+        try:
+            f = typ.py__iter__
+        except AttributeError:
+            pass
+        else:
+            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):
+    """
+    Transforms a function or method with arguments to the signature that is
+    given as an argument clinic notation.
+
+    Argument clinic is part of CPython and used for all the functions that are
+    implemented in C (Python 3.7):
+
+        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)
+            try:
+                args += tuple(_iterate_argument_clinic(
+                    context.inference_state,
+                    arguments,
+                    clinic_args
+                ))
+            except ParamIssue:
+                return NO_VALUES
+            else:
+                return func(context, *args, **kwargs)
+
+        return wrapper
+    return decorator
+
+
+def _iterate_argument_clinic(inference_state, arguments, parameters):
+    """Uses a list with argument clinic information (see PEP 436)."""
+    iterator = PushBackIterator(arguments.unpack())
+    for i, (name, optional, allow_kwargs, stars) in enumerate(parameters):
+        if stars == 1:
+            lazy_values = []
+            for key, argument in iterator:
+                if key is not None:
+                    iterator.push_back((key, argument))
+                    break
+
+                lazy_values.append(argument)
+            yield ValueSet([iterable.FakeTuple(inference_state, lazy_values)])
+            lazy_values
+            continue
+        elif stars == 2:
+            raise NotImplementedError()
+        key, argument = next(iterator, (None, None))
+        if key is not None:
+            debug.warning('Keyword arguments in argument clinic are currently not supported.')
+            raise ParamIssue
+        if argument is None and not optional:
+            debug.warning('TypeError: %s expected at least %s arguments, got %s',
+                          name, len(parameters), i)
+            raise ParamIssue
+
+        value_set = NO_VALUES if argument is None else argument.infer()
+
+        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 type inference of that function.
+            debug.warning('argument_clinic "%s" not resolvable.', name)
+            raise ParamIssue
+        yield value_set
+
+
+def _parse_argument_clinic(string):
+    allow_kwargs = False
+    optional = False
+    while string:
+        # Optional arguments have to begin with a bracket. And should always be
+        # at the end of the arguments. This is therefore not a proper argument
+        # clinic implementation. `range()` for exmple allows an optional start
+        # value at the beginning.
+        match = re.match(r'(?:(?:(\[),? ?|, ?|)(\**\w+)|, ?/)\]*', string)
+        string = string[len(match.group(0)):]
+        if not match.group(2):  # A slash -> allow named arguments
+            allow_kwargs = True
+            continue
+        optional = optional or bool(match.group(1))
+        word = match.group(2)
+        stars = word.count('*')
+        word = word[stars:]
+        yield (word, optional, allow_kwargs, stars)
+        if stars:
+            allow_kwargs = True
+
+
+class _AbstractArgumentsMixin(object):
+    def infer_all(self, funcdef=None):
+        """
+        Inferes all arguments as a support for static analysis
+        (normally Jedi).
+        """
+        for key, lazy_value in self.unpack():
+            types = lazy_value.infer()
+            try_iter_content(types)
+
+    def unpack(self, funcdef=None):
+        raise NotImplementedError
+
+    def get_calling_nodes(self):
+        return []
+
+
+class AbstractArguments(_AbstractArgumentsMixin):
+    context = None
+    argument_node = None
+    trailer = None
+
+
+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 ('*', '**'))):
+        yield 0, arglist
+        return
+
+    iterator = iter(arglist.children)
+    for child in iterator:
+        if child == ',':
+            continue
+        elif child in ('*', '**'):
+            yield len(child.value), next(iterator)
+        elif child.type == 'argument' and \
+                child.children[0] in ('*', '**'):
+            assert len(child.children) == 2
+            yield len(child.children[0].value), child.children[1]
+        else:
+            yield 0, child
+
+
+class TreeArguments(AbstractArguments):
+    def __init__(self, inference_state, context, argument_node, trailer=None):
+        """
+        :param argument_node: May be an argument_node or a list of nodes.
+        """
+        self.argument_node = argument_node
+        self.context = context
+        self._inference_state = inference_state
+        self.trailer = trailer  # Can be None, e.g. in a class definition.
+
+    @classmethod
+    @inference_state_as_method_param_cache()
+    def create_cached(cls, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    def unpack(self, funcdef=None):
+        named_args = []
+        for star_count, el in unpack_arglist(self.argument_node):
+            if star_count == 1:
+                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_value(
+                        [v for v in values if v is not None]
+                    )
+            elif star_count == 2:
+                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
+            else:
+                if el.type == 'argument':
+                    c = el.children
+                    if len(c) == 3:  # Keyword argument.
+                        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._inference_state,
+                            defining_context=self.context,
+                            sync_comp_for_node=sync_comp_for,
+                            entry_node=el.children[0],
+                        )
+                        yield None, LazyKnownValue(comp)
+                else:
+                    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
+
+    def _as_tree_tuple_objects(self):
+        for star_count, argument in unpack_arglist(self.argument_node):
+            default = None
+            if argument.type == 'argument':
+                if len(argument.children) == 3:  # Keyword argument.
+                    argument, default = argument.children[::2]
+            yield argument, default, star_count
+
+    def iter_calling_names_with_star(self):
+        for name, default, star_count in self._as_tree_tuple_objects():
+            # TODO this function is a bit strange. probably refactor?
+            if not star_count or not isinstance(name, tree.Name):
+                continue
+
+            yield TreeNameDefinition(self.context, name)
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.argument_node)
+
+    def get_calling_nodes(self):
+        old_arguments_list = []
+        arguments = self
+
+        while arguments not in old_arguments_list:
+            if not isinstance(arguments, TreeArguments):
+                break
+
+            old_arguments_list.append(arguments)
+            for calling_name in reversed(list(arguments.iter_calling_names_with_star())):
+                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
+                executed_param_name = names[0].get_executed_param_name()
+                arguments = executed_param_name.arguments
+                break
+
+        if arguments.argument_node is not None:
+            return [ContextualizedNode(arguments.context, arguments.argument_node)]
+        if arguments.trailer is not None:
+            return [ContextualizedNode(arguments.context, arguments.trailer)]
+        return []
+
+
+class ValuesArguments(AbstractArguments):
+    def __init__(self, values_list):
+        self._values_list = values_list
+
+    def unpack(self, funcdef=None):
+        for values in self._values_list:
+            yield None, LazyKnownValues(values)
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._values_list)
+
+
+class TreeArgumentsWrapper(_AbstractArgumentsMixin):
+    def __init__(self, arguments):
+        self._wrapped_arguments = arguments
+
+    @property
+    def context(self):
+        return self._wrapped_arguments.context
+
+    @property
+    def argument_node(self):
+        return self._wrapped_arguments.argument_node
+
+    @property
+    def trailer(self):
+        return self._wrapped_arguments.trailer
+
+    def unpack(self, func=None):
+        raise NotImplementedError
+
+    def get_calling_nodes(self):
+        return self._wrapped_arguments.get_calling_nodes()
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._wrapped_arguments)
+
+
+def _iterate_star_args(context, array, input_node, funcdef=None):
+    if not array.py__getattribute__('__iter__'):
+        if funcdef is not None:
+            # TODO this funcdef should not be needed.
+            m = "TypeError: %s() argument after * must be a sequence, not %s" \
+                % (funcdef.name.value, array)
+            analysis.add(context, 'type-error-star', input_node, message=m)
+    try:
+        iter_ = array.py__iter__
+    except AttributeError:
+        pass
+    else:
+        for lazy_value in iter_():
+            yield lazy_value
+
+
+def _star_star_dict(context, array, input_node, funcdef):
+    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.
+        return {}
+    elif isinstance(array, iterable.Sequence) and array.array_type == 'dict':
+        return array.exact_key_items()
+    else:
+        if funcdef is not None:
+            m = "TypeError: %s argument after ** must be a mapping, not %s" \
+                % (funcdef.name.value, array)
+            analysis.add(context, 'type-error-star-star', input_node, message=m)
+        return {}

jedi/inference/base_value.py

@@ -0,0 +1,425 @@
+"""
+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 parso.python.tree import Name
+
+from jedi import debug
+from jedi._compatibility import zip_longest, unicode
+from jedi.parser_utils import clean_scope_docstring
+from jedi.common import BaseValueSet, BaseValue
+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 HelperValueMixin(object):
+    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
+
+    @classmethod
+    @inference_state_as_method_param_cache()
+    def create_cached(cls, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    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
+        for f in self.get_filters(origin_scope=origin_scope):
+            yield f
+        # 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})):
+                for f in c.get_filters():
+                    yield f
+
+    def goto(self, name_or_str, name_context=None, analysis_errors=True):
+        if name_context is None:
+            name_context = self
+        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__(u"__await__")
+        if not await_value_set:
+            debug.warning('Tried to run __await__ on value %s', self)
+        return await_value_set.execute_with_values()
+
+    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
+            ])
+        return self.py__iter__(contextualized_node)
+
+    def is_sub_class_of(self, class_value):
+        for cls in self.py__mro__():
+            if cls.is_same_class(class_value):
+                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 != 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, BaseValue):
+    """
+    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
+
+    @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_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 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 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)
+        return None
+
+    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 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 NotImplementedError('Not all values need to be converted to contexts: %s', self)
+
+    def name(self):
+        raise NotImplementedError
+
+    def py__name__(self):
+        return self.name.string_name
+
+
+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(TreeValue, self).__init__(inference_state, parent_context)
+        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.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, unicode, 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(BaseValueSet):
+    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()]
+
+
+NO_VALUES = ValueSet([])
+
+
+def iterator_to_value_set(func):
+    def wrapper(*args, **kwargs):
+        return ValueSet(func(*args, **kwargs))
+
+    return wrapper

jedi/inference/cache.py

@@ -0,0 +1,124 @@
+"""
+- the popular ``_memoize_default`` works like a typical memoize and returns the
+  default otherwise.
+- ``CachedMetaClass`` uses ``_memoize_default`` to do the same with classes.
+"""
+
+from jedi import debug
+
+_NO_DEFAULT = object()
+_RECURSION_SENTINEL = object()
+
+
+def _memoize_default(default=_NO_DEFAULT, inference_state_is_first_arg=False,
+                     second_arg_is_inference_state=False):
+    """ This is a typical memoization decorator, BUT there is one difference:
+    To prevent recursion it sets defaults.
+
+    Preventing recursion is in this case the much bigger use than speed. I
+    don't think, that there is a big speed difference, but there are many cases
+    where recursion could happen (think about a = b; b = a).
+    """
+    def func(function):
+        def wrapper(obj, *args, **kwargs):
+            # TODO These checks are kind of ugly and slow.
+            if inference_state_is_first_arg:
+                cache = obj.memoize_cache
+            elif second_arg_is_inference_state:
+                cache = args[0].memoize_cache  # needed for meta classes
+            else:
+                cache = obj.inference_state.memoize_cache
+
+            try:
+                memo = cache[function]
+            except KeyError:
+                cache[function] = memo = {}
+
+            key = (obj, args, frozenset(kwargs.items()))
+            if key in memo:
+                return memo[key]
+            else:
+                if default is not _NO_DEFAULT:
+                    memo[key] = default
+                rv = function(obj, *args, **kwargs)
+                memo[key] = rv
+                return rv
+        return wrapper
+
+    return func
+
+
+def inference_state_function_cache(default=_NO_DEFAULT):
+    def decorator(func):
+        return _memoize_default(default=default, inference_state_is_first_arg=True)(func)
+
+    return decorator
+
+
+def inference_state_method_cache(default=_NO_DEFAULT):
+    def decorator(func):
+        return _memoize_default(default=default)(func)
+
+    return decorator
+
+
+def inference_state_as_method_param_cache():
+    def decorator(call):
+        return _memoize_default(second_arg_is_inference_state=True)(call)
+
+    return decorator
+
+
+class CachedMetaClass(type):
+    """
+    This is basically almost the same than the decorator above, it just caches
+    class initializations. Either you do it this way or with decorators, but
+    with decorators you lose class access (isinstance, etc).
+    """
+    @inference_state_as_method_param_cache()
+    def __call__(self, *args, **kwargs):
+        return super(CachedMetaClass, self).__call__(*args, **kwargs)
+
+
+def inference_state_method_generator_cache():
+    """
+    This is a special memoizer. It memoizes generators and also checks for
+    recursion errors and returns no further iterator elemends in that case.
+    """
+    def func(function):
+        def wrapper(obj, *args, **kwargs):
+            cache = obj.inference_state.memoize_cache
+            try:
+                memo = cache[function]
+            except KeyError:
+                cache[function] = memo = {}
+
+            key = (obj, args, frozenset(kwargs.items()))
+
+            if key in memo:
+                actual_generator, cached_lst = memo[key]
+            else:
+                actual_generator = function(obj, *args, **kwargs)
+                cached_lst = []
+                memo[key] = actual_generator, cached_lst
+
+            i = 0
+            while True:
+                try:
+                    next_element = cached_lst[i]
+                    if next_element is _RECURSION_SENTINEL:
+                        debug.warning('Found a generator recursion for %s' % obj)
+                        # This means we have hit a recursion.
+                        return
+                except IndexError:
+                    cached_lst.append(_RECURSION_SENTINEL)
+                    next_element = next(actual_generator, None)
+                    if next_element is None:
+                        cached_lst.pop()
+                        return
+                    cached_lst[-1] = next_element
+                yield next_element
+                i += 1
+        return wrapper
+
+    return func

jedi/inference/compiled/__init__.py

@@ -0,0 +1,68 @@
+from jedi._compatibility import unicode
+from jedi.inference.compiled.value import CompiledValue, CompiledName, \
+    CompiledValueFilter, CompiledValueName, create_from_access_path
+from jedi.inference.base_value import LazyValueWrapper
+
+
+def builtin_from_name(inference_state, string):
+    typing_builtins_module = inference_state.builtins_module
+    if string in ('None', 'True', 'False'):
+        builtins, = typing_builtins_module.non_stub_value_set
+        filter_ = next(builtins.get_filters())
+    else:
+        filter_ = next(typing_builtins_module.get_filters())
+    name, = filter_.get(string)
+    value, = name.infer()
+    return value
+
+
+class ExactValue(LazyValueWrapper):
+    """
+    This class represents exact values, that makes operations like additions
+    and exact boolean values possible, while still being a "normal" stub.
+    """
+    def __init__(self, compiled_value):
+        self.inference_state = compiled_value.inference_state
+        self._compiled_value = compiled_value
+
+    def __getattribute__(self, name):
+        if name in ('get_safe_value', 'execute_operation', 'access_handle',
+                    'negate', 'py__bool__', 'is_compiled'):
+            return getattr(self._compiled_value, name)
+        return super(ExactValue, self).__getattribute__(name)
+
+    def _get_wrapped_value(self):
+        instance, = builtin_from_name(
+            self.inference_state, self._compiled_value.name.string_name).execute_with_values()
+        return instance
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._compiled_value)
+
+
+def create_simple_object(inference_state, 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_value = create_from_access_path(
+        inference_state,
+        inference_state.compiled_subprocess.create_simple_object(obj)
+    )
+    return ExactValue(compiled_value)
+
+
+def get_string_value_set(inference_state):
+    return builtin_from_name(inference_state, u'str').execute_with_values()
+
+
+def load_module(inference_state, 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 = inference_state.compiled_subprocess.load_module(dotted_name=dotted_name, **kwargs)
+    if access_path is None:
+        return None
+    return create_from_access_path(inference_state, access_path)

jedi/inference/compiled/access.py

@@ -1,16 +1,17 @@
+from __future__ import print_function
 import inspect
 import types
 import sys
-from textwrap import dedent
 import operator as op
 from collections import namedtuple
+import warnings
+import re
 
-from jedi import debug
-from jedi._compatibility import unicode, is_py3, is_py34, builtins, \
-    py_version, force_unicode, print_to_stderr
-from jedi.evaluate.compiled.getattr_static import getattr_static
-from jedi.evaluate.utils import dotted_from_fs_path
+from jedi._compatibility import unicode, is_py3, builtins, \
+    py_version, force_unicode
+from jedi.inference.compiled.getattr_static import getattr_static
 
+ALLOWED_GETITEM_TYPES = (str, list, tuple, unicode, bytes, bytearray, dict)
 
 MethodDescriptorType = type(str.replace)
 # These are not considered classes and access is granted even though they have
@@ -33,10 +34,9 @@ NOT_CLASS_TYPES = (
 if is_py3:
     NOT_CLASS_TYPES += (
         types.MappingProxyType,
-        types.SimpleNamespace
+        types.SimpleNamespace,
+        types.DynamicClassAttribute,
     )
-    if is_py34:
-        NOT_CLASS_TYPES += (types.DynamicClassAttribute,)
 
 
 # Those types don't exist in typing.
@@ -46,12 +46,6 @@ WrapperDescriptorType = type(set.__iter__)
 object_class_dict = type.__dict__["__dict__"].__get__(object)
 ClassMethodDescriptorType = type(object_class_dict['__subclasshook__'])
 
-def _a_generator(foo):
-    """Used to have an object to return for generators."""
-    yield 42
-    yield foo
-
-
 _sentinel = object()
 
 # Maps Python syntax to the operator module.
@@ -92,79 +86,58 @@ def safe_getattr(obj, name, default=_sentinel):
             raise
         return default
     else:
-        if type(attr) in ALLOWED_DESCRIPTOR_ACCESS:
+        if isinstance(attr, ALLOWED_DESCRIPTOR_ACCESS):
             # In case of descriptors that have get methods we cannot return
             # it's value, because that would mean code execution.
+            # Since it's an isinstance call, code execution is still possible,
+            # but this is not really a security feature, but much more of a
+            # safety feature. Code execution is basically always possible when
+            # a module is imported. This is here so people don't shoot
+            # themselves in the foot.
             return getattr(obj, name)
     return attr
 
 
 SignatureParam = namedtuple(
     'SignatureParam',
-    'name has_default default has_annotation annotation kind_name'
+    'name has_default default default_string has_annotation annotation annotation_string kind_name'
 )
 
 
-def compiled_objects_cache(attribute_name):
-    def decorator(func):
-        """
-        This decorator caches just the ids, oopposed to caching the object itself.
-        Caching the id has the advantage that an object doesn't need to be
-        hashable.
-        """
-        def wrapper(evaluator, obj, parent_context=None):
-            cache = getattr(evaluator, attribute_name)
-            # Do a very cheap form of caching here.
-            key = id(obj)
-            try:
-                cache[key]
-                return cache[key][0]
-            except KeyError:
-                # TODO wuaaaarrghhhhhhhh
-                if attribute_name == 'mixed_cache':
-                    result = func(evaluator, obj, parent_context)
-                else:
-                    result = func(evaluator, obj)
-                # Need to cache all of them, otherwise the id could be overwritten.
-                cache[key] = result, obj, parent_context
-                return result
-        return wrapper
-
-    return decorator
+def shorten_repr(func):
+    def wrapper(self):
+        r = func(self)
+        if len(r) > 50:
+            r = r[:50] + '..'
+        return r
+    return wrapper
 
 
-def create_access(evaluator, obj):
-    return evaluator.compiled_subprocess.get_or_create_access_handle(obj)
+def create_access(inference_state, obj):
+    return inference_state.compiled_subprocess.get_or_create_access_handle(obj)
 
 
-def load_module(evaluator, path=None, name=None, sys_path=None):
-    if sys_path is None:
-        sys_path = list(evaluator.get_sys_path())
-    if path is not None:
-        dotted_path = dotted_from_fs_path(path, sys_path=sys_path)
-    else:
-        dotted_path = name
-
+def load_module(inference_state, dotted_name, sys_path):
     temp, sys.path = sys.path, sys_path
     try:
-        __import__(dotted_path)
+        __import__(dotted_name)
     except ImportError:
         # If a module is "corrupt" or not really a Python module or whatever.
-        debug.warning('Module %s not importable in path %s.', dotted_path, path)
+        print('Module %s not importable in path %s.' % (dotted_name, sys_path), file=sys.stderr)
         return None
     except Exception:
         # Since __import__ pretty much makes code execution possible, just
         # catch any error here and print it.
         import traceback
-        print_to_stderr("Cannot import:\n%s" % traceback.format_exc())
+        print("Cannot import:\n%s" % traceback.format_exc(), file=sys.stderr)
         return None
     finally:
         sys.path = temp
 
     # Just access the cache after import, because of #59 as well as the very
     # complicated import structure of Python.
-    module = sys.modules[dotted_path]
-    return create_access_path(evaluator, module)
+    module = sys.modules[dotted_name]
+    return create_access_path(inference_state, module)
 
 
 class AccessPath(object):
@@ -181,8 +154,8 @@ class AccessPath(object):
         self.accesses = value
 
 
-def create_access_path(evaluator, obj):
-    access = create_access(evaluator, obj)
+def create_access_path(inference_state, obj):
+    access = create_access(inference_state, obj)
     return AccessPath(access.get_access_path_tuples())
 
 
@@ -190,19 +163,31 @@ def _force_unicode_decorator(func):
     return lambda *args, **kwargs: force_unicode(func(*args, **kwargs))
 
 
+def get_api_type(obj):
+    if inspect.isclass(obj):
+        return u'class'
+    elif inspect.ismodule(obj):
+        return u'module'
+    elif inspect.isbuiltin(obj) or inspect.ismethod(obj) \
+            or inspect.ismethoddescriptor(obj) or inspect.isfunction(obj):
+        return u'function'
+    # Everything else...
+    return u'instance'
+
+
 class DirectObjectAccess(object):
-    def __init__(self, evaluator, obj):
-        self._evaluator = evaluator
+    def __init__(self, inference_state, obj):
+        self._inference_state = inference_state
         self._obj = obj
 
     def __repr__(self):
         return '%s(%s)' % (self.__class__.__name__, self.get_repr())
 
     def _create_access(self, obj):
-        return create_access(self._evaluator, obj)
+        return create_access(self._inference_state, obj)
 
     def _create_access_path(self, obj):
-        return create_access_path(self._evaluator, obj)
+        return create_access_path(self._inference_state, obj)
 
     def py__bool__(self):
         return bool(self._obj)
@@ -213,7 +198,7 @@ class DirectObjectAccess(object):
         except AttributeError:
             return None
 
-    def py__doc__(self, include_call_signature=False):
+    def py__doc__(self):
         return force_unicode(inspect.getdoc(self._obj)) or u''
 
     def py__name__(self):
@@ -236,15 +221,23 @@ class DirectObjectAccess(object):
     def py__mro__accesses(self):
         return tuple(self._create_access_path(cls) for cls in self._obj.__mro__[1:])
 
-    def py__getitem__(self, index):
-        if type(self._obj) not in (str, list, tuple, unicode, bytes, bytearray, dict):
+    def py__getitem__all_values(self):
+        if isinstance(self._obj, dict):
+            return [self._create_access_path(v) for v in self._obj.values()]
+        return self.py__iter__list()
+
+    def py__simple_getitem__(self, index):
+        if type(self._obj) not in ALLOWED_GETITEM_TYPES:
             # Get rid of side effects, we won't call custom `__getitem__`s.
             return None
 
         return self._create_access_path(self._obj[index])
 
     def py__iter__list(self):
-        if type(self._obj) not in (str, list, tuple, unicode, bytes, bytearray, dict):
+        if not hasattr(self._obj, '__getitem__'):
+            return None
+
+        if type(self._obj) not in ALLOWED_GETITEM_TYPES:
             # Get rid of side effects, we won't call custom `__getitem__`s.
             return []
 
@@ -262,7 +255,17 @@ class DirectObjectAccess(object):
     def py__bases__(self):
         return [self._create_access_path(base) for base in self._obj.__bases__]
 
+    def py__path__(self):
+        paths = getattr(self._obj, '__path__', None)
+        # Avoid some weird hacks that would just fail, because they cannot be
+        # used by pickle.
+        if not isinstance(paths, list) \
+                or not all(isinstance(p, (bytes, unicode)) for p in paths):
+            return None
+        return paths
+
     @_force_unicode_decorator
+    @shorten_repr
     def get_repr(self):
         builtins = 'builtins', '__builtin__'
 
@@ -284,9 +287,31 @@ class DirectObjectAccess(object):
     def is_class(self):
         return inspect.isclass(self._obj)
 
+    def is_function(self):
+        return inspect.isfunction(self._obj) or inspect.ismethod(self._obj)
+
+    def is_module(self):
+        return inspect.ismodule(self._obj)
+
+    def is_instance(self):
+        return _is_class_instance(self._obj)
+
     def ismethoddescriptor(self):
         return inspect.ismethoddescriptor(self._obj)
 
+    def get_qualified_names(self):
+        def try_to_get_name(obj):
+            return getattr(obj, '__qualname__', getattr(obj, '__name__', None))
+
+        if self.is_module():
+            return ()
+        name = try_to_get_name(self._obj)
+        if name is None:
+            name = try_to_get_name(type(self._obj))
+            if name is None:
+                return ()
+        return tuple(force_unicode(n) for n in name.split('.'))
+
     def dir(self):
         return list(map(force_unicode, dir(self._obj)))
 
@@ -297,8 +322,23 @@ class DirectObjectAccess(object):
         except TypeError:
             return False
 
-    def is_allowed_getattr(self, name):
+    def is_allowed_getattr(self, name, unsafe=False):
         # TODO this API is ugly.
+        if unsafe:
+            # Unsafe is mostly used to check for __getattr__/__getattribute__.
+            # getattr_static works for properties, but the underscore methods
+            # are just ignored (because it's safer and avoids more code
+            # execution). See also GH #1378.
+
+            # Avoid warnings, see comment in the next function.
+            with warnings.catch_warnings(record=True):
+                warnings.simplefilter("always")
+                try:
+                    return hasattr(self._obj, name), False
+                except Exception:
+                    # Obviously has an attribute (propably a property) that
+                    # gets executed, so just avoid all exceptions here.
+                    return False, False
         try:
             attr, is_get_descriptor = getattr_static(self._obj, name)
         except AttributeError:
@@ -310,36 +350,78 @@ class DirectObjectAccess(object):
                 return True, True
         return True, False
 
-    def getattr(self, name, default=_sentinel):
+    def getattr_paths(self, name, default=_sentinel):
         try:
-            return self._create_access(getattr(self._obj, name))
-        except AttributeError:
-            # Happens e.g. in properties of
-            # PyQt4.QtGui.QStyleOptionComboBox.currentText
-            # -> just set it to None
+            # Make sure no warnings are printed here, this is autocompletion,
+            # warnings should not be shown. See also GH #1383.
+            with warnings.catch_warnings(record=True):
+                warnings.simplefilter("always")
+                return_obj = getattr(self._obj, name)
+        except Exception as e:
             if default is _sentinel:
-                raise
-            return self._create_access(default)
+                if isinstance(e, AttributeError):
+                    # Happens e.g. in properties of
+                    # PyQt4.QtGui.QStyleOptionComboBox.currentText
+                    # -> just set it to None
+                    raise
+                # Just in case anything happens, return an AttributeError. It
+                # should not crash.
+                raise AttributeError
+            return_obj = default
+        access = self._create_access(return_obj)
+        if inspect.ismodule(return_obj):
+            return [access]
+
+        try:
+            module = return_obj.__module__
+        except AttributeError:
+            pass
+        else:
+            if module is not None:
+                try:
+                    __import__(module)
+                    # For some modules like _sqlite3, the __module__ for classes is
+                    # different, in this case it's sqlite3. So we have to try to
+                    # load that "original" module, because it's not loaded yet. If
+                    # we don't do that, we don't really have a "parent" module and
+                    # we would fall back to builtins.
+                except ImportError:
+                    pass
+
+        module = inspect.getmodule(return_obj)
+        if module is None:
+            module = inspect.getmodule(type(return_obj))
+            if module is None:
+                module = builtins
+        return [self._create_access(module), access]
 
     def get_safe_value(self):
-        if type(self._obj) in (bool, bytes, float, int, str, unicode, slice):
+        if type(self._obj) in (bool, bytes, float, int, str, unicode, slice) or self._obj is None:
             return self._obj
         raise ValueError("Object is type %s and not simple" % type(self._obj))
 
     def get_api_type(self):
-        obj = self._obj
-        if self.is_class():
-            return u'class'
-        elif inspect.ismodule(obj):
-            return u'module'
-        elif inspect.isbuiltin(obj) or inspect.ismethod(obj) \
-                or inspect.ismethoddescriptor(obj) or inspect.isfunction(obj):
-            return u'function'
-        # Everything else...
-        return u'instance'
+        return get_api_type(self._obj)
+
+    def get_array_type(self):
+        if isinstance(self._obj, dict):
+            return 'dict'
+        return None
+
+    def get_key_paths(self):
+        def iter_partial_keys():
+            # We could use list(keys()), but that might take a lot more memory.
+            for (i, k) in enumerate(self._obj.keys()):
+                # Limit key listing at some point. This is artificial, but this
+                # way we don't get stalled because of slow completions
+                if i > 50:
+                    break
+                yield k
+
+        return [self._create_access_path(k) for k in iter_partial_keys()]
 
     def get_access_path_tuples(self):
-        accesses = [create_access(self._evaluator, o) for o in self._get_objects_path()]
+        accesses = [create_access(self._inference_state, o) for o in self._get_objects_path()]
         return [(access.py__name__(), access) for access in accesses]
 
     def _get_objects_path(self):
@@ -366,7 +448,6 @@ class DirectObjectAccess(object):
                     yield builtins
                 else:
                     try:
-                        # TODO use sys.modules, __module__ can be faked.
                         yield sys.modules[imp_plz]
                     except KeyError:
                         # __module__ can be something arbitrary that doesn't exist.
@@ -379,10 +460,45 @@ class DirectObjectAccess(object):
         op = _OPERATORS[operator]
         return self._create_access_path(op(self._obj, other_access._obj))
 
+    def get_annotation_name_and_args(self):
+        """
+        Returns Tuple[Optional[str], Tuple[AccessPath, ...]]
+        """
+        if sys.version_info < (3, 5):
+            return None, ()
+
+        name = None
+        args = ()
+        if safe_getattr(self._obj, '__module__', default='') == 'typing':
+            m = re.match(r'typing.(\w+)\[', repr(self._obj))
+            if m is not None:
+                name = m.group(1)
+
+                import typing
+                if sys.version_info >= (3, 8):
+                    args = typing.get_args(self._obj)
+                else:
+                    args = safe_getattr(self._obj, '__args__', default=None)
+        return name, tuple(self._create_access_path(arg) for arg in args)
+
     def needs_type_completions(self):
         return inspect.isclass(self._obj) and self._obj != type
 
     def get_signature_params(self):
+        return [
+            SignatureParam(
+                name=p.name,
+                has_default=p.default is not p.empty,
+                default=self._create_access_path(p.default),
+                default_string=repr(p.default),
+                has_annotation=p.annotation is not p.empty,
+                annotation=self._create_access_path(p.annotation),
+                annotation_string=str(p.annotation),
+                kind_name=str(p.kind)
+            ) for p in self._get_signature().parameters.values()
+        ]
+
+    def _get_signature(self):
         obj = self._obj
         if py_version < 33:
             raise ValueError("inspect.signature was introduced in 3.3")
@@ -403,38 +519,43 @@ class DirectObjectAccess(object):
                 raise ValueError
 
         try:
-            signature = inspect.signature(obj)
+            return inspect.signature(obj)
         except (RuntimeError, TypeError):
             # Reading the code of the function in Python 3.6 implies there are
             # at least these errors that might occur if something is wrong with
             # the signature. In that case we just want a simple escape for now.
             raise ValueError
-        return [
-            SignatureParam(
-                name=p.name,
-                has_default=p.default is not p.empty,
-                default=self._create_access_path(p.default),
-                has_annotation=p.annotation is not p.empty,
-                annotation=self._create_access_path(p.annotation),
-                kind_name=str(p.kind)
-            ) for p in signature.parameters.values()
-        ]
+
+    def get_return_annotation(self):
+        try:
+            o = self._obj.__annotations__.get('return')
+        except AttributeError:
+            return None
+
+        if o is None:
+            return None
+
+        try:
+            # Python 2 doesn't have typing.
+            import typing
+        except ImportError:
+            pass
+        else:
+            try:
+                o = typing.get_type_hints(self._obj).get('return')
+            except Exception:
+                pass
+
+        return self._create_access_path(o)
 
     def negate(self):
         return self._create_access_path(-self._obj)
 
-    def dict_values(self):
-        return [self._create_access_path(v) for v in self._obj.values()]
-
-    def is_super_class(self, exception):
-        return issubclass(exception, self._obj)
-
     def get_dir_infos(self):
         """
         Used to return a couple of infos that are needed when accessing the sub
         objects of an objects
         """
-        # TODO is_allowed_getattr might raise an AttributeError
         tuples = dict(
             (force_unicode(name), self.is_allowed_getattr(name))
             for name in self.dir()
@@ -450,41 +571,3 @@ def _is_class_instance(obj):
         return False
     else:
         return cls != type and not issubclass(cls, NOT_CLASS_TYPES)
-
-
-if py_version >= 35:
-    exec(compile(dedent("""
-        async def _coroutine(): pass
-        _coroutine = _coroutine()
-        CoroutineType = type(_coroutine)
-        _coroutine.close()  # Prevent ResourceWarning
-    """), 'blub', 'exec'))
-    _coroutine_wrapper = _coroutine.__await__()
-else:
-    _coroutine = None
-    _coroutine_wrapper = None
-
-if py_version >= 36:
-    exec(compile(dedent("""
-        async def _async_generator():
-            yield
-        _async_generator = _async_generator()
-        AsyncGeneratorType = type(_async_generator)
-    """), 'blub', 'exec'))
-else:
-    _async_generator = None
-
-class _SPECIAL_OBJECTS(object):
-    FUNCTION_CLASS = types.FunctionType
-    METHOD_CLASS = type(DirectObjectAccess.py__bool__)
-    MODULE_CLASS = types.ModuleType
-    GENERATOR_OBJECT = _a_generator(1.0)
-    BUILTINS = builtins
-    COROUTINE = _coroutine
-    COROUTINE_WRAPPER = _coroutine_wrapper
-    ASYNC_GENERATOR = _async_generator
-
-
-def get_special_object(evaluator, identifier):
-    obj = getattr(_SPECIAL_OBJECTS, identifier)
-    return create_access_path(evaluator, obj)

jedi/inference/compiled/getattr_static.py

@@ -46,9 +46,9 @@ def _shadowed_dict_newstyle(klass):
         except KeyError:
             pass
         else:
-            if not (type(class_dict) is types.GetSetDescriptorType and
-                    class_dict.__name__ == "__dict__" and
-                    class_dict.__objclass__ is entry):
+            if not (type(class_dict) is types.GetSetDescriptorType
+                    and class_dict.__name__ == "__dict__"
+                    and class_dict.__objclass__ is entry):
                 return class_dict
     return _sentinel
 

jedi/inference/compiled/mixed.py

@@ -0,0 +1,294 @@
+"""
+Used only for REPL Completion.
+"""
+
+import inspect
+import os
+import sys
+
+from jedi.parser_utils import get_cached_code_lines
+
+from jedi._compatibility import unwrap
+from jedi import settings
+from jedi.cache import memoize_method
+from jedi.inference import compiled
+from jedi.file_io import FileIO
+from jedi.inference.names import NameWrapper
+from jedi.inference.base_value import ValueSet, ValueWrapper, NO_VALUES
+from jedi.inference.value import ModuleValue
+from jedi.inference.cache import inference_state_function_cache, \
+    inference_state_method_cache
+from jedi.inference.compiled.access import ALLOWED_GETITEM_TYPES, get_api_type
+from jedi.inference.gradual.conversion import to_stub
+from jedi.inference.context import CompiledContext, CompiledModuleContext, \
+    TreeContextMixin
+
+_sentinel = object()
+
+
+class MixedObject(ValueWrapper):
+    """
+    A ``MixedObject`` is used in two ways:
+
+    1. It uses the default logic of ``parser.python.tree`` objects,
+    2. except for getattr calls and signatures. The names dicts are generated
+       in a fashion like ``CompiledValue``.
+
+    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 CompiledValue 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_value, tree_value):
+        super(MixedObject, self).__init__(tree_value)
+        self.compiled_value = compiled_value
+        self.access_handle = compiled_value.access_handle
+
+    def get_filters(self, *args, **kwargs):
+        yield MixedObjectFilter(
+            self.inference_state, self.compiled_value, self._wrapped_value)
+
+    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_value.get_signatures()
+
+    @inference_state_method_cache(default=NO_VALUES)
+    def py__call__(self, arguments):
+        # Fallback to the wrapped value if to stub returns no values.
+        values = to_stub(self._wrapped_value)
+        if not values:
+            values = self._wrapped_value
+        return values.py__call__(arguments)
+
+    def get_safe_value(self, default=_sentinel):
+        if default is _sentinel:
+            return self.compiled_value.get_safe_value()
+        else:
+            return self.compiled_value.get_safe_value(default)
+
+    def py__simple_getitem__(self, index):
+        python_object = self.compiled_value.access_handle.access._obj
+        if type(python_object) in ALLOWED_GETITEM_TYPES:
+            return self.compiled_value.py__simple_getitem__(index)
+        return self._wrapped_value.py__simple_getitem__(index)
+
+    def _as_context(self):
+        if self.parent_context is None:
+            return MixedModuleContext(self)
+        return MixedContext(self)
+
+    def __repr__(self):
+        return '<%s: %s; %s>' % (
+            type(self).__name__,
+            self.access_handle.get_repr(),
+            self._wrapped_value,
+        )
+
+
+class MixedContext(CompiledContext, TreeContextMixin):
+    @property
+    def compiled_value(self):
+        return self._value.compiled_value
+
+
+class MixedModuleContext(CompiledModuleContext, MixedContext):
+    pass
+
+
+class MixedName(NameWrapper):
+    """
+    The ``CompiledName._compiled_value`` is our MixedObject.
+    """
+    def __init__(self, wrapped_name, parent_tree_value):
+        super(MixedName, self).__init__(wrapped_name)
+        self._parent_tree_value = parent_tree_value
+
+    @property
+    def start_pos(self):
+        values = list(self.infer())
+        if not values:
+            # This means a start_pos that doesn't exist (compiled objects).
+            return 0, 0
+        return values[0].name.start_pos
+
+    @memoize_method
+    def infer(self):
+        compiled_value = self._wrapped_name.infer_compiled_value()
+        tree_value = self._parent_tree_value
+        if tree_value.is_instance() or tree_value.is_class():
+            tree_values = tree_value.py__getattribute__(self.string_name)
+            if compiled_value.is_function():
+                return ValueSet({MixedObject(compiled_value, v) for v in tree_values})
+
+        module_context = tree_value.get_root_context()
+        return _create(self._inference_state, compiled_value, module_context)
+
+
+class MixedObjectFilter(compiled.CompiledValueFilter):
+    def __init__(self, inference_state, compiled_value, tree_value):
+        super(MixedObjectFilter, self).__init__(inference_state, compiled_value)
+        self._tree_value = tree_value
+
+    def _create_name(self, name):
+        return MixedName(
+            super(MixedObjectFilter, self)._create_name(name),
+            self._tree_value,
+        )
+
+
+@inference_state_function_cache()
+def _load_module(inference_state, path):
+    return inference_state.parse(
+        path=path,
+        cache=True,
+        diff_cache=settings.fast_parser,
+        cache_path=settings.cache_directory
+    ).get_root_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:
+        try:
+            python_object = unwrap(python_object)
+        except ValueError:
+            # Can return a ValueError when it wraps around
+            pass
+
+    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(inference_state, 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(inference_state, 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(inference_state.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(inference_state.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
+
+
+@inference_state_function_cache()
+def _create(inference_state, compiled_value, module_context):
+    # TODO accessing this is bad, but it probably doesn't matter that much,
+    # because we're working with interpreteters only here.
+    python_object = compiled_value.access_handle.access._obj
+    result = _find_syntax_node_name(inference_state, 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 ValueSet({compiled_value})
+
+        tree_values = to_stub(compiled_value)
+        if not tree_values:
+            return ValueSet({compiled_value})
+    else:
+        module_node, tree_node, file_io, code_lines = result
+
+        if module_context is None or module_context.tree_node != module_node:
+            root_compiled_value = compiled_value.get_root_context().get_value()
+            # TODO this __name__ might be wrong.
+            name = root_compiled_value.py__name__()
+            string_names = tuple(name.split('.'))
+            module_value = ModuleValue(
+                inference_state, module_node,
+                file_io=file_io,
+                string_names=string_names,
+                code_lines=code_lines,
+                is_package=root_compiled_value.is_package(),
+            )
+            if name is not None:
+                inference_state.module_cache.add(string_names, ValueSet([module_value]))
+            module_context = module_value.as_context()
+
+        tree_values = ValueSet({module_context.create_value(tree_node)})
+        if tree_node.type == 'classdef':
+            if not compiled_value.is_class():
+                # Is an instance, not a class.
+                tree_values = tree_values.execute_with_values()
+
+    return ValueSet(
+        MixedObject(compiled_value, tree_value=tree_value)
+        for tree_value in tree_values
+    )

jedi/inference/compiled/subprocess/__init__.py

@@ -12,39 +12,68 @@ import sys
 import subprocess
 import socket
 import errno
-import weakref
 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
+    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, \
+from jedi.inference.compiled.subprocess import functions
+from jedi.inference.compiled.access import DirectObjectAccess, AccessPath, \
     SignatureParam
 from jedi.api.exceptions import InternalError
 
-_subprocesses = {}
 
 _MAIN_PATH = os.path.join(os.path.dirname(__file__), '__main__.py')
 
 
-def get_subprocess(executable):
-    try:
-        return _subprocesses[executable]
-    except KeyError:
-        sub = _subprocesses[executable] = _CompiledSubprocess(executable)
-        return sub
+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)
 
 
-class _EvaluatorProcess(object):
-    def __init__(self, evaluator):
-        self._evaluator_weakref = weakref.ref(evaluator)
-        self._evaluator_id = id(evaluator)
+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 _InferenceStateProcess(object):
+    def __init__(self, inference_state):
+        self._inference_state_weakref = weakref.ref(inference_state)
+        self._inference_state_id = id(inference_state)
         self._handles = {}
 
     def get_or_create_access_handle(self, obj):
@@ -52,7 +81,7 @@ class _EvaluatorProcess(object):
         try:
             return self.get_access_handle(id_)
         except KeyError:
-            access = DirectObjectAccess(self._evaluator_weakref(), obj)
+            access = DirectObjectAccess(self._inference_state_weakref(), obj)
             handle = AccessHandle(self, access, id_)
             self.set_access_handle(handle)
             return handle
@@ -64,19 +93,19 @@ class _EvaluatorProcess(object):
         self._handles[handle.id] = handle
 
 
-class EvaluatorSameProcess(_EvaluatorProcess):
+class InferenceStateSameProcess(_InferenceStateProcess):
     """
     Basically just an easy access to functions.py. It has the same API
-    as EvaluatorSubprocess and does the same thing without using a subprocess.
+    as InferenceStateSubprocess 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())
+        return partial(_get_function(name), self._inference_state_weakref())
 
 
-class EvaluatorSubprocess(_EvaluatorProcess):
-    def __init__(self, evaluator, compiled_subprocess):
-        super(EvaluatorSubprocess, self).__init__(evaluator)
+class InferenceStateSubprocess(_InferenceStateProcess):
+    def __init__(self, inference_state, compiled_subprocess):
+        super(InferenceStateSubprocess, self).__init__(inference_state)
         self._used = False
         self._compiled_subprocess = compiled_subprocess
 
@@ -87,7 +116,7 @@ class EvaluatorSubprocess(_EvaluatorProcess):
             self._used = True
 
             result = self._compiled_subprocess.run(
-                self._evaluator_weakref(),
+                self._inference_state_weakref(),
                 func,
                 args=args,
                 kwargs=kwargs,
@@ -118,75 +147,95 @@ class EvaluatorSubprocess(_EvaluatorProcess):
         return obj
 
     def __del__(self):
-        if self._used:
-            self._compiled_subprocess.delete_evaluator(self._evaluator_id)
+        if self._used and not self._compiled_subprocess.is_crashed:
+            self._compiled_subprocess.delete_inference_state(self._inference_state_id)
 
 
-class _CompiledSubprocess(object):
-    _crashed = False
+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._inference_state_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,
+        )
 
-    @property
     @memoize_method
-    def _process(self):
+    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))
+            os.path.dirname(os.path.dirname(parso_path)),
+            '.'.join(str(x) for x in sys.version_info[:3]),
         )
-        return GeneralizedPopen(
+        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.
+    def run(self, inference_state, function, args=(), kwargs={}):
+        # Delete old inference_states.
         while True:
             try:
-                evaluator_id = self._evaluator_deletion_queue.pop()
+                inference_state_id = self._inference_state_deletion_queue.pop()
             except IndexError:
                 break
             else:
-                self._send(evaluator_id, None)
+                self._send(inference_state_id, None)
 
         assert callable(function)
-        return self._send(id(evaluator), function, args, kwargs)
+        return self._send(id(inference_state), function, args, kwargs)
 
     def get_sys_path(self):
         return self._send(None, functions.get_sys_path, (), {})
 
-    def kill(self):
-        self._crashed = True
-        try:
-            subprocess = _subprocesses[self._executable]
-        except KeyError:
-            # Fine it was already removed from the cache.
-            pass
-        else:
-            # In the `!=` case there is already a new subprocess in place
-            # and we don't need to do anything here anymore.
-            if subprocess == self:
-                del _subprocesses[self._executable]
+    def _kill(self):
+        self.is_crashed = True
+        self._cleanup_callable()
 
-        self._process.kill()
-        self._process.wait()
-
-    def _send(self, evaluator_id, function, args=(), kwargs={}):
-        if self._crashed:
+    def _send(self, inference_state_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
+        data = inference_state_id, function, args, kwargs
         try:
-            pickle_dump(data, self._process.stdin)
+            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
@@ -194,15 +243,27 @@ class _CompiledSubprocess(object):
             if e.errno not in (errno.EPIPE, errno.EINVAL):
                 # Not a broken pipe
                 raise
-            self.kill()
+            self._kill()
             raise InternalError("The subprocess %s was killed. Maybe out of memory?"
                                 % self._executable)
 
         try:
-            is_exception, traceback, result = pickle_load(self._process.stdout)
-        except EOFError:
-            self.kill()
-            raise InternalError("The subprocess %s has crashed." % self._executable)
+            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
@@ -211,84 +272,89 @@ class _CompiledSubprocess(object):
             raise result
         return result
 
-    def delete_evaluator(self, evaluator_id):
+    def delete_inference_state(self, inference_state_id):
         """
-        Currently we are not deleting evalutors instantly. They only get
+        Currently we are not deleting inference_state instantly. They only get
         deleted once the subprocess is used again. It would probably a better
         solution to move all of this into a thread. However, the memory usage
-        of a single evaluator shouldn't be that high.
+        of a single inference_state shouldn't be that high.
         """
-        # With an argument - the evaluator gets deleted.
-        self._evaluator_deletion_queue.append(evaluator_id)
+        # With an argument - the inference_state gets deleted.
+        self._inference_state_deletion_queue.append(inference_state_id)
 
 
 class Listener(object):
-    def __init__(self):
-        self._evaluators = {}
+    def __init__(self, pickle_protocol):
+        self._inference_states = {}
         # TODO refactor so we don't need to process anymore just handle
         # controlling.
-        self._process = _EvaluatorProcess(Listener)
+        self._process = _InferenceStateProcess(Listener)
+        self._pickle_protocol = pickle_protocol
 
-    def _get_evaluator(self, function, evaluator_id):
-        from jedi.evaluate import Evaluator
+    def _get_inference_state(self, function, inference_state_id):
+        from jedi.inference import InferenceState
 
         try:
-            evaluator = self._evaluators[evaluator_id]
+            inference_state = self._inference_states[inference_state_id]
         except KeyError:
             from jedi.api.environment import InterpreterEnvironment
-            evaluator = Evaluator(
+            inference_state = InferenceState(
                 # The project is not actually needed. Nothing should need to
                 # access it.
                 project=None,
                 environment=InterpreterEnvironment()
             )
-            self._evaluators[evaluator_id] = evaluator
-        return evaluator
+            self._inference_states[inference_state_id] = inference_state
+        return inference_state
 
-    def _run(self, evaluator_id, function, args, kwargs):
-        if evaluator_id is None:
+    def _run(self, inference_state_id, function, args, kwargs):
+        if inference_state_id is None:
             return function(*args, **kwargs)
         elif function is None:
-            del self._evaluators[evaluator_id]
+            del self._inference_states[inference_state_id]
         else:
-            evaluator = self._get_evaluator(function, evaluator_id)
+            inference_state = self._get_inference_state(function, inference_state_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)
+                    args[i] = inference_state.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)
+                    kwargs[key] = inference_state.compiled_subprocess.get_access_handle(value.id)
 
-            return function(evaluator, *args, **kwargs)
+            return function(inference_state, *args, **kwargs)
 
     def listen(self):
         stdout = sys.stdout
-        # Mute stdout/stderr. Nobody should actually be able to write to those,
-        # because stdout is used for IPC and stderr will just be annoying if it
-        # leaks (on module imports).
+        # Mute stdout. Nobody should actually be able to write to it,
+        # because stdout is used for IPC.
         sys.stdout = open(os.devnull, 'w')
-        sys.stderr = 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(1)
+                # 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, file=stdout)
+            pickle_dump(result, stdout, self._pickle_protocol)
 
 
 class AccessHandle(object):
@@ -317,8 +383,8 @@ class AccessHandle(object):
         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)
+        # 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):
@@ -333,8 +399,4 @@ class AccessHandle(object):
 
     @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/inference/compiled/subprocess/__main__.py

@@ -1,5 +1,5 @@
-import sys
 import os
+import sys
 
 
 def _get_paths():
@@ -31,7 +31,7 @@ if sys.version_info > (3, 4):
 
     # Try to import jedi/parso.
     sys.meta_path.insert(0, _ExactImporter(_get_paths()))
-    from jedi.evaluate.compiled import subprocess  # NOQA
+    from jedi.inference.compiled import subprocess  # NOQA
     sys.meta_path.pop(0)
 else:
     import imp
@@ -43,7 +43,13 @@ else:
 
     load('parso')
     load('jedi')
-    from jedi.evaluate.compiled import subprocess  # NOQA
+    from jedi.inference.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().listen()
+subprocess.Listener(pickle_protocol=pickle_protocol).listen()

jedi/inference/compiled/subprocess/functions.py

@@ -0,0 +1,86 @@
+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.inference.compiled import access
+from jedi import parser_utils
+
+
+def get_sys_path():
+    return list(map(cast_path, sys.path))
+
+
+def load_module(inference_state, **kwargs):
+    return access.load_module(inference_state, **kwargs)
+
+
+def get_compiled_method_return(inference_state, id, attribute, *args, **kwargs):
+    handle = inference_state.compiled_subprocess.get_access_handle(id)
+    return getattr(handle.access, attribute)(*args, **kwargs)
+
+
+def create_simple_object(inference_state, obj):
+    return access.create_access_path(inference_state, obj)
+
+
+def get_module_info(inference_state, 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(inference_state, search_path):
+    return [
+        force_unicode(name)
+        for module_loader, name, is_pkg in iter_modules(search_path)
+    ]
+
+
+def get_builtin_module_names(inference_state):
+    return list(map(force_unicode, sys.builtin_module_names))
+
+
+def _test_raise_error(inference_state, exception_type):
+    """
+    Raise an error to simulate certain problems for unit tests.
+    """
+    raise exception_type
+
+
+def _test_print(inference_state, 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(inference_state, value):
+    return parser_utils.safe_literal_eval(value)

jedi/inference/compiled/value.py

@@ -0,0 +1,627 @@
+"""
+Imitate the parser representation.
+"""
+import re
+from functools import partial
+
+from jedi import debug
+from jedi.inference.utils import to_list
+from jedi._compatibility import force_unicode, Parameter, cast_path
+from jedi.cache import memoize_method
+from jedi.inference.filters import AbstractFilter
+from jedi.inference.names import AbstractNameDefinition, ValueNameMixin, \
+    ParamNameInterface
+from jedi.inference.base_value import Value, ValueSet, NO_VALUES
+from jedi.inference.lazy_value import LazyKnownValue
+from jedi.inference.compiled.access import _sentinel
+from jedi.inference.cache import inference_state_function_cache
+from jedi.inference.helpers import reraise_getitem_errors
+from jedi.inference.signature import BuiltinSignature
+from jedi.inference.context import CompiledContext, CompiledModuleContext
+
+
+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 CompiledValue(Value):
+    def __init__(self, inference_state, access_handle, parent_context=None):
+        super(CompiledValue, self).__init__(inference_state, 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.inference_state,
+                return_annotation
+            ).execute_annotation()
+
+        try:
+            self.access_handle.getattr_paths(u'__call__')
+        except AttributeError:
+            return super(CompiledValue, self).py__call__(arguments)
+        else:
+            if self.access_handle.is_class():
+                from jedi.inference.value import CompiledInstance
+                return ValueSet([
+                    CompiledInstance(self.inference_state, self.parent_context, self, arguments)
+                ])
+            else:
+                return ValueSet(self._execute_function(arguments))
+
+    @CheckAttribute()
+    def py__class__(self):
+        return create_from_access_path(self.inference_state, self.access_handle.py__class__())
+
+    @CheckAttribute()
+    def py__mro__(self):
+        return (self,) + tuple(
+            create_from_access_path(self.inference_state, access)
+            for access in self.access_handle.py__mro__accesses()
+        )
+
+    @CheckAttribute()
+    def py__bases__(self):
+        return tuple(
+            create_from_access_path(self.inference_state, access)
+            for access in self.access_handle.py__bases__()
+        )
+
+    def get_qualified_names(self):
+        return self.access_handle.get_qualified_names()
+
+    def py__bool__(self):
+        return self.access_handle.py__bool__()
+
+    def is_class(self):
+        return self.access_handle.is_class()
+
+    def is_function(self):
+        return self.access_handle.is_function()
+
+    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())
+
+    @memoize_method
+    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()
+
+    def get_filters(self, is_instance=False, origin_scope=None):
+        yield self._ensure_one_filter(is_instance)
+
+    @memoize_method
+    def _ensure_one_filter(self, is_instance):
+        return CompiledValueFilter(self.inference_state, self, is_instance)
+
+    def py__simple_getitem__(self, index):
+        with reraise_getitem_errors(IndexError, KeyError, TypeError):
+            try:
+                access = self.access_handle.py__simple_getitem__(index)
+            except AttributeError:
+                return super(CompiledValue, self).py__simple_getitem__(index)
+        if access is None:
+            return NO_VALUES
+
+        return ValueSet([create_from_access_path(self.inference_state, access)])
+
+    def py__getitem__(self, index_value_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(CompiledValue, self).py__getitem__(index_value_set, contextualized_node)
+        return ValueSet(
+            create_from_access_path(self.inference_state, 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(CompiledValue, 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 LazyKnownValue(create_from_access_path(self.inference_state, 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 CompiledValueName(self, name)
+
+    def _execute_function(self, params):
+        from jedi.inference import docstrings
+        from jedi.inference.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.inference_state.builtins_module.access_handle.getattr_paths(name)
+            except AttributeError:
+                continue
+            else:
+                bltn_obj = builtin_from_name(self.inference_state, name)
+                for result in self.inference_state.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):
+        try:
+            return ValueSet([create_from_access_path(
+                self.inference_state,
+                self.access_handle.execute_operation(other.access_handle, operator)
+            )])
+        except TypeError:
+            return NO_VALUES
+
+    def execute_annotation(self):
+        if self.access_handle.get_repr() == 'None':
+            # None as an annotation doesn't need to be executed.
+            return ValueSet([self])
+
+        name, args = self.access_handle.get_annotation_name_and_args()
+        arguments = [
+            ValueSet([create_from_access_path(self.inference_state, path)])
+            for path in args
+        ]
+        if name == 'Union':
+            return ValueSet.from_sets(arg.execute_annotation() for arg in arguments)
+        elif name:
+            # While with_generics only exists on very specific objects, we
+            # should probably be fine, because we control all the typing
+            # objects.
+            return ValueSet([
+                v.with_generics(arguments)
+                for v in self.inference_state.typing_module.py__getattribute__(name)
+            ]).execute_annotation()
+        return super(CompiledValue, self).execute_annotation()
+
+    def negate(self):
+        return create_from_access_path(self.inference_state, self.access_handle.negate())
+
+    def get_metaclasses(self):
+        return NO_VALUES
+
+    def _as_context(self):
+        return CompiledContext(self)
+
+    @property
+    def array_type(self):
+        return self.access_handle.get_array_type()
+
+    def get_key_values(self):
+        return [
+            create_from_access_path(self.inference_state, k)
+            for k in self.access_handle.get_key_paths()
+        ]
+
+
+class CompiledModule(CompiledValue):
+    file_io = None  # For modules
+
+    def _as_context(self):
+        return CompiledModuleContext(self)
+
+    def py__path__(self):
+        paths = self.access_handle.py__path__()
+        if paths is None:
+            return None
+        return map(cast_path, paths)
+
+    def is_package(self):
+        return self.py__path__() is not None
+
+    @property
+    def string_names(self):
+        # For modules
+        name = self.py__name__()
+        if name is None:
+            return ()
+        return tuple(name.split('.'))
+
+    def py__file__(self):
+        return cast_path(self.access_handle.py__file__())
+
+
+class CompiledName(AbstractNameDefinition):
+    def __init__(self, inference_state, parent_value, name):
+        self._inference_state = inference_state
+        self.parent_context = parent_value.as_context()
+        self._parent_value = parent_value
+        self.string_name = name
+
+    def py__doc__(self):
+        value, = self.infer()
+        return value.py__doc__()
+
+    def _get_qualified_names(self):
+        parent_qualified_names = self.parent_context.get_qualified_names()
+        if parent_qualified_names is None:
+            return None
+        return parent_qualified_names + (self.string_name,)
+
+    def get_defining_qualified_value(self):
+        context = self.parent_context
+        if context.is_module() or context.is_class():
+            return self.parent_context.get_value()  # Might be None
+
+        return None
+
+    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
+
+    @memoize_method
+    def infer(self):
+        return ValueSet([self.infer_compiled_value()])
+
+    def infer_compiled_value(self):
+        return create_from_name(self._inference_state, self._parent_value, self.string_name)
+
+
+class SignatureParamName(ParamNameInterface, AbstractNameDefinition):
+    def __init__(self, compiled_value, signature_param):
+        self.parent_context = compiled_value.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
+        inference_state = self.parent_context.inference_state
+        values = NO_VALUES
+        if p.has_default:
+            values = ValueSet([create_from_access_path(inference_state, p.default)])
+        if p.has_annotation:
+            annotation = create_from_access_path(inference_state, p.annotation)
+            values |= annotation.execute_with_values()
+        return values
+
+
+class UnresolvableParamName(ParamNameInterface, AbstractNameDefinition):
+    def __init__(self, compiled_value, name, default):
+        self.parent_context = compiled_value.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_VALUES
+
+
+class CompiledValueName(ValueNameMixin, AbstractNameDefinition):
+    def __init__(self, value, name):
+        self.string_name = name
+        self._value = value
+        self.parent_context = value.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, inference_state, name):
+        self.parent_context = inference_state.builtins_module
+        self.string_name = name
+
+    def infer(self):
+        return NO_VALUES
+
+
+class CompiledValueFilter(AbstractFilter):
+    def __init__(self, inference_state, compiled_value, is_instance=False):
+        self._inference_state = inference_state
+        self.compiled_value = compiled_value
+        self.is_instance = is_instance
+
+    def get(self, name):
+        access_handle = self.compiled_value.access_handle
+        return self._get(
+            name,
+            lambda name, unsafe: access_handle.is_allowed_getattr(name, unsafe),
+            lambda name: name in access_handle.dir(),
+            check_has_attribute=True
+        )
+
+    def _get(self, name, allowed_getattr_callback, in_dir_callback, check_has_attribute=False):
+        """
+        To remove quite a few access calls we introduced the callback here.
+        """
+        # Always use unicode objects in Python 2 from here.
+        name = force_unicode(name)
+
+        if self._inference_state.allow_descriptor_getattr:
+            pass
+
+        has_attribute, is_descriptor = allowed_getattr_callback(
+            name,
+            unsafe=self._inference_state.allow_descriptor_getattr
+        )
+        if check_has_attribute and not has_attribute:
+            return []
+
+        if (is_descriptor or not has_attribute) \
+                and not self._inference_state.allow_descriptor_getattr:
+            return [self._get_cached_name(name, is_empty=True)]
+
+        if self.is_instance and not in_dir_callback(name):
+            return []
+        return [self._get_cached_name(name)]
+
+    @memoize_method
+    def _get_cached_name(self, name, is_empty=False):
+        if is_empty:
+            return EmptyCompiledName(self._inference_state, name)
+        else:
+            return self._create_name(name)
+
+    def values(self):
+        from jedi.inference.compiled import builtin_from_name
+        names = []
+        needs_type_completions, dir_infos = self.compiled_value.access_handle.get_dir_infos()
+        # We could use `unsafe` here as well, especially as a parameter to
+        # get_dir_infos. But this would lead to a lot of property executions
+        # that are probably not wanted. The drawback for this is that we
+        # have a different name for `get` and `values`. For `get` we always
+        # execute.
+        for name in dir_infos:
+            names += self._get(
+                name,
+                lambda name, unsafe: dir_infos[name],
+                lambda name: name in dir_infos,
+            )
+
+        # ``dir`` doesn't include the type names.
+        if not self.is_instance and needs_type_completions:
+            for filter in builtin_from_name(self._inference_state, u'type').get_filters():
+                names += filter.values()
+        return names
+
+    def _create_name(self, name):
+        return CompiledName(
+            self._inference_state,
+            self.compiled_value,
+            name
+        )
+
+    def __repr__(self):
+        return "<%s: %s>" % (self.__class__.__name__, self.compiled_value)
+
+
+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(inference_state, compiled_value, name):
+    access_paths = compiled_value.access_handle.getattr_paths(name, default=None)
+    parent_context = compiled_value
+    if parent_context.is_class():
+        parent_context = parent_context.parent_context
+
+    value = None
+    for access_path in access_paths:
+        value = create_cached_compiled_value(
+            inference_state,
+            access_path,
+            parent_context=None if value is None else value.as_context(),
+        )
+    return value
+
+
+def _normalize_create_args(func):
+    """The cache doesn't care about keyword vs. normal args."""
+    def wrapper(inference_state, obj, parent_context=None):
+        return func(inference_state, obj, parent_context)
+    return wrapper
+
+
+def create_from_access_path(inference_state, access_path):
+    value = None
+    for name, access in access_path.accesses:
+        value = create_cached_compiled_value(
+            inference_state,
+            access,
+            parent_context=None if value is None else value.as_context()
+        )
+    return value
+
+
+@_normalize_create_args
+@inference_state_function_cache()
+def create_cached_compiled_value(inference_state, access_handle, parent_context):
+    assert not isinstance(parent_context, CompiledValue)
+    if parent_context is None:
+        cls = CompiledModule
+    else:
+        cls = CompiledValue
+    return cls(inference_state, access_handle, parent_context)

jedi/inference/context.py

@@ -0,0 +1,488 @@
+from abc import abstractmethod
+from contextlib import contextmanager
+
+from parso.tree import search_ancestor
+from parso.python.tree import Name
+
+from jedi.inference.filters import ParserTreeFilter, MergedFilter, \
+    GlobalNameFilter
+from jedi.inference.names import AnonymousParamName, TreeNameDefinition
+from jedi.inference.base_value import NO_VALUES, ValueSet
+from jedi.parser_utils import get_parent_scope
+from jedi import debug
+from jedi import parser_utils
+
+
+class AbstractContext(object):
+    # Must be defined: inference_state and tree_node and parent_context as an attribute/property
+
+    def __init__(self, inference_state):
+        self.inference_state = inference_state
+        self.predefined_names = {}
+
+    @abstractmethod
+    def get_filters(self, until_position=None, origin_scope=None):
+        raise NotImplementedError
+
+    def goto(self, name_or_str, position):
+        from jedi.inference import finder
+        filters = _get_global_filters_for_name(
+            self, name_or_str if isinstance(name_or_str, Name) else None, position,
+        )
+        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, position)
+
+        string_name = name_or_str.value if isinstance(name_or_str, Name) else name_or_str
+
+        # This paragraph is currently needed for proper branch type inference
+        # (static analysis).
+        found_predefined_types = None
+        if self.predefined_names and isinstance(name_or_str, Name):
+            node = name_or_str
+            while node is not None and not parser_utils.is_scope(node):
+                node = node.parent
+                if node.type in ("if_stmt", "for_stmt", "comp_for", 'sync_comp_for'):
+                    try:
+                        name_dict = self.predefined_names[node]
+                        types = name_dict[string_name]
+                    except KeyError:
+                        continue
+                    else:
+                        found_predefined_types = types
+                        break
+        if found_predefined_types is not None and names:
+            from jedi.inference import flow_analysis
+            check = flow_analysis.reachability_check(
+                context=self,
+                value_scope=self.tree_node,
+                node=name_or_str,
+            )
+            if check is flow_analysis.UNREACHABLE:
+                values = NO_VALUES
+            else:
+                values = found_predefined_types
+        else:
+            values = ValueSet.from_sets(name.infer() for name in names)
+
+        if not names and not values and analysis_errors:
+            if isinstance(name_or_str, Name):
+                from jedi.inference import analysis
+                message = ("NameError: name '%s' is not defined." % string_name)
+                analysis.add(name_context, 'name-error', name_or_str, message)
+
+        debug.dbg('context.names_to_types: %s -> %s', names, values)
+        if values:
+            return values
+        return self._check_for_additional_knowledge(name_or_str, name_context, position)
+
+    def _check_for_additional_knowledge(self, name_or_str, name_context, position):
+        name_context = name_context or self
+        # Add isinstance and other if/assert knowledge.
+        if isinstance(name_or_str, Name) and not name_context.is_instance():
+            flow_scope = name_or_str
+            base_nodes = [name_context.tree_node]
+
+            if any(b.type in ('comp_for', 'sync_comp_for') for b in base_nodes):
+                return NO_VALUES
+            from jedi.inference.finder import check_flow_information
+            while True:
+                flow_scope = get_parent_scope(flow_scope, include_flows=True)
+                n = check_flow_information(name_context, flow_scope,
+                                           name_or_str, position)
+                if n is not None:
+                    return n
+                if flow_scope in base_nodes:
+                    break
+        return NO_VALUES
+
+    def get_root_context(self):
+        parent_context = self.parent_context
+        if parent_context is None:
+            return self
+        return parent_context.get_root_context()
+
+    def is_module(self):
+        return False
+
+    def is_builtins_module(self):
+        return False
+
+    def is_class(self):
+        return False
+
+    def is_stub(self):
+        return False
+
+    def is_instance(self):
+        return False
+
+    def is_compiled(self):
+        return False
+
+    @abstractmethod
+    def py__name__(self):
+        raise NotImplementedError
+
+    def get_value(self):
+        raise NotImplementedError
+
+    @property
+    def name(self):
+        return None
+
+    def get_qualified_names(self):
+        return ()
+
+    def py__doc__(self):
+        return ''
+
+    @contextmanager
+    def predefine_names(self, flow_scope, dct):
+        predefined = self.predefined_names
+        predefined[flow_scope] = dct
+        try:
+            yield
+        finally:
+            del predefined[flow_scope]
+
+
+class ValueContext(AbstractContext):
+    """
+    Should be defined, otherwise the API returns empty types.
+    """
+    def __init__(self, value):
+        super(ValueContext, self).__init__(value.inference_state)
+        self._value = value
+
+    @property
+    def tree_node(self):
+        return self._value.tree_node
+
+    @property
+    def parent_context(self):
+        return self._value.parent_context
+
+    def is_module(self):
+        return self._value.is_module()
+
+    def is_builtins_module(self):
+        return self._value == self.inference_state.builtins_module
+
+    def is_class(self):
+        return self._value.is_class()
+
+    def is_stub(self):
+        return self._value.is_stub()
+
+    def is_instance(self):
+        return self._value.is_instance()
+
+    def is_compiled(self):
+        return self._value.is_compiled()
+
+    def py__name__(self):
+        return self._value.py__name__()
+
+    @property
+    def name(self):
+        return self._value.name
+
+    def get_qualified_names(self):
+        return self._value.get_qualified_names()
+
+    def py__doc__(self):
+        return self._value.py__doc__()
+
+    def get_value(self):
+        return self._value
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self._value)
+
+
+class TreeContextMixin(object):
+    def infer_node(self, node):
+        from jedi.inference.syntax_tree import infer_node
+        return infer_node(self, node)
+
+    def create_value(self, node):
+        from jedi.inference import value
+
+        if node == self.tree_node:
+            assert self.is_module()
+            return self.get_value()
+
+        parent_context = self.create_context(node)
+
+        if node.type in ('funcdef', 'lambdef'):
+            func = value.FunctionValue.from_context(parent_context, node)
+            if parent_context.is_class():
+                class_value = parent_context.parent_context.create_value(parent_context.tree_node)
+                instance = value.AnonymousInstance(
+                    self.inference_state, parent_context.parent_context, class_value)
+                func = value.BoundMethod(
+                    instance=instance,
+                    class_context=class_value.as_context(),
+                    function=func
+                )
+            return func
+        elif node.type == 'classdef':
+            return value.ClassValue(self.inference_state, parent_context, node)
+        else:
+            raise NotImplementedError("Probably shouldn't happen: %s" % node)
+
+    def create_context(self, node):
+        def from_scope_node(scope_node, is_nested=True):
+            if scope_node == self.tree_node:
+                return self
+
+            if scope_node.type in ('funcdef', 'lambdef', 'classdef'):
+                return self.create_value(scope_node).as_context()
+            elif scope_node.type in ('comp_for', 'sync_comp_for'):
+                parent_scope = parser_utils.get_parent_scope(scope_node)
+                parent_context = from_scope_node(parent_scope)
+                if node.start_pos >= scope_node.children[-1].start_pos:
+                    return parent_context
+                return CompForContext(parent_context, scope_node)
+            raise Exception("There's a scope that was not managed: %s" % scope_node)
+
+        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
+
+        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)
+
+    def create_name(self, tree_name):
+        definition = tree_name.get_definition()
+        if definition and definition.type == 'param' and definition.name == tree_name:
+            funcdef = search_ancestor(definition, 'funcdef', 'lambdef')
+            func = self.create_value(funcdef)
+            return AnonymousParamName(func, tree_name)
+        else:
+            context = self.create_context(tree_name)
+            return TreeNameDefinition(context, tree_name)
+
+
+class FunctionContext(TreeContextMixin, ValueContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield ParserTreeFilter(
+            self.inference_state,
+            parent_context=self,
+            until_position=until_position,
+            origin_scope=origin_scope
+        )
+
+
+class ModuleContext(TreeContextMixin, ValueContext):
+    def py__file__(self):
+        return self._value.py__file__()
+
+    def get_filters(self, until_position=None, origin_scope=None):
+        filters = self._value.get_filters(origin_scope)
+        # Skip the first filter and replace it.
+        next(filters)
+        yield MergedFilter(
+            ParserTreeFilter(
+                parent_context=self,
+                until_position=until_position,
+                origin_scope=origin_scope
+            ),
+            self.get_global_filter(),
+        )
+        for f in filters:  # Python 2...
+            yield f
+
+    def get_global_filter(self):
+        return GlobalNameFilter(self, self.tree_node)
+
+    @property
+    def string_names(self):
+        return self._value.string_names
+
+    @property
+    def code_lines(self):
+        return self._value.code_lines
+
+    def get_value(self):
+        """
+        This is the only function that converts a context back to a value.
+        This is necessary for stub -> python conversion and vice versa. However
+        this method shouldn't be moved to AbstractContext.
+        """
+        return self._value
+
+
+class NamespaceContext(TreeContextMixin, ValueContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        return self._value.get_filters()
+
+    def get_value(self):
+        return self._value
+
+    def py__file__(self):
+        return self._value.py__file__()
+
+
+class ClassContext(TreeContextMixin, ValueContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield self.get_global_filter(until_position, origin_scope)
+
+    def get_global_filter(self, until_position=None, origin_scope=None):
+        return ParserTreeFilter(
+            parent_context=self,
+            until_position=until_position,
+            origin_scope=origin_scope
+        )
+
+
+class CompForContext(TreeContextMixin, AbstractContext):
+    def __init__(self, parent_context, comp_for):
+        super(CompForContext, self).__init__(parent_context.inference_state)
+        self.tree_node = comp_for
+        self.parent_context = parent_context
+
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield ParserTreeFilter(self)
+
+    def get_value(self):
+        return None
+
+    def py__name__(self):
+        return '<comprehension context>'
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self.tree_node)
+
+
+class CompiledContext(ValueContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        return self._value.get_filters()
+
+
+class CompiledModuleContext(CompiledContext):
+    code_lines = None
+
+    def get_value(self):
+        return self._value
+
+    @property
+    def string_names(self):
+        return self._value.string_names
+
+    def py__file__(self):
+        return self._value.py__file__()
+
+
+def _get_global_filters_for_name(context, name_or_none, position):
+    # For functions and classes the defaults don't belong to the
+    # function and get inferred in the value before the function. So
+    # make sure to exclude the function/class name.
+    if name_or_none is not None:
+        ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef', 'lambdef')
+        lambdef = None
+        if ancestor == 'lambdef':
+            # For lambdas it's even more complicated since parts will
+            # be inferred later.
+            lambdef = ancestor
+            ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef')
+        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(context, position, name_or_none)
+
+
+def get_global_filters(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_context().create_context(scope)
+    >>> filters = list(get_global_filters(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
+    [...]
+    """
+    base_context = context
+    from jedi.inference.value.function import BaseFunctionExecutionContext
+    while context is not None:
+        # Names in methods cannot be resolved within the class.
+        for filter in context.get_filters(
+                until_position=until_position,
+                origin_scope=origin_scope):
+            yield filter
+        if isinstance(context, (BaseFunctionExecutionContext, ModuleContext)):
+            # 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(base_context.inference_state.builtins_module.get_filters())

jedi/inference/docstrings.py

@@ -1,6 +1,6 @@
 """
 Docstrings are another source of information for functions and classes.
-:mod:`jedi.evaluate.dynamic` tries to find all executions of functions, while
+:mod:`jedi.inference.dynamic` tries to find all executions of functions, while
 the docstring parsing is much easier. There are three different types of
 docstrings that |jedi| understands:
 
@@ -16,16 +16,18 @@ annotations.
 """
 
 import re
+import warnings
 from textwrap import dedent
 
 from parso import parse, ParserSyntaxError
 
 from jedi._compatibility import u
-from jedi.evaluate.utils import indent_block
-from jedi.evaluate.cache import evaluator_method_cache
-from jedi.evaluate.base_context import iterator_to_context_set, ContextSet, \
-    NO_CONTEXTS
-from jedi.evaluate.lazy_context import LazyKnownContexts
+from jedi import debug
+from jedi.inference.utils import indent_block
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.base_value import iterator_to_value_set, ValueSet, \
+    NO_VALUES
+from jedi.inference.lazy_value import LazyKnownValues
 
 
 DOCSTRING_PARAM_PATTERNS = [
@@ -47,27 +49,26 @@ _numpy_doc_string_cache = None
 
 def _get_numpy_doc_string_cls():
     global _numpy_doc_string_cache
-    try:
-        from numpydoc.docscrape import NumpyDocString
-        _numpy_doc_string_cache = NumpyDocString
-    except ImportError as e:
-        _numpy_doc_string_cache = e
-    if isinstance(_numpy_doc_string_cache, ImportError):
+    if isinstance(_numpy_doc_string_cache, (ImportError, SyntaxError)):
         raise _numpy_doc_string_cache
+    from numpydoc.docscrape import NumpyDocString
+    _numpy_doc_string_cache = NumpyDocString
     return _numpy_doc_string_cache
 
 
 def _search_param_in_numpydocstr(docstr, param_str):
     """Search `docstr` (in numpydoc format) for type(-s) of `param_str`."""
-    try:
-        # This is a non-public API. If it ever changes we should be
-        # prepared and return gracefully.
-        params = _get_numpy_doc_string_cls()(docstr)._parsed_data['Parameters']
-    except (KeyError, AttributeError, ImportError):
-        return []
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        try:
+            # This is a non-public API. If it ever changes we should be
+            # prepared and return gracefully.
+            params = _get_numpy_doc_string_cls()(docstr)._parsed_data['Parameters']
+        except Exception:
+            return []
     for p_name, p_type, p_descr in params:
         if p_name == param_str:
-            m = re.match('([^,]+(,[^,]+)*?)(,[ ]*optional)?$', p_type)
+            m = re.match(r'([^,]+(,[^,]+)*?)(,[ ]*optional)?$', p_type)
             if m:
                 p_type = m.group(1)
             return list(_expand_typestr(p_type))
@@ -78,16 +79,18 @@ def _search_return_in_numpydocstr(docstr):
     """
     Search `docstr` (in numpydoc format) for type(-s) of function returns.
     """
-    try:
-        doc = _get_numpy_doc_string_cls()(docstr)
-    except ImportError:
-        return
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        try:
+            doc = _get_numpy_doc_string_cls()(docstr)
+        except Exception:
+            return
     try:
         # This is a non-public API. If it ever changes we should be
         # prepared and return gracefully.
         returns = doc._parsed_data['Returns']
         returns += doc._parsed_data['Yields']
-    except (KeyError, AttributeError):
+    except Exception:
         return
     for r_name, r_type, r_descr in returns:
         # Return names are optional and if so the type is in the name
@@ -102,15 +105,15 @@ def _expand_typestr(type_str):
     Attempts to interpret the possible types in `type_str`
     """
     # Check if alternative types are specified with 'or'
-    if re.search('\\bor\\b', type_str):
+    if re.search(r'\bor\b', type_str):
         for t in type_str.split('or'):
             yield t.split('of')[0].strip()
     # Check if like "list of `type`" and set type to list
-    elif re.search('\\bof\\b', type_str):
+    elif re.search(r'\bof\b', type_str):
         yield type_str.split('of')[0]
     # Check if type has is a set of valid literal values eg: {'C', 'F', 'A'}
     elif type_str.startswith('{'):
-        node = parse(type_str, version='3.6').children[0]
+        node = parse(type_str, version='3.7').children[0]
         if node.type == 'atom':
             for leaf in node.children[1].children:
                 if leaf.type == 'number':
@@ -180,7 +183,7 @@ def _strip_rst_role(type_str):
         return type_str
 
 
-def _evaluate_for_statement_string(module_context, string):
+def _infer_for_statement_string(module_context, string):
     code = dedent(u("""
     def pseudo_docstring_stuff():
         '''
@@ -193,7 +196,7 @@ def _evaluate_for_statement_string(module_context, string):
     if string is None:
         return []
 
-    for element in re.findall('((?:\w+\.)*\w+)\.', string):
+    for element in re.findall(r'((?:\w+\.)*\w+)\.', string):
         # Try to import module part in dotted name.
         # (e.g., 'threading' in 'threading.Thread').
         string = 'import %s\n' % element + string
@@ -201,7 +204,8 @@ def _evaluate_for_statement_string(module_context, string):
     # Take the default grammar here, if we load the Python 2.7 grammar here, it
     # will be impossible to use `...` (Ellipsis) as a token. Docstring types
     # don't need to conform with the current grammar.
-    grammar = module_context.evaluator.latest_grammar
+    debug.dbg('Parse docstring code %s', string, color='BLUE')
+    grammar = module_context.inference_state.latest_grammar
     try:
         module = grammar.parse(code.format(indent_block(string)), error_recovery=False)
     except ParserSyntaxError:
@@ -214,13 +218,16 @@ def _evaluate_for_statement_string(module_context, string):
     except (AttributeError, IndexError):
         return []
 
-    from jedi.evaluate.context import FunctionContext
-    function_context = FunctionContext(
-        module_context.evaluator,
+    if stmt.type not in ('name', 'atom', 'atom_expr'):
+        return []
+
+    from jedi.inference.value import FunctionValue
+    function_value = FunctionValue(
+        module_context.inference_state,
         module_context,
         funcdef
     )
-    func_execution_context = function_context.get_function_execution()
+    func_execution_context = function_value.as_context()
     # Use the module of the param.
     # TODO this module is not the module of the param in case of a function
     # call. In that case it's the module of the function call.
@@ -234,59 +241,58 @@ def _execute_types_in_stmt(module_context, stmt):
     doesn't include tuple, list and dict literals, because the stuff they
     contain is executed. (Used as type information).
     """
-    definitions = module_context.eval_node(stmt)
-    return ContextSet.from_sets(
-        _execute_array_values(module_context.evaluator, d)
+    definitions = module_context.infer_node(stmt)
+    return ValueSet.from_sets(
+        _execute_array_values(module_context.inference_state, d)
         for d in definitions
     )
 
 
-def _execute_array_values(evaluator, array):
+def _execute_array_values(inference_state, array):
     """
     Tuples indicate that there's not just one return value, but the listed
     ones.  `(str, int)` means that it returns a tuple with both types.
     """
-    from jedi.evaluate.context.iterable import SequenceLiteralContext, FakeSequence
-    if isinstance(array, SequenceLiteralContext):
+    from jedi.inference.value.iterable import SequenceLiteralValue, FakeTuple, FakeList
+    if isinstance(array, SequenceLiteralValue) and array.array_type in ('tuple', 'list'):
         values = []
-        for lazy_context in array.py__iter__():
-            objects = ContextSet.from_sets(
-                _execute_array_values(evaluator, typ)
-                for typ in lazy_context.infer()
+        for lazy_value in array.py__iter__():
+            objects = ValueSet.from_sets(
+                _execute_array_values(inference_state, typ)
+                for typ in lazy_value.infer()
             )
-            values.append(LazyKnownContexts(objects))
-        return {FakeSequence(evaluator, array.array_type, values)}
+            values.append(LazyKnownValues(objects))
+        cls = FakeTuple if array.array_type == 'tuple' else FakeList
+        return {cls(inference_state, values)}
     else:
-        return array.execute_evaluated()
+        return array.execute_annotation()
 
 
-@evaluator_method_cache()
-def infer_param(execution_context, param):
-    from jedi.evaluate.context.instance import AnonymousInstanceFunctionExecution
-
-    def eval_docstring(docstring):
-        return ContextSet.from_iterable(
+@inference_state_method_cache()
+def infer_param(function_value, param):
+    def infer_docstring(docstring):
+        return ValueSet(
             p
             for param_str in _search_param_in_docstr(docstring, param.name.value)
-            for p in _evaluate_for_statement_string(module_context, param_str)
+            for p in _infer_for_statement_string(module_context, param_str)
         )
-    module_context = execution_context.get_root_context()
+    module_context = function_value.get_root_context()
     func = param.get_parent_function()
     if func.type == 'lambdef':
-        return NO_CONTEXTS
+        return NO_VALUES
 
-    types = eval_docstring(execution_context.py__doc__())
-    if isinstance(execution_context, AnonymousInstanceFunctionExecution) and \
-            execution_context.function_context.name.string_name == '__init__':
-        class_context = execution_context.instance.class_context
-        types |= eval_docstring(class_context.py__doc__())
+    types = infer_docstring(function_value.py__doc__())
+    if function_value.is_bound_method() \
+            and function_value.py__name__() == '__init__':
+        types |= infer_docstring(function_value.class_context.py__doc__())
 
+    debug.dbg('Found param types for docstring: %s', types, color='BLUE')
     return types
 
 
-@evaluator_method_cache()
-@iterator_to_context_set
-def infer_return_types(function_context):
+@inference_state_method_cache()
+@iterator_to_value_set
+def infer_return_types(function_value):
     def search_return_in_docstr(code):
         for p in DOCSTRING_RETURN_PATTERNS:
             match = p.search(code)
@@ -296,6 +302,6 @@ def infer_return_types(function_context):
         for type_ in _search_return_in_numpydocstr(code):
             yield type_
 
-    for type_str in search_return_in_docstr(function_context.py__doc__()):
-        for type_eval in _evaluate_for_statement_string(function_context.get_root_context(), type_str):
-            yield type_eval
+    for type_str in search_return_in_docstr(function_value.py__doc__()):
+        for value in _infer_for_statement_string(function_value.get_root_context(), type_str):
+            yield value

jedi/inference/dynamic_params.py

@@ -0,0 +1,227 @@
+"""
+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.parser_utils import get_parent_scope
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.arguments import TreeArguments
+from jedi.inference.param import get_executed_param_names
+from jedi.inference.helpers import is_stdlib_path
+from jedi.inference.utils import to_list
+from jedi.inference.value import instance
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference.references import get_module_contexts_containing_name
+from jedi.inference import recursion
+
+
+MAX_PARAM_SEARCHES = 20
+
+
+def _avoid_recursions(func):
+    def wrapper(function_value, param_index):
+        inf = function_value.inference_state
+        with recursion.execution_allowed(inf, function_value.tree_node) 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:
+                inf.dynamic_params_depth += 1
+                try:
+                    return func(function_value, param_index)
+                finally:
+                    inf.dynamic_params_depth -= 1
+            return NO_VALUES
+        return
+    return wrapper
+
+
+@debug.increase_indent
+@_avoid_recursions
+def dynamic_param_lookup(function_value, param_index):
+    """
+    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.
+    """
+    funcdef = function_value.tree_node
+
+    if not settings.dynamic_params:
+        return NO_VALUES
+
+    path = function_value.get_root_context().py__file__()
+    if path is not None and is_stdlib_path(path):
+        # We don't want to search for references in the stdlib. Usually people
+        # 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 NO_VALUES
+
+    if funcdef.type == 'lambdef':
+        string_name = _get_lambda_name(funcdef)
+        if string_name is None:
+            return NO_VALUES
+    else:
+        string_name = funcdef.name.value
+    debug.dbg('Dynamic param search in %s.', string_name, color='MAGENTA')
+
+    module_context = function_value.get_root_context()
+    arguments_list = _search_function_arguments(module_context, funcdef, string_name)
+    values = ValueSet.from_sets(
+        get_executed_param_names(
+            function_value, arguments
+        )[param_index].infer()
+        for arguments in arguments_list
+    )
+    debug.dbg('Dynamic param result finished', color='MAGENTA')
+    return values
+
+
+@inference_state_method_cache(default=None)
+@to_list
+def _search_function_arguments(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_arguments = False
+    i = 0
+    inference_state = module_context.inference_state
+
+    if settings.dynamic_params_for_other_modules:
+        module_contexts = get_module_contexts_containing_name(
+            inference_state, [module_context], string_name,
+            # Limit the amounts of files to be opened massively.
+            limit_reduction=5,
+        )
+    else:
+        module_contexts = [module_context]
+
+    for for_mod_context in module_contexts:
+        for name, trailer in _get_potential_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 inferred.
+            if i * inference_state.dynamic_params_depth > MAX_PARAM_SEARCHES:
+                return
+
+            random_context = for_mod_context.create_context(name)
+            for arguments in _check_name_for_execution(
+                    inference_state, random_context, compare_node, name, trailer):
+                found_arguments = True
+                yield arguments
+
+        # If there are results after processing a module, we're probably
+        # good to process. This is a speed optimization.
+        if found_arguments:
+            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_potential_nodes(module_value, func_string_name):
+    try:
+        names = module_value.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(inference_state, context, compare_node, name, trailer):
+    from jedi.inference.value.function import BaseFunctionExecutionContext
+
+    def create_args(value):
+        arglist = trailer.children[1]
+        if arglist == ')':
+            arglist = None
+        args = TreeArguments(inference_state, context, arglist, trailer)
+        from jedi.inference.value.instance import InstanceArguments
+        if value.tree_node.type == 'classdef':
+            created_instance = instance.TreeInstance(
+                inference_state,
+                value.parent_context,
+                value,
+                args
+            )
+            return InstanceArguments(created_instance, args)
+        else:
+            if value.is_bound_method():
+                args = InstanceArguments(value.instance, args)
+            return args
+
+    for value in inference_state.infer(context, name):
+        value_node = value.tree_node
+        if compare_node == value_node:
+            yield create_args(value)
+        elif isinstance(value.parent_context, BaseFunctionExecutionContext) \
+                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.
+            param_names = value.parent_context.get_param_names()
+            if len(param_names) != 1:
+                continue
+            values = param_names[0].infer()
+            if [v.tree_node for v in values] == [compare_node]:
+                # Found a decorator.
+                module_context = context.get_root_context()
+                execution_context = value.as_context(create_args(value))
+                potential_nodes = _get_potential_nodes(module_context, param_names[0].string_name)
+                for name, trailer in potential_nodes:
+                    if value_node.start_pos < name.start_pos < value_node.end_pos:
+                        random_context = execution_context.create_context(name)
+                        iterator = _check_name_for_execution(
+                            inference_state,
+                            random_context,
+                            compare_node,
+                            name,
+                            trailer
+                        )
+                        for arguments in iterator:
+                            yield arguments

jedi/inference/filters.py

@@ -0,0 +1,355 @@
+"""
+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.inference import flow_analysis
+from jedi.inference.base_value import ValueSet, ValueWrapper, \
+    LazyValueWrapper
+from jedi.parser_utils import get_cached_parent_scope
+from jedi.inference.utils import to_list
+from jedi.inference.names import TreeNameDefinition, ParamName, \
+    AnonymousParamName, 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(include_setitem=True)
+        )
+        return result
+
+
+class AbstractUsedNamesFilter(AbstractFilter):
+    name_class = TreeNameDefinition
+
+    def __init__(self, parent_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.parent_context = parent_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.parent_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.parent_context)
+
+
+class ParserTreeFilter(AbstractUsedNamesFilter):
+    def __init__(self, parent_context, node_context=None, until_position=None,
+                 origin_scope=None):
+        """
+        node_context is an option to specify a second value for use cases
+        like the class mro where the parent class of a new name would be the
+        value, but for some type inference it's important to have a local
+        value of the other classes.
+        """
+        if node_context is None:
+            node_context = parent_context
+        super(ParserTreeFilter, self).__init__(parent_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,
+                value_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):
+    def __init__(self, parent_context, function_value, until_position, origin_scope):
+        super(_FunctionExecutionFilter, self).__init__(
+            parent_context,
+            until_position=until_position,
+            origin_scope=origin_scope,
+        )
+        self._function_value = function_value
+
+    def _convert_param(self, param, name):
+        raise NotImplementedError
+
+    @to_list
+    def _convert_names(self, names):
+        for name in names:
+            param = search_ancestor(name, 'param')
+            # Here we don't need to check if the param is a default/annotation,
+            # because those are not definitions and never make it to this
+            # point.
+            if param:
+                yield self._convert_param(param, name)
+            else:
+                yield TreeNameDefinition(self.parent_context, name)
+
+
+class FunctionExecutionFilter(_FunctionExecutionFilter):
+    def __init__(self, *args, **kwargs):
+        self._arguments = kwargs.pop('arguments')  # Python 2
+        super(FunctionExecutionFilter, self).__init__(*args, **kwargs)
+
+    def _convert_param(self, param, name):
+        return ParamName(self._function_value, name, self._arguments)
+
+
+class AnonymousFunctionExecutionFilter(_FunctionExecutionFilter):
+    def _convert_param(self, param, name):
+        return AnonymousParamName(self._function_value, name)
+
+
+class GlobalNameFilter(AbstractUsedNamesFilter):
+    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(ValueWrapper):
+    """``Generator.__next__`` ``dict.values`` methods and so on."""
+    api_type = u'function'
+
+    def __init__(self, value, method, builtin_func):
+        super(_BuiltinMappedMethod, self).__init__(builtin_func)
+        self._value = value
+        self._method = method
+
+    def py__call__(self, arguments):
+        # TODO add TypeError if params are given/or not correct.
+        return self._method(self._value)
+
+
+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_value):
+            callable_, python_version = value
+            if python_version is not None and \
+                    python_version != parent_context.inference_state.environment.version_info.major:
+                raise KeyError
+
+            self.parent_context = parent_context
+            self.string_name = string_name
+            self._callable = callable_
+            self._builtin_value = builtin_value
+
+        def infer(self):
+            for filter in self._builtin_value.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 ValueSet([
+                _BuiltinMappedMethod(self.parent_context, self._callable, builtin_func)
+            ])
+
+    def __init__(self, value, dct, builtin_value):
+        super(SpecialMethodFilter, self).__init__(dct)
+        self.value = value
+        self._builtin_value = builtin_value
+        """
+        This value is what will be used to introspect the name, where as the
+        other value will be used to execute the function.
+
+        We distinguish, because we have to.
+        """
+
+    def _convert(self, name, value):
+        return self.SpecialMethodName(self.value, name, value, self._builtin_value)
+
+
+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, *args, **kwargs):
+        yield SpecialMethodFilter(self, self.overwritten_methods, self._wrapped_value)
+
+        for filter in self._wrapped_value.get_filters():
+            yield filter
+
+
+class LazyAttributeOverwrite(use_metaclass(_OverwriteMeta, _AttributeOverwriteMixin,
+                                           LazyValueWrapper)):
+    def __init__(self, inference_state):
+        self.inference_state = inference_state
+
+
+class AttributeOverwrite(use_metaclass(_OverwriteMeta, _AttributeOverwriteMixin,
+                                       ValueWrapper)):
+    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

jedi/inference/finder.py

@@ -0,0 +1,146 @@
+"""
+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.tree import search_ancestor
+from parso.python.tree import Name
+
+from jedi import settings
+from jedi.inference.arguments import TreeArguments
+from jedi.inference.value import iterable
+from jedi.inference.base_value import NO_VALUES
+from jedi.parser_utils import is_scope
+
+
+def filter_name(filters, name_or_str):
+    """
+    Searches names that are defined in a scope (the different
+    ``filters``), until a name fits.
+    """
+    string_name = name_or_str.value if isinstance(name_or_str, Name) else name_or_str
+    names = []
+    for filter in filters:
+        names = filter.get(string_name)
+        if names:
+            break
+
+    return list(_remove_del_stmt(names))
+
+
+def _remove_del_stmt(names):
+    # Catch del statements and remove them from results.
+    for name in names:
+        if name.tree_name is not None:
+            definition = name.tree_name.get_definition()
+            if definition is not None and definition.type == 'del_stmt':
+                continue
+        yield name
+
+
+def check_flow_information(value, 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(value, 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(value, if_test, search_name)
+    return result
+
+
+def _get_isinstance_trailer_arglist(node):
+    if node.type in ('power', 'atom_expr') and len(node.children) == 2:
+        # This might be removed if we analyze and, etc
+        first, trailer = node.children
+        if first.type == 'name' and first.value == 'isinstance' \
+                and trailer.type == 'trailer' and trailer.children[0] == '(':
+            return trailer
+    return None
+
+
+def _check_isinstance_type(value, node, search_name):
+    lazy_cls = None
+    trailer = _get_isinstance_trailer_arglist(node)
+    if trailer is not None and len(trailer.children) == 3:
+        arglist = trailer.children[1]
+        args = TreeArguments(value.inference_state, value, arglist, trailer)
+        param_list = list(args.unpack())
+        # Disallow keyword arguments
+        if len(param_list) == 2 and len(arglist.children) == 3:
+            (key1, _), (key2, lazy_value_cls) = param_list
+            if key1 is None and key2 is None:
+                call = _get_call_string(search_name)
+                is_instance_call = _get_call_string(arglist.children[0])
+                # Do a simple get_code comparison of the strings . They should
+                # just have the same code, and everything will be all right.
+                # There are ways that this is not correct, if some stuff is
+                # redefined in between. However here we don't care, because
+                # it's a heuristic that works pretty well.
+                if call == is_instance_call:
+                    lazy_cls = lazy_value_cls
+    if lazy_cls is None:
+        return None
+
+    value_set = NO_VALUES
+    for cls_or_tup in lazy_cls.infer():
+        if isinstance(cls_or_tup, iterable.Sequence) and cls_or_tup.array_type == 'tuple':
+            for lazy_value in cls_or_tup.py__iter__():
+                value_set |= lazy_value.infer().execute_with_values()
+        else:
+            value_set |= cls_or_tup.execute_with_values()
+    return value_set
+
+
+def _get_call_string(node):
+    if node.parent.type == 'atom_expr':
+        return _get_call_string(node.parent)
+
+    code = ''
+    leaf = node.get_first_leaf()
+    end = node.get_last_leaf().end_pos
+    while leaf.start_pos < end:
+        code += leaf.value
+        leaf = leaf.get_next_leaf()
+    return code

jedi/inference/flow_analysis.py

@@ -1,5 +1,6 @@
 from jedi.parser_utils import get_flow_branch_keyword, is_scope, get_parent_scope
-from jedi.evaluate.recursion import execution_allowed
+from jedi.inference.recursion import execution_allowed
+from jedi.inference.helpers import is_big_annoying_library
 
 
 class Status(object):
@@ -41,7 +42,11 @@ def _get_flow_scopes(node):
         yield node
 
 
-def reachability_check(context, context_scope, node, origin_scope=None):
+def reachability_check(context, value_scope, node, origin_scope=None):
+    if is_big_annoying_library(context) \
+            or not context.inference_state.flow_analysis_enabled:
+        return UNSURE
+
     first_flow_scope = get_parent_scope(node, include_flows=True)
     if origin_scope is not None:
         origin_flow_scopes = list(_get_flow_scopes(origin_scope))
@@ -60,7 +65,8 @@ def reachability_check(context, context_scope, node, origin_scope=None):
                     if not branch_matches and origin_keyword == 'else' \
                             and node_keyword == 'except':
                         return UNREACHABLE
-                break
+                if branch_matches:
+                    break
 
         # Direct parents get resolved, we filter scopes that are separate
         # branches.  This makes sense for autocompletion and static analysis.
@@ -74,10 +80,10 @@ def reachability_check(context, context_scope, node, origin_scope=None):
                 return REACHABLE
             origin_scope = origin_scope.parent
 
-    return _break_check(context, context_scope, first_flow_scope, node)
+    return _break_check(context, value_scope, first_flow_scope, node)
 
 
-def _break_check(context, context_scope, flow_scope, node):
+def _break_check(context, value_scope, flow_scope, node):
     reachable = REACHABLE
     if flow_scope.type == 'if_stmt':
         if flow_scope.is_node_after_else(node):
@@ -97,19 +103,19 @@ def _break_check(context, context_scope, flow_scope, node):
     if reachable in (UNREACHABLE, UNSURE):
         return reachable
 
-    if context_scope != flow_scope and context_scope != flow_scope.parent:
+    if value_scope != flow_scope and value_scope != flow_scope.parent:
         flow_scope = get_parent_scope(flow_scope, include_flows=True)
-        return reachable & _break_check(context, context_scope, flow_scope, node)
+        return reachable & _break_check(context, value_scope, flow_scope, node)
     else:
         return reachable
 
 
 def _check_if(context, node):
-    with execution_allowed(context.evaluator, node) as allowed:
+    with execution_allowed(context.inference_state, node) as allowed:
         if not allowed:
             return UNSURE
 
-        types = context.eval_node(node)
+        types = context.infer_node(node)
         values = set(x.py__bool__() for x in types)
         if len(values) == 1:
             return Status.lookup_table[values.pop()]

jedi/inference/gradual/annotation.py

@@ -0,0 +1,477 @@
+"""
+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, Parameter
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference.gradual.base import DefineGenericBase, GenericClass
+from jedi.inference.gradual.generics import TupleGenericManager
+from jedi.inference.gradual.typing import TypingClassValueWithIndex
+from jedi.inference.gradual.type_var import TypeVar
+from jedi.inference.helpers import is_string
+from jedi.inference.compiled import builtin_from_name
+from jedi.inference.param import get_executed_param_names
+from jedi import debug
+from jedi import parser_utils
+
+
+def infer_annotation(context, annotation):
+    """
+    Inferes an annotation node. This means that it inferes the part of
+    `int` here:
+
+        foo: int = 3
+
+    Also checks for forward references (strings)
+    """
+    value_set = context.infer_node(annotation)
+    if len(value_set) != 1:
+        debug.warning("Inferred typing index %s should lead to 1 object, "
+                      " not %s" % (annotation, value_set))
+        return value_set
+
+    inferred_value = list(value_set)[0]
+    if is_string(inferred_value):
+        result = _get_forward_reference_node(context, inferred_value.get_safe_value())
+        if result is not None:
+            return context.infer_node(result)
+    return value_set
+
+
+def _infer_annotation_string(context, string, index=None):
+    node = _get_forward_reference_node(context, string)
+    if node is None:
+        return NO_VALUES
+
+    value_set = context.infer_node(node)
+    if index is not None:
+        value_set = value_set.filter(
+            lambda value: value.array_type == u'tuple'  # noqa
+                            and len(list(value.py__iter__())) >= index
+        ).py__simple_getitem__(index)
+    return value_set
+
+
+def _get_forward_reference_node(context, string):
+    try:
+        new_node = context.inference_state.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 in ['name', 'atom_expr', 'power']:
+        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
+
+
+@inference_state_method_cache()
+def infer_param(function_value, param, ignore_stars=False):
+    values = _infer_param(function_value, param)
+    if ignore_stars:
+        return values
+    inference_state = function_value.inference_state
+    if param.star_count == 1:
+        tuple_ = builtin_from_name(inference_state, 'tuple')
+        return ValueSet([GenericClass(
+            tuple_,
+            TupleGenericManager((values,)),
+        ) for c in values])
+    elif param.star_count == 2:
+        dct = builtin_from_name(inference_state, 'dict')
+        generics = (
+            ValueSet([builtin_from_name(inference_state, 'str')]),
+            values
+        )
+        return ValueSet([GenericClass(
+            dct,
+            TupleGenericManager(generics),
+        ) for c in values])
+        pass
+    return values
+
+
+def _infer_param(function_value, 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_VALUES
+
+        match = re.match(r"^#\s*type:\s*\(([^#]*)\)\s*->", comment)
+        if not match:
+            return NO_VALUES
+        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
+            )
+        if function_value.is_bound_method():
+            if index == 0:
+                # Assume it's self, which is already handled
+                return NO_VALUES
+            index -= 1
+        if index >= len(params_comments):
+            return NO_VALUES
+
+        param_comment = params_comments[index]
+        return _infer_annotation_string(
+            function_value.get_default_param_context(),
+            param_comment
+        )
+    # Annotations are like default params and resolve in the same way.
+    context = function_value.get_default_param_context()
+    return infer_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
+
+
+@inference_state_method_cache()
+def infer_return_types(function, arguments):
+    """
+    Infers the type of a function's return value,
+    according to type annotations.
+    """
+    all_annotations = py__annotations__(function.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.tree_node
+        comment = parser_utils.get_following_comment_same_line(node)
+        if comment is None:
+            return NO_VALUES
+
+        match = re.match(r"^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)", comment)
+        if not match:
+            return NO_VALUES
+
+        return _infer_annotation_string(
+            function.get_default_param_context(),
+            match.group(1).strip()
+        ).execute_annotation()
+        if annotation is None:
+            return NO_VALUES
+
+    context = function.get_default_param_context()
+    unknown_type_vars = find_unknown_type_vars(context, annotation)
+    annotation_values = infer_annotation(context, annotation)
+    if not unknown_type_vars:
+        return annotation_values.execute_annotation()
+
+    type_var_dict = infer_type_vars_for_execution(function, arguments, all_annotations)
+
+    return ValueSet.from_sets(
+        ann.define_generics(type_var_dict)
+        if isinstance(ann, (DefineGenericBase, TypeVar)) else ValueSet({ann})
+        for ann in annotation_values
+    ).execute_annotation()
+
+
+def infer_type_vars_for_execution(function, arguments, 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 = function.get_default_param_context()
+
+    annotation_variable_results = {}
+    executed_param_names = get_executed_param_names(function, arguments)
+    for executed_param_name in executed_param_names:
+        try:
+            annotation_node = annotation_dict[executed_param_name.string_name]
+        except KeyError:
+            continue
+
+        annotation_variables = find_unknown_type_vars(context, annotation_node)
+        if annotation_variables:
+            # Infer unknown type var
+            annotation_value_set = context.infer_node(annotation_node)
+            kind = executed_param_name.get_kind()
+            actual_value_set = executed_param_name.infer()
+            if kind is Parameter.VAR_POSITIONAL:
+                actual_value_set = actual_value_set.merge_types_of_iterate()
+            elif kind is Parameter.VAR_KEYWORD:
+                # TODO _dict_values is not public.
+                actual_value_set = actual_value_set.try_merge('_dict_values')
+            for ann in annotation_value_set:
+                _merge_type_var_dicts(
+                    annotation_variable_results,
+                    _infer_type_vars(ann, actual_value_set),
+                )
+    return annotation_variable_results
+
+
+def infer_return_for_callable(arguments, param_values, result_values):
+    result = NO_VALUES
+    for pv in param_values:
+        if pv.array_type == 'list':
+            type_var_dict = infer_type_vars_for_callable(arguments, pv.py__iter__())
+
+            result |= ValueSet.from_sets(
+                v.define_generics(type_var_dict)
+                if isinstance(v, (DefineGenericBase, TypeVar)) else ValueSet({v})
+                for v in result_values
+            ).execute_annotation()
+    return result
+
+
+def infer_type_vars_for_callable(arguments, lazy_params):
+    """
+    Infers type vars for the Calllable class:
+
+        def x() -> Callable[[Callable[..., _T]], _T]: ...
+    """
+    annotation_variable_results = {}
+    for (_, lazy_value), lazy_callable_param in zip(arguments.unpack(), lazy_params):
+        callable_param_values = lazy_callable_param.infer()
+        # Infer unknown type var
+        actual_value_set = lazy_value.infer()
+        for v in callable_param_values:
+            _merge_type_var_dicts(
+                annotation_variable_results,
+                _infer_type_vars(v, actual_value_set),
+            )
+    return annotation_variable_results
+
+
+def _merge_type_var_dicts(base_dict, new_dict):
+    for type_var_name, values in new_dict.items():
+        if values:
+            try:
+                base_dict[type_var_name] |= values
+            except KeyError:
+                base_dict[type_var_name] = values
+
+
+def _infer_type_vars(annotation_value, value_set, is_class_value=False):
+    """
+    This function 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`.
+    """
+    type_var_dict = {}
+    if isinstance(annotation_value, TypeVar):
+        if not is_class_value:
+            return {annotation_value.py__name__(): value_set.py__class__()}
+        return {annotation_value.py__name__(): value_set}
+    elif isinstance(annotation_value, TypingClassValueWithIndex):
+        name = annotation_value.py__name__()
+        if name == 'Type':
+            given = annotation_value.get_generics()
+            if given:
+                for nested_annotation_value in given[0]:
+                    _merge_type_var_dicts(
+                        type_var_dict,
+                        _infer_type_vars(
+                            nested_annotation_value,
+                            value_set,
+                            is_class_value=True,
+                        )
+                    )
+        elif name == 'Callable':
+            given = annotation_value.get_generics()
+            if len(given) == 2:
+                for nested_annotation_value in given[1]:
+                    _merge_type_var_dicts(
+                        type_var_dict,
+                        _infer_type_vars(
+                            nested_annotation_value,
+                            value_set.execute_annotation(),
+                        )
+                    )
+    elif isinstance(annotation_value, GenericClass):
+        name = annotation_value.py__name__()
+        if name == 'Iterable':
+            given = annotation_value.get_generics()
+            if given:
+                for nested_annotation_value in given[0]:
+                    _merge_type_var_dicts(
+                        type_var_dict,
+                        _infer_type_vars(
+                            nested_annotation_value,
+                            value_set.merge_types_of_iterate()
+                        )
+                    )
+        elif name == 'Mapping':
+            given = annotation_value.get_generics()
+            if len(given) == 2:
+                for value in value_set:
+                    try:
+                        method = value.get_mapping_item_values
+                    except AttributeError:
+                        continue
+                    key_values, value_values = method()
+
+                    for nested_annotation_value in given[0]:
+                        _merge_type_var_dicts(
+                            type_var_dict,
+                            _infer_type_vars(
+                                nested_annotation_value,
+                                key_values,
+                            )
+                        )
+                    for nested_annotation_value in given[1]:
+                        _merge_type_var_dicts(
+                            type_var_dict,
+                            _infer_type_vars(
+                                nested_annotation_value,
+                                value_values,
+                            )
+                        )
+    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 _infer_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:
+            found[:] = _filter_type_vars(context.infer_node(node), found)
+
+    found = []  # We're not using a set, because the order matters.
+    check_node(node)
+    return found
+
+
+def _filter_type_vars(value_set, found=()):
+    new_found = list(found)
+    for type_var in value_set:
+        if isinstance(type_var, TypeVar) and type_var not in found:
+            new_found.append(type_var)
+    return new_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/inference/gradual/base.py

@@ -0,0 +1,321 @@
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \
+    iterator_to_value_set, LazyValueWrapper, ValueWrapper
+from jedi.inference.compiled import builtin_from_name
+from jedi.inference.value.klass import ClassFilter
+from jedi.inference.value.klass import ClassMixin
+from jedi.inference.utils import to_list
+from jedi.inference.names import AbstractNameDefinition, ValueName
+from jedi.inference.context import ClassContext
+from jedi.inference.gradual.generics import TupleGenericManager
+
+
+class _BoundTypeVarName(AbstractNameDefinition):
+    """
+    This type var was bound to a certain type, e.g. int.
+    """
+    def __init__(self, type_var, value_set):
+        self._type_var = type_var
+        self.parent_context = type_var.parent_context
+        self._value_set = value_set
+
+    def infer(self):
+        def iter_():
+            for value in self._value_set:
+                # Replace any with the constraints if they are there.
+                from jedi.inference.gradual.typing import Any
+                if isinstance(value, Any):
+                    for constraint in self._type_var.constraints:
+                        yield constraint
+                else:
+                    yield value
+        return ValueSet(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._value_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 _AnnotatedClassContext(ClassContext):
+    def get_filters(self, *args, **kwargs):
+        filters = super(_AnnotatedClassContext, self).get_filters(
+            *args, **kwargs
+        )
+        for f in filters:
+            yield f
+
+        # The type vars can only be looked up if it's a global search and
+        # not a direct lookup on the class.
+        yield self._value.get_type_var_filter()
+
+
+class DefineGenericBase(LazyValueWrapper):
+    def __init__(self, generics_manager):
+        self._generics_manager = generics_manager
+
+    def _create_instance_with_generics(self, generics_manager):
+        raise NotImplementedError
+
+    @inference_state_method_cache()
+    def get_generics(self):
+        return self._generics_manager.to_tuple()
+
+    def define_generics(self, type_var_dict):
+        from jedi.inference.gradual.type_var import TypeVar
+        changed = False
+        new_generics = []
+        for generic_set in self.get_generics():
+            values = NO_VALUES
+            for generic in generic_set:
+                if isinstance(generic, (GenericClass, TypeVar)):
+                    result = generic.define_generics(type_var_dict)
+                    values |= result
+                    if result != ValueSet({generic}):
+                        changed = True
+                else:
+                    values |= ValueSet([generic])
+            new_generics.append(values)
+
+        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 ValueSet([self])
+
+        return ValueSet([self._create_instance_with_generics(
+            TupleGenericManager(tuple(new_generics))
+        )])
+
+    def is_same_class(self, other):
+        if not isinstance(other, DefineGenericBase):
+            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 __repr__(self):
+        return '<%s: %s%s>' % (
+            self.__class__.__name__,
+            self._wrapped_value,
+            list(self.get_generics()),
+        )
+
+
+class GenericClass(ClassMixin, DefineGenericBase):
+    """
+    A class that is defined with generics, might be something simple like:
+
+        class Foo(Generic[T]): ...
+        my_foo_int_cls = Foo[int]
+    """
+    def __init__(self, class_value, generics_manager):
+        super(GenericClass, self).__init__(generics_manager)
+        self._class_value = class_value
+
+    def _get_wrapped_value(self):
+        return self._class_value
+
+    def get_type_var_filter(self):
+        return _TypeVarFilter(self.get_generics(), self.list_type_vars())
+
+    def py__call__(self, arguments):
+        instance, = super(GenericClass, self).py__call__(arguments)
+        return ValueSet([_GenericInstanceWrapper(instance)])
+
+    def _as_context(self):
+        return _AnnotatedClassContext(self)
+
+    @to_list
+    def py__bases__(self):
+        for base in self._wrapped_value.py__bases__():
+            yield _LazyGenericBaseClass(self, base)
+
+    def _create_instance_with_generics(self, generics_manager):
+        return GenericClass(self._class_value, generics_manager)
+
+    def is_sub_class_of(self, class_value):
+        if super(GenericClass, self).is_sub_class_of(class_value):
+            return True
+        return self._class_value.is_sub_class_of(class_value)
+
+
+class _LazyGenericBaseClass(object):
+    def __init__(self, class_value, lazy_base_class):
+        self._class_value = class_value
+        self._lazy_base_class = lazy_base_class
+
+    @iterator_to_value_set
+    def infer(self):
+        for base in self._lazy_base_class.infer():
+            if isinstance(base, GenericClass):
+                # Here we have to recalculate the given types.
+                yield GenericClass.create_cached(
+                    base.inference_state,
+                    base._wrapped_value,
+                    TupleGenericManager(tuple(self._remap_type_vars(base))),
+                )
+            else:
+                yield base
+
+    def _remap_type_vars(self, base):
+        from jedi.inference.gradual.type_var import TypeVar
+        filter = self._class_value.get_type_var_filter()
+        for type_var_set in base.get_generics():
+            new = NO_VALUES
+            for type_var in type_var_set:
+                if isinstance(type_var, TypeVar):
+                    names = filter.get(type_var.py__name__())
+                    new |= ValueSet.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 value set.
+                    new |= ValueSet([type_var])
+            yield new
+
+
+class _GenericInstanceWrapper(ValueWrapper):
+    def py__stop_iteration_returns(self):
+        for cls in self._wrapped_value.class_value.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 ValueSet([builtin_from_name(self.inference_state, u'None')])
+        return self._wrapped_value.py__stop_iteration_returns()
+
+
+class _PseudoTreeNameClass(Value):
+    """
+    In typeshed, some classes are defined like this:
+
+        Tuple: _SpecialForm = ...
+
+    Now this is not a real class, therefore we have to do some workarounds like
+    this class. Essentially this class makes it possible to goto that `Tuple`
+    name, without affecting anything else negatively.
+    """
+    def __init__(self, parent_context, tree_name):
+        super(_PseudoTreeNameClass, self).__init__(
+            parent_context.inference_state,
+            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.inference_state, u'object')
+
+    @property
+    def name(self):
+        return ValueName(self, self._tree_name)
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)
+
+
+class BaseTypingValue(LazyValueWrapper):
+    def __init__(self, parent_context, tree_name):
+        self.inference_state = parent_context.inference_state
+        self.parent_context = parent_context
+        self._tree_name = tree_name
+
+    @property
+    def name(self):
+        return ValueName(self, self._tree_name)
+
+    def _get_wrapped_value(self):
+        return _PseudoTreeNameClass(self.parent_context, self._tree_name)
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)
+
+
+class BaseTypingValueWithGenerics(DefineGenericBase):
+    def __init__(self, parent_context, tree_name, generics_manager):
+        super(BaseTypingValueWithGenerics, self).__init__(generics_manager)
+        self.inference_state = parent_context.inference_state
+        self.parent_context = parent_context
+        self._tree_name = tree_name
+
+    def _get_wrapped_value(self):
+        return _PseudoTreeNameClass(self.parent_context, self._tree_name)
+
+    def __repr__(self):
+        return '%s(%s%s)' % (self.__class__.__name__, self._tree_name.value,
+                             self._generics_manager)

jedi/inference/gradual/conversion.py

@@ -0,0 +1,195 @@
+from jedi import debug
+from jedi.inference.base_value import ValueSet, \
+    NO_VALUES
+from jedi.inference.utils import to_list
+from jedi.inference.gradual.stub_value import StubModuleValue
+
+
+def _stub_to_python_value_set(stub_value, ignore_compiled=False):
+    stub_module_context = stub_value.get_root_context()
+    if not stub_module_context.is_stub():
+        return ValueSet([stub_value])
+
+    was_instance = stub_value.is_instance()
+    if was_instance:
+        stub_value = stub_value.py__class__()
+
+    qualified_names = stub_value.get_qualified_names()
+    if qualified_names is None:
+        return NO_VALUES
+
+    was_bound_method = stub_value.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
+
+    values = _infer_from_stub(stub_module_context, qualified_names, ignore_compiled)
+    if was_instance:
+        values = ValueSet.from_sets(
+            c.execute_with_values()
+            for c in values
+            if c.is_class()
+        )
+    if was_bound_method:
+        # Now that the instance has been properly created, we can simply get
+        # the method.
+        values = values.py__getattribute__(method_name)
+    return values
+
+
+def _infer_from_stub(stub_module_context, qualified_names, ignore_compiled):
+    from jedi.inference.compiled.mixed import MixedObject
+    stub_module = stub_module_context.get_value()
+    assert isinstance(stub_module, (StubModuleValue, MixedObject)), stub_module_context
+    non_stubs = stub_module.non_stub_value_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_context = name.get_root_context()
+        if not module_context.is_stub():
+            yield name
+            continue
+
+        if name.api_type == 'module':
+            values = convert_values(name.infer(), ignore_compiled=prefer_stub_to_compiled)
+            if values:
+                for v in values:
+                    yield v.name
+                continue
+        else:
+            v = name.get_defining_qualified_value()
+            if v is not None:
+                converted = _stub_to_python_value_set(v, ignore_compiled=prefer_stub_to_compiled)
+                if converted:
+                    converted_names = converted.goto(name.get_public_name())
+                    if converted_names:
+                        for n in converted_names:
+                            yield n
+                        continue
+        yield name
+
+
+def _load_stub_module(module):
+    if module.is_stub():
+        return module
+    from jedi.inference.gradual.typeshed import _try_to_load_stub_cached
+    return _try_to_load_stub_cached(
+        module.inference_state,
+        import_names=module.string_names,
+        python_value_set=ValueSet([module]),
+        parent_module_value=None,
+        sys_path=module.inference_state.get_sys_path(),
+    )
+
+
+@to_list
+def _python_to_stub_names(names, fallback_to_python=False):
+    for name in names:
+        module_context = name.get_root_context()
+        if module_context.is_stub():
+            yield name
+            continue
+
+        if name.api_type == 'module':
+            found_name = False
+            for n in name.goto():
+                if n.api_type == 'module':
+                    values = convert_values(n.infer(), only_stubs=True)
+                    for v in values:
+                        yield v.name
+                        found_name = True
+                else:
+                    for x in _python_to_stub_names([n], fallback_to_python=fallback_to_python):
+                        yield x
+                        found_name = True
+            if found_name:
+                continue
+        else:
+            v = name.get_defining_qualified_value()
+            if v is not None:
+                converted = to_stub(v)
+                if converted:
+                    converted_names = converted.goto(name.get_public_name())
+                    if converted_names:
+                        for n in converted_names:
+                            yield n
+                        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, prefer_stub_to_compiled=True):
+    if only_stubs and prefer_stubs:
+        raise ValueError("You cannot use both of 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=prefer_stub_to_compiled)
+
+
+def convert_values(values, only_stubs=False, prefer_stubs=False, ignore_compiled=True):
+    assert not (only_stubs and prefer_stubs)
+    with debug.increase_indent_cm('convert values'):
+        if only_stubs or prefer_stubs:
+            return ValueSet.from_sets(
+                to_stub(value)
+                or (ValueSet({value}) if prefer_stubs else NO_VALUES)
+                for value in values
+            )
+        else:
+            return ValueSet.from_sets(
+                _stub_to_python_value_set(stub_value, ignore_compiled=ignore_compiled)
+                or ValueSet({stub_value})
+                for stub_value in values
+            )
+
+
+def to_stub(value):
+    if value.is_stub():
+        return ValueSet([value])
+
+    was_instance = value.is_instance()
+    if was_instance:
+        value = value.py__class__()
+
+    qualified_names = value.get_qualified_names()
+    stub_module = _load_stub_module(value.get_root_context().get_value())
+    if stub_module is None or qualified_names is None:
+        return NO_VALUES
+
+    was_bound_method = value.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_values = ValueSet([stub_module])
+    for name in qualified_names:
+        stub_values = stub_values.py__getattribute__(name)
+
+    if was_instance:
+        stub_values = ValueSet.from_sets(
+            c.execute_with_values()
+            for c in stub_values
+            if c.is_class()
+        )
+    if was_bound_method:
+        # Now that the instance has been properly created, we can simply get
+        # the method.
+        stub_values = stub_values.py__getattribute__(method_name)
+    return stub_values

jedi/inference/gradual/generics.py

@@ -0,0 +1,98 @@
+"""
+This module is about generics, like the `int` in `List[int]`. It's not about
+the Generic class.
+"""
+
+from jedi import debug
+from jedi.cache import memoize_method
+from jedi.inference.utils import to_tuple
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference.value.iterable import SequenceLiteralValue
+from jedi.inference.helpers import is_string
+
+
+def _resolve_forward_references(context, value_set):
+    for value in value_set:
+        if is_string(value):
+            from jedi.inference.gradual.annotation import _get_forward_reference_node
+            node = _get_forward_reference_node(context, value.get_safe_value())
+            if node is not None:
+                for c in context.infer_node(node):
+                    yield c
+        else:
+            yield value
+
+
+class _AbstractGenericManager(object):
+    def get_index_and_execute(self, index):
+        try:
+            return self[index].execute_annotation()
+        except IndexError:
+            debug.warning('No param #%s found for annotation %s', index, self)
+            return NO_VALUES
+
+
+class LazyGenericManager(_AbstractGenericManager):
+    def __init__(self, context_of_index, index_value):
+        self._context_of_index = context_of_index
+        self._index_value = index_value
+
+    @memoize_method
+    def __getitem__(self, index):
+        return self._tuple()[index]()
+
+    def __len__(self):
+        return len(self._tuple())
+
+    @memoize_method
+    @to_tuple
+    def _tuple(self):
+        def lambda_scoping_in_for_loop_sucks(lazy_value):
+            return lambda: ValueSet(_resolve_forward_references(
+                self._context_of_index,
+                lazy_value.infer()
+            ))
+
+        if isinstance(self._index_value, SequenceLiteralValue):
+            for lazy_value in self._index_value.py__iter__(contextualized_node=None):
+                yield lambda_scoping_in_for_loop_sucks(lazy_value)
+        else:
+            yield lambda: ValueSet(_resolve_forward_references(
+                self._context_of_index,
+                ValueSet([self._index_value])
+            ))
+
+    @to_tuple
+    def to_tuple(self):
+        for callable_ in self._tuple():
+            yield callable_()
+
+    def is_homogenous_tuple(self):
+        if isinstance(self._index_value, SequenceLiteralValue):
+            entries = self._index_value.get_tree_entries()
+            if len(entries) == 2 and entries[1] == '...':
+                return True
+        return False
+
+    def __repr__(self):
+        return '<LazyG>[%s]' % (', '.join(repr(x) for x in self.to_tuple()))
+
+
+class TupleGenericManager(_AbstractGenericManager):
+    def __init__(self, tup):
+        self._tuple = tup
+
+    def __getitem__(self, index):
+        return self._tuple[index]
+
+    def __len__(self):
+        return len(self._tuple)
+
+    def to_tuple(self):
+        return self._tuple
+
+    def is_homogenous_tuple(self):
+        return False
+
+    def __repr__(self):
+        return '<TupG>[%s]' % (', '.join(repr(x) for x in self.to_tuple()))