From ef4b424cdac693df2bb6fb41da7e28ae523279b6 Mon Sep 17 00:00:00 2001
From: Dave Halter <davidhalter88@gmail.com>
Date: Tue, 28 Apr 2015 01:34:31 +0200
Subject: [PATCH] Replace pr with tree, #566.

---
 jedi/evaluate/__init__.py       | 42 +++++++++++++-------------
 jedi/evaluate/analysis.py       | 16 +++++-----
 jedi/evaluate/dynamic.py        | 10 +++----
 jedi/evaluate/finder.py         | 52 ++++++++++++++++-----------------
 jedi/evaluate/flow_analysis.py  |  6 ++--
 jedi/evaluate/helpers.py        | 16 +++++-----
 jedi/evaluate/imports.py        | 14 ++++-----
 jedi/evaluate/iterable.py       | 16 +++++-----
 jedi/evaluate/param.py          | 22 +++++++-------
 jedi/evaluate/precedence.py     |  4 +--
 jedi/evaluate/representation.py | 50 +++++++++++++++----------------
 jedi/evaluate/stdlib.py         | 12 ++++----
 jedi/evaluate/sys_path.py       | 16 +++++-----
 13 files changed, 138 insertions(+), 138 deletions(-)

diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 4c96e4f2..4c2951ef 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -63,7 +63,7 @@ that are not used are just being ignored.
 import copy
 from itertools import chain
 
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi import debug
 from jedi.evaluate import representation as er
 from jedi.evaluate import imports
@@ -91,14 +91,14 @@ class Evaluator(object):
         self.analysis = []
 
     def wrap(self, element):
-        if isinstance(element, pr.Class):
+        if isinstance(element, tree.Class):
             return er.Class(self, element)
-        elif isinstance(element, pr.Function):
-            if isinstance(element, pr.Lambda):
+        elif isinstance(element, tree.Function):
+            if isinstance(element, tree.Lambda):
                 return er.LambdaWrapper(self, element)
             else:
                 return er.Function(self, element)
-        elif isinstance(element, (pr.Module)) \
+        elif isinstance(element, (tree.Module)) \
                 and not isinstance(element, er.ModuleWrapper):
             return er.ModuleWrapper(self, element)
         else:
@@ -130,7 +130,7 @@ class Evaluator(object):
         names are defined in the statement, `seek_name` returns the result for
         this name.
 
-        :param stmt: A `pr.ExprStmt`.
+        :param stmt: A `tree.ExprStmt`.
         """
         debug.dbg('eval_statement %s (%s)', stmt, seek_name)
         types = self.eval_element(stmt.get_rhs())
@@ -146,7 +146,7 @@ class Evaluator(object):
             name = str(stmt.get_defined_names()[0])
             parent = self.wrap(stmt.get_parent_scope())
             left = self.find_types(parent, name, stmt.start_pos, search_global=True)
-            if isinstance(stmt.get_parent_until(pr.ForStmt), pr.ForStmt):
+            if isinstance(stmt.get_parent_until(tree.ForStmt), tree.ForStmt):
                 # Iterate through result and add the values, that's possible
                 # only in for loops without clutter, because they are
                 # predictable.
@@ -166,15 +166,15 @@ class Evaluator(object):
             return iterable.unite(self.eval_element(e) for e in element)
 
         debug.dbg('eval_element %s@%s', element, element.start_pos)
-        if isinstance(element, (pr.Name, pr.Literal)) or pr.is_node(element, 'atom'):
+        if isinstance(element, (tree.Name, tree.Literal)) or tree.is_node(element, 'atom'):
             return self._eval_atom(element)
-        elif isinstance(element, pr.Keyword):
+        elif isinstance(element, tree.Keyword):
             # For False/True/None
             if element.value in ('False', 'True', 'None'):
                 return [compiled.builtin.get_by_name(element.value)]
             else:
                 return []
-        elif element.isinstance(pr.Lambda):
+        elif element.isinstance(tree.Lambda):
             return [er.LambdaWrapper(self, element)]
         elif element.isinstance(er.LambdaWrapper):
             return [element]  # TODO this is no real evaluation.
@@ -218,24 +218,24 @@ class Evaluator(object):
         generate the node (because it has just one child). In that case an atom
         might be a name or a literal as well.
         """
-        if isinstance(atom, pr.Name):
+        if isinstance(atom, tree.Name):
             # This is the first global lookup.
             stmt = atom.get_definition()
-            scope = stmt.get_parent_until(pr.IsScope, include_current=True)
-            if isinstance(stmt, pr.CompFor):
-                stmt = stmt.get_parent_until((pr.ClassOrFunc, pr.ExprStmt))
+            scope = stmt.get_parent_until(tree.IsScope, include_current=True)
+            if isinstance(stmt, tree.CompFor):
+                stmt = stmt.get_parent_until((tree.ClassOrFunc, tree.ExprStmt))
             if stmt.type != 'expr_stmt':
                 # We only need to adjust the start_pos for statements, because
                 # there the name cannot be used.
                 stmt = atom
             return self.find_types(scope, atom, stmt.start_pos, search_global=True)
-        elif isinstance(atom, pr.Literal):
+        elif isinstance(atom, tree.Literal):
             return [compiled.create(self, atom.eval())]
         else:
             c = atom.children
             # Parentheses without commas are not tuples.
             if c[0] == '(' and not len(c) == 2 \
