diff --git a/jedi/api/__init__.py b/jedi/api/__init__.py
index 02dfcb20..78cfb298 100644
--- a/jedi/api/__init__.py
+++ b/jedi/api/__init__.py
@@ -113,7 +113,7 @@ class Script(object):
         debug.speed('init')
 
     def _parsed_callback(self, parser):
-        module = er.wrap(self._evaluator, parser.module)
+        module = self._evaluator.wrap(parser.module)
         self._evaluator.modules[unicode(module.name)] = module
 
     @property
@@ -213,7 +213,7 @@ class Script(object):
                 if isinstance(c.parent, (pr.Function, pr.Class)):
                     # TODO I think this is a hack. It should be an
                     #   er.Function/er.Class before that.
-                    c = er.wrap(self._evaluator, c.parent).name
+                    c = self._evaluator.wrap(c.parent).name
                 new = classes.Completion(self._evaluator, c, needs_dot, len(like))
                 k = (new.name, new.complete)  # key
                 if k in comp_dct and settings.no_completion_duplicates:
@@ -235,7 +235,7 @@ class Script(object):
                 scope = scope.get_parent_scope()
             names_dicts = global_names_dict_generator(
                 self._evaluator,
-                er.wrap(self._evaluator, scope),
+                self._evaluator.wrap(scope),
                 self._pos
             )
             completion_names = []
@@ -342,7 +342,7 @@ class Script(object):
         context = self._user_context.get_context()
         definitions = set()
         if next(context) in ('class', 'def'):
-            definitions = set([er.wrap(self._evaluator, self._parser.user_scope())])
+            definitions = set([self._evaluator.wrap(self._parser.user_scope())])
         else:
             # Fetch definition of callee, if there's no path otherwise.
             if not goto_path:
diff --git a/jedi/api/classes.py b/jedi/api/classes.py
index 3643d987..88e456d8 100644
--- a/jedi/api/classes.py
+++ b/jedi/api/classes.py
@@ -61,7 +61,7 @@ class BaseDefinition(object):
         """
         An instance of :class:`jedi.parser.reprsentation.Name` subclass.
         """
-        self._definition = er.wrap(evaluator, self._name.get_definition())
+        self._definition = evaluator.wrap(self._name.get_definition())
         self.is_keyword = isinstance(self._definition, keywords.Keyword)
 
         # generate a path to the definition
@@ -175,7 +175,6 @@ class BaseDefinition(object):
                 pass
             else:
                 if isinstance(par, er.ModuleWrapper):
-                    #module = er.wrap(self._evaluator, par)
                     # TODO just make the path dotted from the beginning, we
                     # shouldn't really split here.
                     path[0:0] = par.py__name__().split('.')
@@ -354,7 +353,7 @@ class BaseDefinition(object):
 
     def parent(self):
         scope = self._definition.get_parent_scope()
-        scope = er.wrap(self._evaluator, scope)
+        scope = self._evaluator.wrap(scope)
         return Definition(self._evaluator, scope.name)
 
     def __repr__(self):
diff --git a/jedi/api/interpreter.py b/jedi/api/interpreter.py
index 534447f5..595435c6 100644
--- a/jedi/api/interpreter.py
+++ b/jedi/api/interpreter.py
@@ -85,7 +85,7 @@ class LazyName(helpers.FakeName):
                     assert len(parser_path) == 1
                     found = self._evaluator.find_types(mod, parser_path[0], search_global=True)
                 else:
-                    found = [er.wrap(self._evaluator, mod)]
+                    found = [self._evaluator.wrap(mod)]
 
                 if not found:
                     debug.warning('Possibly an interpreter lookup for Python code failed %s',
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index bf84caab..4c96e4f2 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -91,7 +91,18 @@ class Evaluator(object):
         self.analysis = []
 
     def wrap(self, element):
-        return er.wrap(self, element)
+        if isinstance(element, pr.Class):
+            return er.Class(self, element)
+        elif isinstance(element, pr.Function):
+            if isinstance(element, pr.Lambda):
+                return er.LambdaWrapper(self, element)
+            else:
+                return er.Function(self, element)
+        elif isinstance(element, (pr.Module)) \
+                and not isinstance(element, er.ModuleWrapper):
+            return er.ModuleWrapper(self, element)
+        else:
+            return element
 
     def find_types(self, scope, name_str, position=None, search_global=False,
                    is_goto=False):
@@ -133,7 +144,7 @@ class Evaluator(object):
             operator = copy.copy(first_operation)
             operator.value = operator.value[:-1]
             name = str(stmt.get_defined_names()[0])
-            parent = er.wrap(self, stmt.get_parent_scope())
+            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):
                 # Iterate through result and add the values, that's possible
diff --git a/jedi/evaluate/dynamic.py b/jedi/evaluate/dynamic.py
index ed607bad..b895afa2 100644
--- a/jedi/evaluate/dynamic.py
+++ b/jedi/evaluate/dynamic.py
@@ -112,7 +112,7 @@ def search_function_call(evaluator, func):
                         else:
                             undec.append(escope)
 
-                    if er.wrap(evaluator, compare) in undec:
+                    if evaluator.wrap(compare) in undec:
                         # Only if we have the correct function we execute
                         # it, otherwise just ignore it.
                         evaluator.eval_trailer(types, trailer)
