Revert 3.7 AST fix

Also start testing on 3.7-dev and build docs on 3.7

.travis.yml

@@ -1,58 +1,59 b''
 # http://travis-ci.org/#!/ipython/ipython
 language: python
 python:
     - 3.6
     - 3.5
 sudo: false
 env:
   global:
     - PATH=$TRAVIS_BUILD_DIR/pandoc:$PATH
 group: edge
 before_install:
     - 'if [[ $GROUP != js* ]]; then COVERAGE=""; fi'
 install:
     - pip install pip --upgrade
     - pip install setuptools --upgrade
     - pip install -e file://$PWD#egg=ipython[test] --upgrade
     - pip install trio curio
     - pip install codecov check-manifest --upgrade
     - sudo apt-get install graphviz
 script:
     - check-manifest
     - cd /tmp && iptest --coverage xml && cd -
     # On the latest Python only, make sure that the docs build.
     - |
-      if [[ "$TRAVIS_PYTHON_VERSION" == "3.6" ]]; then
+      if [[ "$TRAVIS_PYTHON_VERSION" == "3.7" ]]; then
         pip install -r docs/requirements.txt
         python tools/fixup_whats_new_pr.py
         make -C docs/ html SPHINXOPTS="-W"
       fi
 after_success:
     - cp /tmp/ipy_coverage.xml ./
     - cp /tmp/.coverage ./
     - codecov
 
 matrix:
     include:
         - { python: "3.7", dist: xenial, sudo: true }
+        - { python: "3.7-dev", dist: xenial, sudo: true }
         - { python: "nightly", dist: xenial, sudo: true }
     allow_failures:
         - python: nightly
 
 before_deploy:
     - rm -rf dist/
     - python setup.py sdist
     - python setup.py bdist_wheel
 
 deploy:
     provider: releases
     api_key:
         secure: Y/Ae9tYs5aoBU8bDjN2YrwGG6tCbezj/h3Lcmtx8HQavSbBgXnhnZVRb2snOKD7auqnqjfT/7QMm4ZyKvaOEgyggGktKqEKYHC8KOZ7yp8I5/UMDtk6j9TnXpSqqBxPiud4MDV76SfRYEQiaDoG4tGGvSfPJ9KcNjKrNvSyyxns=
     file: dist/*
     file_glob: true
     skip_cleanup: true
     on:
         repo: ipython/ipython
         all_branches: true  # Backports are released from e.g. 5.x branch
         tags: true
         python: 3.6  # Any version should work, but we only need one

IPython/core/compilerop.py

@@ -1,161 +1,144 b''
 """Compiler tools with improved interactive support.
 
 Provides compilation machinery similar to codeop, but with caching support so
 we can provide interactive tracebacks.
 
 Authors
 -------
 * Robert Kern
 * Fernando Perez
 * Thomas Kluyver
 """
 
 # Note: though it might be more natural to name this module 'compiler', that
 # name is in the stdlib and name collisions with the stdlib tend to produce
 # weird problems (often with third-party tools).
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-2011 The IPython Development Team.
 #
 #  Distributed under the terms of the BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import __future__
 from ast import PyCF_ONLY_AST
 import codeop
 import functools
 import hashlib
 import linecache
 import operator
 import time
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 # Roughly equal to PyCF_MASK | PyCF_MASK_OBSOLETE as defined in pythonrun.h,
 # this is used as a bitmask to extract future-related code flags.
 PyCF_MASK = functools.reduce(operator.or_,
                              (getattr(__future__, fname).compiler_flag
                               for fname in __future__.all_feature_names))
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 
 def code_name(code, number=0):
     """ Compute a (probably) unique name for code for caching.
 
     This now expects code to be unicode.
     """
     hash_digest = hashlib.sha1(code.encode("utf-8")).hexdigest()
     # Include the number and 12 characters of the hash in the name.  It's
     # pretty much impossible that in a single session we'll have collisions
     # even with truncated hashes, and the full one makes tracebacks too long
     return '<ipython-input-{0}-{1}>'.format(number, hash_digest[:12])
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class CachingCompiler(codeop.Compile):
     """A compiler that caches code compiled from interactive statements.
     """
 
     def __init__(self):
         codeop.Compile.__init__(self)
 
         # This is ugly, but it must be done this way to allow multiple
         # simultaneous ipython instances to coexist.  Since Python itself
         # directly accesses the data structures in the linecache module, and
         # the cache therein is global, we must work with that data structure.
         # We must hold a reference to the original checkcache routine and call
         # that in our own check_cache() below, but the special IPython cache
         # must also be shared by all IPython instances.  If we were to hold
         # separate caches (one in each CachingCompiler instance), any call made
         # by Python itself to linecache.checkcache() would obliterate the
         # cached data from the other IPython instances.
         if not hasattr(linecache, '_ipython_cache'):
             linecache._ipython_cache = {}
         if not hasattr(linecache, '_checkcache_ori'):
             linecache._checkcache_ori = linecache.checkcache
         # Now, we must monkeypatch the linecache directly so that parts of the
         # stdlib that call it outside our control go through our codepath
         # (otherwise we'd lose our tracebacks).
         linecache.checkcache = check_linecache_ipython
 
 
-    def _fix_module_ds(self, module):
-        """
-        Starting in python 3.7 the AST for mule have changed, and if
-        the first expressions encountered is a string it is attached to the
-        `docstring` attribute of the `Module` ast node.
-
-        This breaks IPython, as if this string is the only expression, IPython
-        will not return it as the result of the current cell.
-        """
-        from ast import Str, Expr, Module, fix_missing_locations
-        docstring = getattr(module, 'docstring', None)
-        if not docstring:
-            return module
-        new_body=[Expr(Str(docstring, lineno=1, col_offset=0), lineno=1, col_offset=0)]
-        new_body.extend(module.body)
-        return fix_missing_locations(Module(new_body))
-
     def ast_parse(self, source, filename='<unknown>', symbol='exec'):
         """Parse code to an AST with the current compiler flags active.
 
         Arguments are exactly the same as ast.parse (in the standard library),
         and are passed to the built-in compile function."""
-        return self._fix_module_ds(compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1))
-
+        return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1)
+    
     def reset_compiler_flags(self):
         """Reset compiler flags to default state."""
         # This value is copied from codeop.Compile.__init__, so if that ever
         # changes, it will need to be updated.
         self.flags = codeop.PyCF_DONT_IMPLY_DEDENT
 
     @property
     def compiler_flags(self):
         """Flags currently active in the compilation process.
         """
         return self.flags
 
     def cache(self, code, number=0):
         """Make a name for a block of code, and cache the code.
 
         Parameters
         ----------
         code : str
           The Python source code to cache.
         number : int
           A number which forms part of the code's name. Used for the execution
           counter.
 
         Returns
         -------
         The name of the cached code (as a string). Pass this as the filename
         argument to compilation, so that tracebacks are correctly hooked up.
         """
         name = code_name(code, number)
         entry = (len(code), time.time(),
                  [line+'\n' for line in code.splitlines()], name)
         linecache.cache[name] = entry
         linecache._ipython_cache[name] = entry
         return name
 
 def check_linecache_ipython(*args):
     """Call linecache.checkcache() safely protecting our cached values.
     """
     # First call the original checkcache as intended
     linecache._checkcache_ori(*args)
     # Then, update back the cache with our data, so that tracebacks related
     # to our compiled codes can be produced.
     linecache.cache.update(linecache._ipython_cache)