Remove the module attribute from the parser.

jedi/api/__init__.py

@@ -136,7 +136,7 @@ class Script(object):
         parser = FastParser(self._grammar, self._source, self.path)
         save_parser(self.path, parser, pickling=False)
 
-        return parser.module
+        return parser.get_root_node()
 
     @cache.memoize_method
     def _get_module(self):

jedi/evaluate/compiled/mixed.py

@@ -123,7 +123,7 @@ def parse(grammar, path):
 
 
 def _load_module(evaluator, path, python_object):
-    module = parse(evaluator.grammar, path).module
+    module = parse(evaluator.grammar, path).get_root_node()
     python_module = inspect.getmodule(python_object)
 
     evaluator.modules[python_module.__name__] = module

jedi/evaluate/imports.py

@@ -461,13 +461,13 @@ def _load_module(evaluator, path=None, source=None, sys_path=None, parent_module
         p = path
         p = FastParser(evaluator.grammar, source_to_unicode(source), p)
         save_parser(path, p)
-        return p.module
+        return p.get_root_node()
 
     if sys_path is None:
         sys_path = evaluator.sys_path
 
     cached = load_parser(path)
-    module_node = load(source) if cached is None else cached.module
+    module_node = load(source) if cached is None else cached.get_root_node()
     if isinstance(module_node, compiled.CompiledObject):
         return module_node
 
@@ -499,7 +499,8 @@ def get_modules_containing_name(evaluator, modules, name):
             except IOError:
                 return None
         else:
-            return er.ModuleContext(evaluator, parser_cache_item.parser.module)
+            module_node = parser_cache_item.parser.get_root_node()
+            return er.ModuleContext(evaluator, module_node)
 
     def check_fs(path):
         with open(path, 'rb') as f:

jedi/evaluate/stdlib.py

@@ -19,7 +19,7 @@ from jedi.evaluate import representation as er
 from jedi.evaluate.instance import InstanceFunctionExecution, \
     AbstractInstanceContext, CompiledInstance, BoundMethod
 from jedi.evaluate import iterable
-from jedi.parser import ParserWithRecovery
+from jedi.parser.python import parse
 from jedi import debug
 from jedi.evaluate import precedence
 from jedi.evaluate import param
@@ -265,7 +265,7 @@ def collections_namedtuple(evaluator, obj, arguments):
     )
 
     # Parse source
-    generated_class = ParserWithRecovery(evaluator.grammar, unicode(source)).module.subscopes[0]
+    generated_class = parse(source, grammar=evaluator.grammar).subscopes[0]
     return set([er.ClassContext(evaluator, generated_class, evaluator.BUILTINS)])
 
 

jedi/evaluate/sys_path.py

@@ -222,7 +222,7 @@ def _get_paths_from_buildout_script(evaluator, buildout_script):
 
         p = ParserWithRecovery(evaluator.grammar, source, buildout_script)
         save_parser(buildout_script, p)
-        return p.module
+        return p.get_root_node()
 
     cached = load_parser(buildout_script)
     module_node = cached and cached.module or load(buildout_script)

jedi/parser/python/parser.py

@@ -197,7 +197,6 @@ class ParserWithRecovery(Parser):
     def parse(self, tokenizer):
         root_node = super(ParserWithRecovery, self).parse(self._tokenize(tokenizer))
         root_node.path = self._module_path
-        self.module = root_node
         return root_node
 
     def error_recovery(self, grammar, stack, arcs, typ, value, start_pos, prefix,

jedi/parser/python/tree.py

@@ -16,14 +16,14 @@ The easiest way to play with this module is to use :class:`parsing.Parser`.
 >>> from jedi.parser.python import load_grammar
 >>> from jedi.parser import ParserWithRecovery
 >>> parser = ParserWithRecovery(load_grammar(), u('import os'), 'example.py')
->>> submodule = parser.module
->>> submodule
+>>> module = parser.get_root_node()
+>>> module
 <Module: example.py@1-1>
 
 Any subclasses of :class:`Scope`, including :class:`Module` has an attribute
 :attr:`imports <Scope.imports>`:
 
->>> submodule.imports
+>>> module.imports
 [<ImportName: import os@1,0>]
 
 See also :attr:`Scope.subscopes` and :attr:`Scope.statements`.