-                    and not(pr.is_node(c[1], 'testlist_comp')
+                    and not(tree.is_node(c[1], 'testlist_comp')
                             and len(c[1].children) > 1):
                 return self.eval_element(c[1])
             try:
@@ -243,7 +243,7 @@ class Evaluator(object):
             except (IndexError, AttributeError):
                 pass
             else:
-                if isinstance(comp_for, pr.CompFor):
+                if isinstance(comp_for, tree.CompFor):
                     return [iterable.Comprehension.from_atom(self, atom)]
             return [iterable.Array(self, atom)]
 
@@ -345,13 +345,13 @@ class Evaluator(object):
                         param_names += [param.name for param in params
                                         if param.name.value == name.value]
                 return param_names
-        elif isinstance(par, pr.ExprStmt) and name in par.get_defined_names():
+        elif isinstance(par, tree.ExprStmt) and name in par.get_defined_names():
             # Only take the parent, because if it's more complicated than just
             # a name it's something you can "goto" again.
             return [name]
-        elif isinstance(par, (pr.Param, pr.Function, pr.Class)) and par.name is name:
+        elif isinstance(par, (tree.Param, tree.Function, tree.Class)) and par.name is name:
             return [name]
-        elif isinstance(stmt, pr.Import):
+        elif isinstance(stmt, tree.Import):
             modules = imports.ImportWrapper(self, name).follow(is_goto=True)
             return list(resolve_implicit_imports(modules))
         elif par.type == 'dotted_name':  # Is a decorator.
@@ -365,7 +365,7 @@ class Evaluator(object):
                 ))
 
         scope = name.get_parent_scope()
