Allow passing a custom CachingCompiler to the interactive shell

This permits to customize the filename computation prior to
caching/compiling.

IPython/core/compilerop.py

@@ -112,25 +112,53 b' class CachingCompiler(codeop.Compile):'
         """
         return self.flags
 
-    def cache(self, code, number=0):
+    def get_code_name(self, raw_code, transformed_code, number):
+        """Compute filename given the code, and the cell number.
+
+        Parameters
+        ----------
+        raw_code : str
+          The raw cell code.
+        transformed_code : str
+          The executable Python source code to cache and compile.
+        number : int
+          A number which forms part of the code's name. Used for the execution
+          counter.
+
+        Returns
+        -------
+        The computed filename.
+        """
+        return code_name(transformed_code, number)
+
+    def cache(self, transformed_code, number=0, raw_code=None):
         """Make a name for a block of code, and cache the code.
 
         Parameters
         ----------
-        code : str
-          The Python source code to cache.
+        transformed_code : str
+          The executable Python source code to cache and compile.
         number : int
           A number which forms part of the code's name. Used for the execution
           counter.
+        raw_code : str
+          The raw code before transformation, if None, set to `transformed_code`.
 
         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)
+        if raw_code is None:
+            raw_code = transformed_code
+
+        name = self.get_code_name(raw_code, transformed_code, number)
+        entry = (
+            len(transformed_code),
+            time.time(),
+            [line + "\n" for line in transformed_code.splitlines()],
+            name,
+        )
         linecache.cache[name] = entry
         linecache._ipython_cache[name] = entry
         return name

IPython/core/interactiveshell.py

@@ -443,6 +443,7 b' class InteractiveShell(SingletonConfigurable):'
     display_formatter = Instance(DisplayFormatter, allow_none=True)
     displayhook_class = Type(DisplayHook)
     display_pub_class = Type(DisplayPublisher)
+    compiler_class = Type(CachingCompiler)
 
     sphinxify_docstring = Bool(False, help=
         """
@@ -748,7 +749,7 b' class InteractiveShell(SingletonConfigurable):'
         self.more = False
 
         # command compiler
-        self.compile = CachingCompiler()
+        self.compile = self.compiler_class()
 
         # Make an empty namespace, which extension writers can rely on both
         # existing and NEVER being used by ipython itself.  This gives them a
@@ -1775,8 +1776,14 b' class InteractiveShell(SingletonConfigurable):'
             if meth == 'pdoc':
                 pmethod(info.obj, oname, formatter)
             elif meth == 'pinfo':
-                pmethod(info.obj, oname, formatter, info, 
-                        enable_html_pager=self.enable_html_pager, **kw)
+                pmethod(
+                    info.obj,
+                    oname,
+                    formatter,
+                    info,
+                    enable_html_pager=self.enable_html_pager,
+                    **kw
+                )
             else:
                 pmethod(info.obj, oname)
         else:
@@ -2299,8 +2306,9 b' class InteractiveShell(SingletonConfigurable):'
     # Defined here so that it's included in the documentation
     @functools.wraps(magic.MagicsManager.register_function)
     def register_magic_function(self, func, magic_kind='line', magic_name=None):
-        self.magics_manager.register_function(func, 
-                                  magic_kind=magic_kind, magic_name=magic_name)
+        self.magics_manager.register_function(
+            func, magic_kind=magic_kind, magic_name=magic_name
+        )
 
     def run_line_magic(self, magic_name, line, _stack_depth=1):
         """Execute the given line magic.
@@ -3096,12 +3104,14 b' class InteractiveShell(SingletonConfigurable):'
         # Our own compiler remembers the __future__ environment. If we want to
         # run code with a separate __future__ environment, use the default
         # compiler
-        compiler = self.compile if shell_futures else CachingCompiler()
+        compiler = self.compile if shell_futures else self.compiler_class()
 
         _run_async = False
 
         with self.builtin_trap:
-            cell_name = self.compile.cache(cell, self.execution_count)
+            cell_name = self.compile.cache(
+                cell, self.execution_count, raw_code=raw_cell
+            )
 
             with self.display_trap:
                 # Compile to bytecode