Use the function execution filters with proper inheritance

jedi/inference/filters.py

@@ -143,30 +143,42 @@ class ParserTreeFilter(AbstractUsedNamesFilter):
                 break
 
 
-class FunctionExecutionFilter(ParserTreeFilter):
+class _FunctionExecutionFilter(ParserTreeFilter):
-    def __init__(self, parent_context, function_value,
+    def __init__(self, parent_context, function_value, until_position, origin_scope):
-                 until_position, origin_scope, arguments):
+        super(_FunctionExecutionFilter, self).__init__(
-        super(FunctionExecutionFilter, self).__init__(
             parent_context,
             until_position=until_position,
             origin_scope=origin_scope,
         )
         self._function_value = function_value
-        self._arguments = arguments
+
+    def _convert_param(self, name):
+        raise NotImplementedError
 
     @to_list
     def _convert_names(self, names):
         for name in names:
             param = search_ancestor(name, 'param')
             if param:
-                if self._arguments:
+                yield self._convert_param(name)
-                    yield ParamName(self._function_value, name, self._arguments)
-                else:
-                    yield SimpleParamName(self._function_value, name)
             else:
                 yield TreeNameDefinition(self.parent_context, name)
 
 
+class FunctionExecutionFilter(_FunctionExecutionFilter):
+    def __init__(self, *args, **kwargs):
+        self._arguments = kwargs.pop('arguments')  # Python 2
+        super(FunctionExecutionFilter, self).__init__(*args, **kwargs)
+
+    def _convert_param(self, name):
+        return ParamName(self._function_value, name, self._arguments)
+
+
+class AnonymousFunctionExecutionFilter(_FunctionExecutionFilter):
+    def _convert_param(self, name):
+        return SimpleParamName(self._function_value, name)
+
+
 class GlobalNameFilter(AbstractUsedNamesFilter):
     def get(self, name):
         try:

jedi/inference/value/function.py

@@ -9,7 +9,8 @@ from jedi.inference import docstrings
 from jedi.inference import flow_analysis
 from jedi.inference.signature import TreeSignature
 from jedi.inference.arguments import AnonymousArguments
-from jedi.inference.filters import ParserTreeFilter, FunctionExecutionFilter
+from jedi.inference.filters import ParserTreeFilter, FunctionExecutionFilter, \
+    AnonymousFunctionExecutionFilter
 from jedi.inference.names import ValueName, AbstractNameDefinition, \
     SimpleParamName, ParamName
 from jedi.inference.base_value import ContextualizedNode, NO_VALUES, \
@@ -337,11 +338,10 @@ class FunctionExecutionContext(BaseFunctionExecutionContext):
 
 class AnonymousFunctionExecution(BaseFunctionExecutionContext):
     def get_filters(self, until_position=None, origin_scope=None):
-        yield FunctionExecutionFilter(
+        yield AnonymousFunctionExecutionFilter(
             self, self._value,
             until_position=until_position,
             origin_scope=origin_scope,
-            arguments=None,
         )
 
     def get_param_names(self):