-        if pr.is_node(name.parent, 'trailer'):
+        if tree.is_node(name.parent, 'trailer'):
             call = helpers.call_of_name(name, cut_own_trailer=True)
             types = self.eval_element(call)
             return resolve_implicit_imports(iterable.unite(
diff --git a/jedi/evaluate/analysis.py b/jedi/evaluate/analysis.py
index a47bd0dc..d4a411f4 100644
--- a/jedi/evaluate/analysis.py
+++ b/jedi/evaluate/analysis.py
@@ -2,7 +2,7 @@
 Module for statical analysis.
 """
 from jedi import debug
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi.evaluate.compiled import CompiledObject
 
 
@@ -196,13 +196,13 @@ def _check_for_exception_catch(evaluator, jedi_obj, exception, payload=None):
             return False
 
     obj = jedi_obj
-    while obj is not None and not obj.isinstance(pr.Function, pr.Class):
-        if obj.isinstance(pr.Flow):
+    while obj is not None and not obj.isinstance(tree.Function, tree.Class):
+        if obj.isinstance(tree.Flow):
             # try/except catch check
-            if obj.isinstance(pr.TryStmt) and check_try_for_except(obj, exception):
+            if obj.isinstance(tree.TryStmt) and check_try_for_except(obj, exception):
                 return True
             # hasattr check
-            if exception == AttributeError and obj.isinstance(pr.IfStmt, pr.WhileStmt):
+            if exception == AttributeError and obj.isinstance(tree.IfStmt, tree.WhileStmt):
                 if check_hasattr(obj.children[1], obj.children[3]):
                     return True
         obj = obj.parent
@@ -243,7 +243,7 @@ def get_module_statements(module):
     def add_nodes(nodes):
         new = set()
         for node in nodes:
-            if isinstance(node, pr.Flow):
+            if isinstance(node, tree.Flow):
                 children = node.children
                 if node.type == 'for_stmt':
                     children = children[2:]  # Don't want to include the names.
@@ -258,7 +258,7 @@ def get_module_statements(module):
                     pass
             elif node.type not in ('whitespace', 'operator', 'keyword',
                                    'parameters', 'decorated', 'except_clause') \
-                    and not isinstance(node, (pr.ClassOrFunc, pr.Import)):
+                    and not isinstance(node, (tree.ClassOrFunc, tree.Import)):
                 new.add(node)
 
                 try:
@@ -282,7 +282,7 @@ def get_module_statements(module):
                 import_names |= set(path[-1] for path in imp.paths())
 
         children = scope.children
-        if isinstance(scope, pr.ClassOrFunc):
+        if isinstance(scope, tree.ClassOrFunc):
             children = children[2:]  # We don't want to include the class name.
         nodes |= add_nodes(children)
 
diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index b895afa2..d841ad33 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -19,7 +19,7 @@ It works as follows:
 from itertools import chain
 
 from jedi._compatibility import unicode
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi import settings
 from jedi import debug
 from jedi.evaluate.cache import memoize_default
@@ -55,7 +55,7 @@ def search_params(evaluator, param):
         return []
     debug.dbg('Dynamic param search for %s', param)
 
-    func = param.get_parent_until(pr.Function)
+    func = param.get_parent_until(tree.Function)
     # Compare the param names.
     names = [n for n in search_function_call(evaluator, func)
              if n.value == param.name.value]
@@ -85,11 +85,11 @@ def search_function_call(evaluator, func):
 
             for name in names:
                 parent = name.parent
-                if pr.is_node(parent, 'trailer'):
+                if tree.is_node(parent, 'trailer'):
                     parent = parent.parent
 
                 trailer = None
-                if pr.is_node(parent, 'power'):
+                if tree.is_node(parent, 'power'):
                     for t in parent.children[1:]:
                         if t == '**':
                             break
@@ -124,7 +124,7 @@ def search_function_call(evaluator, func):
     compare = func
     if func_name == '__init__':
         cls = func.get_parent_scope()
-        if isinstance(cls, pr.Class):
+        if isinstance(cls, tree.Class):
             func_name = unicode(cls.name)
             compare = cls
 
diff --git a/jedi/evaluate/finder.py b/jedi/evaluate/finder.py
index 7eedb46a..c112f971 100644
--- a/jedi/evaluate/finder.py
+++ b/jedi/evaluate/finder.py
@@ -14,7 +14,7 @@ check for -> a is a string). There's big potential in these checks.
 from itertools import chain
 
 from jedi._compatibility import unicode, u
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi import debug
 from jedi import common
 from jedi import settings
@@ -43,7 +43,7 @@ def filter_after_position(names, position):
     for n in names:
         # Filter positions and also allow list comprehensions and lambdas.
         if n.start_pos[0] is not None and n.start_pos < position \
-                or isinstance(n.get_definition(), (pr.CompFor, pr.Lambda)):
+                or isinstance(n.get_definition(), (tree.CompFor, tree.Lambda)):
             names_new.append(n)
     return names_new
 
@@ -87,8 +87,8 @@ class NameFinder(object):
         types = self._names_to_types(names, search_global)
 
         if not names and not types \
-                and not (isinstance(self.name_str, pr.Name)
-                         and isinstance(self.name_str.parent.parent, pr.Param)):
+                and not (isinstance(self.name_str, tree.Name)
+                         and isinstance(self.name_str.parent.parent, tree.Param)):
             if not isinstance(self.name_str, (str, unicode)):  # TODO Remove?
                 if search_global:
                     message = ("NameError: name '%s' is not defined."
@@ -110,7 +110,7 @@ class NameFinder(object):
 
     def names_dict_lookup(self, names_dict, position):
         def get_param(scope, el):
-            if isinstance(el.get_parent_until(pr.Param), pr.Param):
+            if isinstance(el.get_parent_until(tree.Param), tree.Param):
                 return scope.param_by_name(str(el))
             return el
 
@@ -148,8 +148,8 @@ class NameFinder(object):
                 last_names.append(name)
                 continue
 
-            if isinstance(self.name_str, pr.Name):
-                origin_scope = self.name_str.get_parent_until(pr.Scope, reverse=True)
+            if isinstance(self.name_str, tree.Name):
+                origin_scope = self.name_str.get_parent_until(tree.Scope, reverse=True)
             else:
                 origin_scope = None
             if isinstance(stmt.parent, compiled.CompiledObject):
@@ -190,7 +190,7 @@ class NameFinder(object):
         """
         for n in names:
             definition = n.parent
-            if isinstance(definition, (pr.Function, pr.Class, pr.Module)):
+            if isinstance(definition, (tree.Function, tree.Class, tree.Module)):
                 yield self._evaluator.wrap(definition).name
             else:
                 yield n
@@ -215,7 +215,7 @@ class NameFinder(object):
         types = []
 
         # Add isinstance and other if/assert knowledge.
-        if isinstance(self.name_str, pr.Name):
+        if isinstance(self.name_str, tree.Name):
             # Ignore FunctionExecution parents for now.
             flow_scope = self.name_str
             until = flow_scope.get_parent_until(er.FunctionExecution)
@@ -246,7 +246,7 @@ class NameFinder(object):
         # definition. __get__ is only called if the descriptor is defined in
         # the class dictionary.
         name_scope = name.get_definition().get_parent_scope()
-        if not isinstance(name_scope, (er.Instance, pr.Class)):
+        if not isinstance(name_scope, (er.Instance, tree.Class)):
             return types
 
         result = []
@@ -264,23 +264,23 @@ class NameFinder(object):
 def _name_to_types(evaluator, name, scope):
     types = []
     typ = name.get_definition()
-    if typ.isinstance(pr.ForStmt):
+    if typ.isinstance(tree.ForStmt):
         for_types = evaluator.eval_element(typ.children[3])
         for_types = iterable.get_iterator_types(for_types)
         types += check_tuple_assignments(for_types, name)
-    elif typ.isinstance(pr.CompFor):
+    elif typ.isinstance(tree.CompFor):
         for_types = evaluator.eval_element(typ.children[3])
         for_types = iterable.get_iterator_types(for_types)
         types += check_tuple_assignments(for_types, name)
-    elif isinstance(typ, pr.Param):
+    elif isinstance(typ, tree.Param):
         types += _eval_param(evaluator, typ, scope)
-    elif typ.isinstance(pr.ExprStmt):
+    elif typ.isinstance(tree.ExprStmt):
         types += _remove_statements(evaluator, typ, name)
-    elif typ.isinstance(pr.WithStmt):
+    elif typ.isinstance(tree.WithStmt):
         types += evaluator.eval_element(typ.node_from_name(name))
-    elif isinstance(typ, pr.Import):
+    elif isinstance(typ, tree.Import):
         types += imports.ImportWrapper(evaluator, name).follow()
-    elif isinstance(typ, pr.GlobalStmt):
+    elif isinstance(typ, tree.GlobalStmt):
         # TODO theoretically we shouldn't be using search_global here, it
         # doesn't make sense, because it's a local search (for that name)!
         # However, globals are not that important and resolving them doesn't
@@ -288,7 +288,7 @@ def _name_to_types(evaluator, name, scope):
         # something is executed.
         types += evaluator.find_types(typ.get_parent_scope(), str(name),
                                       search_global=True)
-    elif isinstance(typ, pr.TryStmt):
+    elif isinstance(typ, tree.TryStmt):
         # 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.
@@ -325,7 +325,7 @@ def _remove_statements(evaluator, stmt, name):
     if check_instance is not None:
         # class renames
         types = [er.get_instance_el(evaluator, check_instance, a, True)
-                 if isinstance(a, (er.Function, pr.Function))
+                 if isinstance(a, (er.Function, tree.Function))
                  else a for a in types]
     return types
 
@@ -334,10 +334,10 @@ def _eval_param(evaluator, param, scope):
     res_new = []
     func = param.get_parent_scope()
 
-    cls = func.parent.get_parent_until((pr.Class, pr.Function))
+    cls = func.parent.get_parent_until((tree.Class, tree.Function))
 
     from jedi.evaluate.param import ExecutedParam, Arguments
-    if isinstance(cls, pr.Class) and param.position_nr == 0 \
+    if isinstance(cls, tree.Class) and param.position_nr == 0 \
             and not isinstance(param, ExecutedParam):
         # This is where we add self - if it has never been
         # instantiated.
@@ -396,13 +396,13 @@ def check_flow_information(evaluator, flow, search_name, pos):
             names = []
 
         for name in names:
-            ass = name.get_parent_until(pr.AssertStmt)
-            if isinstance(ass, pr.AssertStmt) and pos is not None and ass.start_pos < pos:
+            ass = name.get_parent_until(tree.AssertStmt)
+            if isinstance(ass, tree.AssertStmt) and pos is not None and ass.start_pos < pos:
                 result = _check_isinstance_type(evaluator, ass.assertion(), search_name)
                 if result:
                     break
 
-    if isinstance(flow, (pr.IfStmt, pr.WhileStmt)):
+    if isinstance(flow, (tree.IfStmt, tree.WhileStmt)):
         element = flow.children[1]
         result = _check_isinstance_type(evaluator, element, search_name)
     return result
@@ -414,7 +414,7 @@ def _check_isinstance_type(evaluator, element, search_name):
         # this might be removed if we analyze and, etc
         assert len(element.children) == 2
         first, trailer = element.children
-        assert isinstance(first, pr.Name) and first.value == 'isinstance'
+        assert isinstance(first, tree.Name) and first.value == 'isinstance'
         assert trailer.type == 'trailer' and trailer.children[0] == '('
         assert len(trailer.children) == 3
 
@@ -536,7 +536,7 @@ def filter_private_variable(scope, origin_node):
     instance = scope.get_parent_scope()
     coming_from = origin_node
     while coming_from is not None \
-            and not isinstance(coming_from, (pr.Class, compiled.CompiledObject)):
+            and not isinstance(coming_from, (tree.Class, compiled.CompiledObject)):
         coming_from = coming_from.get_parent_scope()
 
     # CompiledObjects don't have double underscore attributes, but Jedi abuses
diff --git a/jedi/evaluate/flow_analysis.py b/jedi/evaluate/flow_analysis.py
index 4a67e03e..cd3df554 100644
--- a/jedi/evaluate/flow_analysis.py
+++ b/jedi/evaluate/flow_analysis.py
@@ -1,4 +1,4 @@
-from jedi.parser import tree as pr
+from jedi.parser import tree
 
 
 class Status(object):
@@ -53,7 +53,7 @@ def _break_check(evaluator, stmt, base_scope, element_scope):
     base_scope = evaluator.wrap(base_scope)
 
     reachable = REACHABLE
-    if isinstance(element_scope, pr.IfStmt):
+    if isinstance(element_scope, tree.IfStmt):
         if element_scope.node_after_else(stmt):
             for check_node in element_scope.check_nodes():
                 reachable = _check_if(evaluator, check_node)
@@ -63,7 +63,7 @@ def _break_check(evaluator, stmt, base_scope, element_scope):
         else:
             node = element_scope.node_in_which_check_node(stmt)
             reachable = _check_if(evaluator, node)
-    elif isinstance(element_scope, (pr.TryStmt, pr.WhileStmt)):
+    elif isinstance(element_scope, (tree.TryStmt, tree.WhileStmt)):
         return UNSURE
 
     # Only reachable branches need to be examined further.
diff --git a/jedi/evaluate/helpers.py b/jedi/evaluate/helpers.py
index 3ac409d8..4802bee0 100644
--- a/jedi/evaluate/helpers.py
+++ b/jedi/evaluate/helpers.py
@@ -1,7 +1,7 @@
 import copy
 from itertools import chain
 
-from jedi.parser import tree as pr
+from jedi.parser import tree
 
 
 def deep_ast_copy(obj, parent=None, new_elements=None):
@@ -60,11 +60,11 @@ def deep_ast_copy(obj, parent=None, new_elements=None):
         new_elements[obj] = new_obj = copy.copy(obj)
         if parent is not None:
             new_obj.parent = parent
-    elif isinstance(obj, pr.BaseNode):
+    elif isinstance(obj, tree.BaseNode):
         new_obj = copy_node(obj)
         if parent is not None:
             for child in new_obj.children:
-                if isinstance(child, (pr.Name, pr.BaseNode)):
+                if isinstance(child, (tree.Name, tree.BaseNode)):
                     child.parent = parent
     else:  # String literals and so on.
         new_obj = obj  # Good enough, don't need to copy anything.
@@ -83,11 +83,11 @@ def call_of_name(name, cut_own_trailer=False):
     This generates a copy of the original ast node.
     """
     par = name
-    if pr.is_node(par.parent, 'trailer'):
+    if tree.is_node(par.parent, 'trailer'):
         par = par.parent
 
     power = par.parent
-    if pr.is_node(power, 'power') and power.children[0] != name \
+    if tree.is_node(power, 'power') and power.children[0] != name \
             and not (power.children[-2] == '**' and
                      name.start_pos > power.children[-1].start_pos):
         par = power
@@ -117,7 +117,7 @@ def get_module_names(module, all_scopes):
     return chain.from_iterable(dct.values())
 
 
-class FakeImport(pr.ImportName):
+class FakeImport(tree.ImportName):
     def __init__(self, name, parent, level=0):
         super(FakeImport, self).__init__([])
         self.parent = parent
@@ -145,13 +145,13 @@ class FakeImport(pr.ImportName):
         return True
 
 
-class FakeName(pr.Name):
+class FakeName(tree.Name):
     def __init__(self, name_str, parent=None, start_pos=(0, 0), is_definition=None):
         """
         In case is_definition is defined (not None), that bool value will be
         returned.
         """
-        super(FakeName, self).__init__(pr.zero_position_modifier, name_str, start_pos)
+        super(FakeName, self).__init__(tree.zero_position_modifier, name_str, start_pos)
         self.parent = parent
         self._is_definition = is_definition
 
diff --git a/jedi/evaluate/imports.py b/jedi/evaluate/imports.py
index 861ad595..fcd7559e 100644
--- a/jedi/evaluate/imports.py
+++ b/jedi/evaluate/imports.py
@@ -22,7 +22,7 @@ from jedi import common
 from jedi import debug
 from jedi import cache
 from jedi.parser import fast
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi.evaluate import sys_path
 from jedi.evaluate import helpers
 from jedi import settings
@@ -50,7 +50,7 @@ def completion_names(evaluator, imp, pos):
         level = imp.level
 
     importer = get_importer(evaluator, tuple(import_path), module, level)
-    if isinstance(imp, pr.ImportFrom):
+    if isinstance(imp, tree.ImportFrom):
         c = imp.children
         only_modules = c[c.index('import')].start_pos >= pos
     else:
@@ -58,12 +58,12 @@ def completion_names(evaluator, imp, pos):
     return importer.completion_names(evaluator, only_modules)
 
 
-class ImportWrapper(pr.Base):
+class ImportWrapper(tree.Base):
     def __init__(self, evaluator, name):
         self._evaluator = evaluator
         self._name = name
 
-        self._import = name.get_parent_until(pr.Import)
+        self._import = name.get_parent_until(tree.Import)
         self.import_path = self._import.path_for_name(name)
 
     @memoize_default()
@@ -138,7 +138,7 @@ class ImportWrapper(pr.Base):
         return types
 
 
-class NestedImportModule(pr.Module):
+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.
@@ -157,7 +157,7 @@ class NestedImportModule(pr.Module):
         zero = (0, 0)
         names = [unicode(name) for name in i.namespace_names[1:]]
         name = helpers.FakeName(names, self._nested_import)
-        new = pr.Import(i._sub_module, zero, zero, name)
+        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)
@@ -462,7 +462,7 @@ class _Importer(object):
                     continue
 
                 # namespace packages
-                if isinstance(scope, pr.Module) and scope.path.endswith('__init__.py'):
+                if isinstance(scope, tree.Module) and scope.path.endswith('__init__.py'):
                     pkg_path = os.path.dirname(scope.path)
                     paths = self.namespace_packages(pkg_path, self.import_path)
                     names += self._get_module_names([pkg_path] + paths)
diff --git a/jedi/evaluate/iterable.py b/jedi/evaluate/iterable.py
index 21cc8e7e..d14a4c5f 100644
--- a/jedi/evaluate/iterable.py
+++ b/jedi/evaluate/iterable.py
@@ -26,7 +26,7 @@ from jedi import common
 from jedi import debug
 from jedi import settings
 from jedi._compatibility import use_metaclass, is_py3, unicode
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi.evaluate import compiled
 from jedi.evaluate import helpers
 from jedi.evaluate.cache import CachedMetaClass, memoize_default
@@ -38,7 +38,7 @@ def unite(iterable):
     return list(chain.from_iterable(iterable))
 
 
-class IterableWrapper(pr.Base):
+class IterableWrapper(tree.Base):
     def is_class(self):
         return False
 
@@ -140,9 +140,9 @@ class Comprehension(IterableWrapper):
         last = comprehension.children[-1]
         last_comp = comprehension.children[1]
         while True:
-            if isinstance(last, pr.CompFor):
+            if isinstance(last, tree.CompFor):
                 last_comp = last
-            elif not pr.is_node(last, 'comp_if'):
+            elif not tree.is_node(last, 'comp_if'):
                 break
             last = last.children[-1]
 
@@ -283,9 +283,9 @@ class Array(IterableWrapper, ArrayMixin):
         if array_node in (']', '}', ')'):
             return []  # Direct closing bracket, doesn't contain items.
 
-        if pr.is_node(array_node, 'testlist_comp'):
+        if tree.is_node(array_node, 'testlist_comp'):
             return array_node.children[::2]
-        elif pr.is_node(array_node, 'dictorsetmaker'):
+        elif tree.is_node(array_node, 'dictorsetmaker'):
             kv = []
             iterator = iter(array_node.children)
             for key in iterator:
@@ -613,14 +613,14 @@ class Slice(object):
 
 
 def create_indexes_or_slices(evaluator, index):
-    if pr.is_node(index, 'subscript'):  # subscript is a slice operation.
+    if tree.is_node(index, 'subscript'):  # subscript is a slice operation.
         start, stop, step = None, None, None
         result = []
         for el in index.children:
             if el == ':':
                 if not result:
                     result.append(None)
-            elif pr.is_node(el, 'sliceop'):
+            elif tree.is_node(el, 'sliceop'):
                 if len(el.children) == 2:
                     result.append(el.children[1])
             else:
diff --git a/jedi/evaluate/param.py b/jedi/evaluate/param.py
index 5ae133f9..8524bf95 100644
--- a/jedi/evaluate/param.py
+++ b/jedi/evaluate/param.py
@@ -4,7 +4,7 @@ from itertools import chain
 from jedi._compatibility import unicode, zip_longest
 from jedi import debug
 from jedi import common
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi.evaluate import iterable
 from jedi.evaluate import analysis
 from jedi.evaluate import precedence
@@ -12,7 +12,7 @@ from jedi.evaluate.helpers import FakeName
 from jedi.cache import underscore_memoization
 
 
-class Arguments(pr.Base):
+class Arguments(tree.Base):
     def __init__(self, evaluator, argument_node, trailer=None):
         """
         The argument_node is either a parser node or a list of evaluated
@@ -30,7 +30,7 @@ class Arguments(pr.Base):
             for el in self.argument_node:
                 yield 0, el
         else:
-            if not pr.is_node(self.argument_node, 'arglist'):
+            if not tree.is_node(self.argument_node, 'arglist'):
                 yield 0, self.argument_node
                 return
 
@@ -59,7 +59,7 @@ class Arguments(pr.Base):
 
     def as_tuple(self):
         for stars, argument in self._split():
-            if pr.is_node(argument, 'argument'):
+            if tree.is_node(argument, 'argument'):
                 argument, default = argument.children[::2]
             else:
                 default = None
@@ -83,7 +83,7 @@ class Arguments(pr.Base):
                     for key, values in dct.items():
                         yield key, values
             else:
-                if pr.is_node(el, 'argument'):
+                if tree.is_node(el, 'argument'):
                     c = el.children
                     if len(c) == 3:  # Keyword argument.
                         named_args.append((c[0].value, (c[2],)))
@@ -106,7 +106,7 @@ class Arguments(pr.Base):
         named_index = None
         new_args = []
         for i, stmt in enumerate(var_args):
-            if isinstance(stmt, pr.ExprStmt):
+            if isinstance(stmt, tree.ExprStmt):
                 if named_index is None and stmt.assignment_details:
                     named_index = i
 
@@ -143,7 +143,7 @@ class Arguments(pr.Base):
 
     def scope(self):
         # Returns the scope in which the arguments are used.
-        return (self.trailer or self.argument_node).get_parent_until(pr.IsScope)
+        return (self.trailer or self.argument_node).get_parent_until(tree.IsScope)
 
     def eval_args(self):
         # TODO this method doesn't work with named args and a lot of other
@@ -154,14 +154,14 @@ class Arguments(pr.Base):
         return '<%s: %s>' % (type(self).__name__, self.argument_node)
 
     def get_calling_var_args(self):
-        if pr.is_node(self.argument_node, 'arglist', 'argument') \
+        if tree.is_node(self.argument_node, 'arglist', 'argument') \
                 or self.argument_node == () and self.trailer is not None:
             return _get_calling_var_args(self._evaluator, self)
         else:
             return None
 
 
-class ExecutedParam(pr.Param):
+class ExecutedParam(tree.Param):
     """Fake a param and give it values."""
     def __init__(self, original_param, var_args, values):
         self._original_param = original_param
@@ -193,7 +193,7 @@ def _get_calling_var_args(evaluator, var_args):
     while var_args != old_var_args:
         old_var_args = var_args
         for name, default, stars in reversed(list(var_args.as_tuple())):
-            if not stars or not isinstance(name, pr.Name):
+            if not stars or not isinstance(name, tree.Name):
                 continue
 
             names = evaluator.goto(name)
@@ -201,7 +201,7 @@ def _get_calling_var_args(evaluator, var_args):
                 break
             param = names[0].get_definition()
             if not isinstance(param, ExecutedParam):
-                if isinstance(param, pr.Param):
+                if isinstance(param, tree.Param):
                     # There is no calling var_args in this case - there's just
                     # a param without any input.
                     return None
diff --git a/jedi/evaluate/precedence.py b/jedi/evaluate/precedence.py
index ab685da9..7a2ee6d2 100644
--- a/jedi/evaluate/precedence.py
+++ b/jedi/evaluate/precedence.py
@@ -4,7 +4,7 @@ Handles operator precedence.
 import operator
 
 from jedi._compatibility import unicode
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi import debug
 from jedi.evaluate.compiled import (CompiledObject, create, builtin,
                                     keyword_from_value, true_obj, false_obj)
@@ -43,7 +43,7 @@ def calculate_children(evaluator, children):
     types = evaluator.eval_element(next(iterator))
     for operator in iterator:
         right = next(iterator)
-        if pr.is_node(operator, 'comp_op'):  # not in / is not
+        if tree.is_node(operator, 'comp_op'):  # not in / is not
             operator = ' '.join(str(c.value) for c in operator.children)
 
         # handle lazy evaluation of and/or here.
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index d125ece7..7b748f66 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -35,7 +35,7 @@ import re
 from itertools import chain
 
 from jedi._compatibility import use_metaclass, unicode, Python3Method
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi import debug
 from jedi import common
 from jedi.cache import underscore_memoization, cache_star_import
@@ -50,7 +50,7 @@ from jedi.evaluate import flow_analysis
 from jedi.evaluate import imports
 
 
-class Executed(pr.Base):
+class Executed(tree.Base):
     """
     An instance is also an executable - because __init__ is called
     :param var_args: The param input array, consist of a parser node or a list.
@@ -64,7 +64,7 @@ class Executed(pr.Base):
         return True
 
     def get_parent_until(self, *args, **kwargs):
-        return pr.Base.get_parent_until(self, *args, **kwargs)
+        return tree.Base.get_parent_until(self, *args, **kwargs)
 
     @common.safe_property
     def parent(self):
@@ -136,7 +136,7 @@ class Instance(use_metaclass(CachedMetaClass, Executed)):
         # This loop adds the names of the self object, copies them and removes
         # the self.
         for sub in self.base.subscopes:
-            if isinstance(sub, pr.Class):
+            if isinstance(sub, tree.Class):
                 continue
             # Get the self name, if there's one.
             self_name = self._get_func_self_name(sub)
@@ -155,7 +155,7 @@ class Instance(use_metaclass(CachedMetaClass, Executed)):
                 for name in name_list:
                     if name.value == self_name and name.prev_sibling() is None:
                         trailer = name.next_sibling()
-                        if pr.is_node(trailer, 'trailer') \
+                        if tree.is_node(trailer, 'trailer') \
                                 and len(trailer.children) == 2 \
                                 and trailer.children[0] == '.':
                             name = trailer.children[1]  # After dot.
@@ -246,9 +246,9 @@ class LazyInstanceDict(object):
         return [self[key] for key in self._dct]
 
 
-class InstanceName(pr.Name):
+class InstanceName(tree.Name):
     def __init__(self, origin_name, parent):
-        super(InstanceName, self).__init__(pr.zero_position_modifier,
+        super(InstanceName, self).__init__(tree.zero_position_modifier,
                                            origin_name.value,
                                            origin_name.start_pos)
         self._origin_name = origin_name
@@ -267,19 +267,19 @@ def get_instance_el(evaluator, instance, var, is_class_var=False):
     in quite a lot of cases, which includes Nodes like ``power``, that need to
     know where a self name comes from for example.
     """
-    if isinstance(var, pr.Name):
+    if isinstance(var, tree.Name):
         parent = get_instance_el(evaluator, instance, var.parent, is_class_var)
         return InstanceName(var, parent)
     elif var.type != 'funcdef' \
-            and isinstance(var, (Instance, compiled.CompiledObject, pr.Leaf,
-                           pr.Module, FunctionExecution)):
+            and isinstance(var, (Instance, compiled.CompiledObject, tree.Leaf,
+                           tree.Module, FunctionExecution)):
         return var
 
     var = evaluator.wrap(var)
     return InstanceElement(evaluator, instance, var, is_class_var)
 
 
-class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
+class InstanceElement(use_metaclass(CachedMetaClass, tree.Base)):
     """
     InstanceElement is a wrapper for any object, that is used as an instance
     variable (e.g. self.variable or class methods).
@@ -295,7 +295,7 @@ class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
     def parent(self):
         par = self.var.parent
         if isinstance(par, Class) and par == self.instance.base \
-                or isinstance(par, pr.Class) \
+                or isinstance(par, tree.Class) \
                 and par == self.instance.base.base:
             par = self.instance
         else:
@@ -304,10 +304,10 @@ class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
         return par
 
     def get_parent_until(self, *args, **kwargs):
-        return pr.BaseNode.get_parent_until(self, *args, **kwargs)
+        return tree.BaseNode.get_parent_until(self, *args, **kwargs)
 
     def get_definition(self):
-        return self.get_parent_until((pr.ExprStmt, pr.IsScope, pr.Import))
+        return self.get_parent_until((tree.ExprStmt, tree.IsScope, tree.Import))
 
     def get_decorated_func(self):
         """ Needed because the InstanceElement should not be stripped """
@@ -367,7 +367,7 @@ class InstanceElement(use_metaclass(CachedMetaClass, pr.Base)):
         return "<%s of %s>" % (type(self).__name__, self.var)
 
 
-class Wrapper(pr.Base):
+class Wrapper(tree.Base):
     def is_scope(self):
         return True
 
@@ -383,7 +383,7 @@ class Wrapper(pr.Base):
 
 class Class(use_metaclass(CachedMetaClass, Wrapper)):
     """
-    This class is not only important to extend `pr.Class`, it is also a
+    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).
     """
     def __init__(self, evaluator, base):
@@ -505,7 +505,7 @@ class Function(use_metaclass(CachedMetaClass, Wrapper)):
                 trailer = dec.children[2:-1]
                 if trailer:
                     # Create a trailer and evaluate it.
-                    trailer = pr.Node('trailer', trailer)
+                    trailer = tree.Node('trailer', trailer)
                     dec_results = self._evaluator.eval_trailer(dec_results, trailer)
 
                 if not len(dec_results):
@@ -629,7 +629,7 @@ class FunctionExecution(Executed):
     def _get_params(self):
         """
         This returns the params for an TODO and is injected as a
-        'hack' into the pr.Function class.
+        'hack' into the tree.Function class.
         This needs to be here, because Instance can have __init__ functions,
         which act the same way as normal functions.
         """
@@ -639,7 +639,7 @@ class FunctionExecution(Executed):
         return [n for n in self._get_params() if str(n) == name][0]
 
     def name_for_position(self, position):
-        return pr.Function.name_for_position(self, position)
+        return tree.Function.name_for_position(self, position)
 
     def _copy_list(self, lst):
         """
@@ -671,22 +671,22 @@ class FunctionExecution(Executed):
     @common.safe_property
     @memoize_default([])
     def returns(self):
-        return pr.Scope._search_in_scope(self, pr.ReturnStmt)
+        return tree.Scope._search_in_scope(self, tree.ReturnStmt)
 
     @common.safe_property
     @memoize_default([])
     def yields(self):
-        return pr.Scope._search_in_scope(self, pr.YieldExpr)
+        return tree.Scope._search_in_scope(self, tree.YieldExpr)
 
     @common.safe_property
     @memoize_default([])
     def statements(self):
-        return pr.Scope._search_in_scope(self, pr.ExprStmt)
+        return tree.Scope._search_in_scope(self, tree.ExprStmt)
 
     @common.safe_property
     @memoize_default([])
     def subscopes(self):
-        return pr.Scope._search_in_scope(self, pr.Scope)
+        return tree.Scope._search_in_scope(self, tree.Scope)
 
     def __repr__(self):
         return "<%s of %s>" % (type(self).__name__, self.base)
@@ -702,7 +702,7 @@ class GlobalName(helpers.FakeName):
                                          name.start_pos, is_definition=True)
 
 
