diff --git a/jedi/inference/gradual/annotation.py b/jedi/inference/gradual/annotation.py
index 8421f83f..6b11144b 100644
--- a/jedi/inference/gradual/annotation.py
+++ b/jedi/inference/gradual/annotation.py
@@ -193,16 +193,16 @@ def py__annotations__(funcdef):
 
 
 @inference_state_method_cache()
-def infer_return_types(function_execution_context):
+def infer_return_types(function, arguments):
     """
     Infers the type of a function's return value,
     according to type annotations.
     """
-    all_annotations = py__annotations__(function_execution_context.tree_node)
+    all_annotations = py__annotations__(function.tree_node)
     annotation = all_annotations.get("return", None)
     if annotation is None:
         # If there is no Python 3-type annotation, look for a Python 2-type annotation
-        node = function_execution_context.tree_node
+        node = function.tree_node
         comment = parser_utils.get_following_comment_same_line(node)
         if comment is None:
             return NO_VALUES
@@ -212,19 +212,19 @@ def infer_return_types(function_execution_context):
             return NO_VALUES
 
         return _infer_annotation_string(
-            function_execution_context.function_value.get_default_param_context(),
+            function.get_default_param_context(),
             match.group(1).strip()
         ).execute_annotation()
         if annotation is None:
             return NO_VALUES
 
-    context = function_execution_context.function_value.get_default_param_context()
+    context = function.get_default_param_context()
     unknown_type_vars = list(find_unknown_type_vars(context, annotation))
     annotation_values = infer_annotation(context, annotation)
     if not unknown_type_vars:
         return annotation_values.execute_annotation()
 
-    type_var_dict = infer_type_vars_for_execution(function_execution_context, all_annotations)
+    type_var_dict = infer_type_vars_for_execution(function, arguments, all_annotations)
 
     return ValueSet.from_sets(
         ann.define_generics(type_var_dict)
@@ -233,7 +233,7 @@ def infer_return_types(function_execution_context):
     ).execute_annotation()
 
 
-def infer_type_vars_for_execution(execution_context, annotation_dict):
+def infer_type_vars_for_execution(function, arguments, annotation_dict):
     """
     Some functions use type vars that are not defined by the class, but rather
     only defined in the function. See for example `iter`. In those cases we
@@ -243,10 +243,10 @@ def infer_type_vars_for_execution(execution_context, annotation_dict):
     2. Infer type vars with the execution state we have.
     3. Return the union of all type vars that have been found.
     """
-    context = execution_context.function_value.get_default_param_context()
+    context = function.get_default_param_context()
 
     annotation_variable_results = {}
-    executed_param_names, _ = execution_context.get_executed_param_names_and_issues()
+    executed_param_names, _ = arguments.get_executed_param_names_and_issues(function)
     for executed_param_name in executed_param_names:
         try:
             annotation_node = annotation_dict[executed_param_name.string_name]
diff --git a/jedi/inference/value/function.py b/jedi/inference/value/function.py
index 377282d3..ce35562c 100644
--- a/jedi/inference/value/function.py
+++ b/jedi/inference/value/function.py
@@ -162,7 +162,6 @@ class MethodValue(FunctionValue):
 class FunctionExecutionContext(ValueContext, TreeContextMixin):
     def __init__(self, function_value, arguments):
         super(FunctionExecutionContext, self).__init__(function_value)
-        self.function_value = function_value
         self._arguments = arguments
 
     @inference_state_method_cache(default=NO_VALUES)
@@ -178,12 +177,12 @@ class FunctionExecutionContext(ValueContext, TreeContextMixin):
         else:
             returns = funcdef.iter_return_stmts()
             from jedi.inference.gradual.annotation import infer_return_types
-            value_set = infer_return_types(self)
+            value_set = infer_return_types(self._value, self._arguments)
             if value_set:
                 # If there are annotations, prefer them over anything else.
                 # This will make it faster.
                 return value_set
-            value_set |= docstrings.infer_return_types(self.function_value)
+            value_set |= docstrings.infer_return_types(self._value)
 
         for r in returns:
             check = flow_analysis.reachability_check(self, funcdef, r)
diff --git a/jedi/inference/value/instance.py b/jedi/inference/value/instance.py
index ccc6095e..7eed0aaf 100644
--- a/jedi/inference/value/instance.py
+++ b/jedi/inference/value/instance.py
@@ -300,12 +300,11 @@ class TreeInstance(AbstractInstanceValue):
                 # need to infer anything.
                 continue
             bound_method = BoundMethod(self, signature.value)
-            execution = bound_method.as_context(self.arguments)
-            all_annotations = py__annotations__(execution.tree_node)
-            type_var_dict = infer_type_vars_for_execution(execution, all_annotations)
+            all_annotations = py__annotations__(signature.value.tree_node)
+            type_var_dict = infer_type_vars_for_execution(bound_method, args, all_annotations)
             if type_var_dict:
                 defined, = self.class_value.define_generics(
-                    infer_type_vars_for_execution(execution, all_annotations),
+                    infer_type_vars_for_execution(signature.value, args, all_annotations),
                 )
                 debug.dbg('Inferred instance value as %s', defined, color='BLUE')
                 return defined