diff --git a/jedi/evaluate/finder.py b/jedi/evaluate/finder.py
index 0dc85ad8..7eedb46a 100644
--- a/jedi/evaluate/finder.py
+++ b/jedi/evaluate/finder.py
@@ -76,7 +76,7 @@ class NameFinder(object):
     def __init__(self, evaluator, scope, name_str, position=None):
         self._evaluator = evaluator
         # Make sure that it's not just a syntax tree node.
-        self.scope = er.wrap(evaluator, scope)
+        self.scope = evaluator.wrap(scope)
         self.name_str = name_str
         self.position = position
 
@@ -129,7 +129,7 @@ class NameFinder(object):
         last_names = []
         for name in reversed(sorted(names, key=lambda name: name.start_pos)):
             stmt = name.get_definition()
-            name_scope = er.wrap(self._evaluator, stmt.get_parent_scope())
+            name_scope = self._evaluator.wrap(stmt.get_parent_scope())
 
             if isinstance(self.scope, er.Instance) and not isinstance(name_scope, er.Instance):
                 # Instances should not be checked for positioning, because we
@@ -191,7 +191,7 @@ class NameFinder(object):
         for n in names:
             definition = n.parent
             if isinstance(definition, (pr.Function, pr.Class, pr.Module)):
-                yield er.wrap(self._evaluator, definition).name
+                yield self._evaluator.wrap(definition).name
             else:
                 yield n
 
@@ -344,7 +344,7 @@ def _eval_param(evaluator, param, scope):
         if isinstance(scope, er.InstanceElement):
             res_new.append(scope.instance)
         else:
-            inst = er.Instance(evaluator, er.wrap(evaluator, cls),
+            inst = er.Instance(evaluator, evaluator.wrap(cls),
                                Arguments(evaluator, ()), is_generated=True)
             res_new.append(inst)
         return res_new
@@ -464,7 +464,7 @@ def global_names_dict_generator(evaluator, scope, position):
 
     >>> from jedi.evaluate import Evaluator
     >>> evaluator = Evaluator(load_grammar())
-    >>> scope = er.wrap(evaluator, scope)
+    >>> scope = evaluator.wrap(scope)
     >>> pairs = list(global_names_dict_generator(evaluator, scope, (4, 0)))
     >>> no_unicode_pprint(pairs[0])
     ({'func': [], 'y': [<Name: y@4,4>]}, (4, 0))
@@ -503,7 +503,7 @@ def global_names_dict_generator(evaluator, scope, position):
                 # The position should be reset if the current scope is a function.
                 in_func = True
                 position = None
-        scope = er.wrap(evaluator, scope.get_parent_scope())
+        scope = evaluator.wrap(scope.get_parent_scope())
 
     # Add builtins to the global scope.
     for names_dict in compiled.builtin.names_dicts(True):
diff --git a/jedi/evaluate/flow_analysis.py b/jedi/evaluate/flow_analysis.py
index a983aaf7..4a67e03e 100644
--- a/jedi/evaluate/flow_analysis.py
+++ b/jedi/evaluate/flow_analysis.py
@@ -33,8 +33,7 @@ UNSURE = Status(None, 'unsure')
 
 
 def break_check(evaluator, base_scope, stmt, origin_scope=None):
-    from jedi.evaluate.representation import wrap
-    element_scope = wrap(evaluator, stmt.get_parent_scope(include_flows=True))
+    element_scope = evaluator.wrap(stmt.get_parent_scope(include_flows=True))
     # Direct parents get resolved, we filter scopes that are separate branches.
     # This makes sense for autocompletion and static analysis. For actual
     # Python it doesn't matter, because we're talking about potentially
@@ -50,9 +49,8 @@ def break_check(evaluator, base_scope, stmt, origin_scope=None):
 
 
 def _break_check(evaluator, stmt, base_scope, element_scope):
-    from jedi.evaluate.representation import wrap
-    element_scope = wrap(evaluator, element_scope)
-    base_scope = wrap(evaluator, base_scope)
+    element_scope = evaluator.wrap(element_scope)
+    base_scope = evaluator.wrap(base_scope)
 
     reachable = REACHABLE
     if isinstance(element_scope, pr.IfStmt):
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 7074b1d6..c1eb07e2 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -50,21 +50,6 @@ from jedi.evaluate import flow_analysis
 from jedi.evaluate import imports
 
 
-def wrap(evaluator, element):
-    if isinstance(element, pr.Class):
-        return Class(evaluator, element)
-    elif isinstance(element, pr.Function):
-        if isinstance(element, pr.Lambda):
-            return LambdaWrapper(evaluator, element)
-        else:
-            return Function(evaluator, element)
-    elif isinstance(element, (pr.Module)) \
-            and not isinstance(element, ModuleWrapper):
-        return ModuleWrapper(evaluator, element)
-    else:
-        return element
-
-
 class Executed(pr.Base):
     """
     An instance is also an executable - because __init__ is called
@@ -290,7 +275,7 @@ def get_instance_el(evaluator, instance, var, is_class_var=False):
                            pr.Module, FunctionExecution)):
         return var
 
-    var = wrap(evaluator, var)
+    var = evaluator.wrap(var)
     return InstanceElement(evaluator, instance, var, is_class_var)