-class ModuleWrapper(use_metaclass(CachedMetaClass, pr.Module, Wrapper)):
+class ModuleWrapper(use_metaclass(CachedMetaClass, tree.Module, Wrapper)):
     def __init__(self, evaluator, module):
         self._evaluator = evaluator
         self.base = self._module = module
@@ -729,7 +729,7 @@ class ModuleWrapper(use_metaclass(CachedMetaClass, pr.Module, Wrapper)):
                 name = i.star_import_name()
                 new = imports.ImportWrapper(self._evaluator, name).follow()
                 for module in new:
-                    if isinstance(module, pr.Module):
+                    if isinstance(module, tree.Module):
                         modules += module.star_imports()
                 modules += new
         return modules
diff --git a/jedi/evaluate/stdlib.py b/jedi/evaluate/stdlib.py
index 40bc9d28..20ff5d51 100644
--- a/jedi/evaluate/stdlib.py
+++ b/jedi/evaluate/stdlib.py
@@ -14,7 +14,7 @@ from jedi.evaluate import compiled
 from jedi.evaluate import representation as er
 from jedi.evaluate import iterable
 from jedi.parser import Parser
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi import debug
 from jedi.evaluate import precedence
 from jedi.evaluate import param
@@ -32,7 +32,7 @@ def execute(evaluator, obj, params):
     else:
         if obj.parent == compiled.builtin:
             module_name = 'builtins'
-        elif isinstance(obj.parent, pr.Module):
+        elif isinstance(obj.parent, tree.Module):
             module_name = str(obj.parent.name)
         else:
             module_name = ''
@@ -98,7 +98,7 @@ def builtins_getattr(evaluator, objects, names, defaults=None):
     types = []
     # follow the first param
     for obj in objects:
-        if not isinstance(obj, (er.Instance, er.Class, pr.Module, compiled.CompiledObject)):
+        if not isinstance(obj, (er.Instance, er.Class, tree.Module, compiled.CompiledObject)):
             debug.warning('getattr called without instance')
             continue
 
@@ -130,13 +130,13 @@ class SuperInstance(er.Instance):
 @argument_clinic('[type[, obj]], /', want_scope=True)
 def builtins_super(evaluator, types, objects, scope):
     # TODO make this able to detect multiple inheritance super
-    accept = (pr.Function, er.FunctionExecution)
+    accept = (tree.Function, er.FunctionExecution)
     if scope.isinstance(*accept):
-        wanted = (pr.Class, er.Instance)
+        wanted = (tree.Class, er.Instance)
         cls = scope.get_parent_until(accept + wanted,
                                      include_current=False)
         if isinstance(cls, wanted):
-            if isinstance(cls, pr.Class):
+            if isinstance(cls, tree.Class):
                 cls = er.Class(evaluator, cls)
             elif isinstance(cls, er.Instance):
                 cls = cls.base
diff --git a/jedi/evaluate/sys_path.py b/jedi/evaluate/sys_path.py
index 2a4c74e6..7cfbd57b 100644
--- a/jedi/evaluate/sys_path.py
+++ b/jedi/evaluate/sys_path.py
@@ -3,7 +3,7 @@ import os
 import sys
 
 from jedi._compatibility import exec_function, unicode
-from jedi.parser import tree as pr
+from jedi.parser import tree
 from jedi.parser import Parser
 from jedi.evaluate.cache import memoize_default
 from jedi import debug
@@ -71,7 +71,7 @@ def _paths_from_assignment(evaluator, expr_stmt):
     for assignee, operator in zip(expr_stmt.children[::2], expr_stmt.children[1::2]):
         try:
             assert operator in ['=', '+=']
-            assert pr.is_node(assignee, 'power') and len(assignee.children) > 1
+            assert tree.is_node(assignee, 'power') and len(assignee.children) > 1
             c = assignee.children
             assert c[0].type == 'name' and c[0].value == 'sys'
             trailer = c[1]
@@ -101,8 +101,8 @@ def _paths_from_list_modifications(module_path, trailer1, trailer2):
     """ extract the path from either "sys.path.append" or "sys.path.insert" """
     # Guarantee that both are trailers, the first one a name and the second one
     # a function execution with at least one param.
-    if not (pr.is_node(trailer1, 'trailer') and trailer1.children[0] == '.'
-            and pr.is_node(trailer2, 'trailer') and trailer2.children[0] == '('
+    if not (tree.is_node(trailer1, 'trailer') and trailer1.children[0] == '.'
+            and tree.is_node(trailer2, 'trailer') and trailer2.children[0] == '('
             and len(trailer2.children) == 3):
         return []
 
@@ -120,12 +120,12 @@ def _check_module(evaluator, module):
     def get_sys_path_powers(names):
         for name in names:
             power = name.parent.parent
-            if pr.is_node(power, 'power'):
+            if tree.is_node(power, 'power'):
                 c = power.children
-                if isinstance(c[0], pr.Name) and c[0].value == 'sys' \
-                        and pr.is_node(c[1], 'trailer'):
+                if isinstance(c[0], tree.Name) and c[0].value == 'sys' \
+                        and tree.is_node(c[1], 'trailer'):
                     n = c[1].children[1]
-                    if isinstance(n, pr.Name) and n.value == 'path':
+                    if isinstance(n, tree.Name) and n.value == 'path':
                         yield name, power
 
     sys_path = list(get_sys_path())  # copy