Use SimpleParamName everywhere it's needed

jedi/inference/__init__.py

@@ -305,8 +305,8 @@ class InferenceState(object):
                 if is_simple_name:
                     return [TreeNameDefinition(context, name)]
             elif type_ == 'param':
-                func = tree.search_ancestor(name, 'funcdef', 'lambdef')
+                funcdef = tree.search_ancestor(name, 'funcdef', 'lambdef')
-                func = context.get_root_context().create_value(func)
+                func = context.get_root_context().create_value(funcdef)
                 return [SimpleParamName(func, name)]
             elif type_ in ('import_from', 'import_name'):
                 module_names = imports.goto_import(context, name)

jedi/inference/filters.py

@@ -143,8 +143,6 @@ class ParserTreeFilter(AbstractUsedNamesFilter):
 
 
 class FunctionExecutionFilter(ParserTreeFilter):
-    param_name = ParamName
-
     def __init__(self, parent_context, function_value, node_context=None,
                  until_position=None, origin_scope=None):
         super(FunctionExecutionFilter, self).__init__(
@@ -160,7 +158,7 @@ class FunctionExecutionFilter(ParserTreeFilter):
         for name in names:
             param = search_ancestor(name, 'param')
             if param:
-                yield self.param_name(self._function_value, name, self.parent_context.var_args)
+                yield ParamName(self._function_value, name, self.parent_context.var_args)
             else:
                 yield TreeNameDefinition(self.parent_context, name)
 

jedi/inference/usages.py

@@ -1,5 +1,7 @@
+from parso.python.tree import search_ancestor
+
 from jedi.inference import imports
-from jedi.inference.names import TreeNameDefinition
+from jedi.inference.names import TreeNameDefinition, SimpleParamName
 
 
 def _resolve_names(definition_names, avoid_names=()):
@@ -27,6 +29,12 @@ def _dictionarize(names):
 
 
 def _find_names(module_context, tree_name):
+    definition = tree_name.get_definition()
+    if definition and definition.type == 'param' and definition.name == tree_name:
+        funcdef = search_ancestor(definition, 'funcdef', 'lambdef')
+        func = module_context.create_value(funcdef)
+        name = SimpleParamName(func, tree_name)
+    else:
         context = module_context.create_context(tree_name)
         name = TreeNameDefinition(context, tree_name)
     found_names = set(name.goto())

jedi/inference/value/function.py

@@ -10,7 +10,7 @@ 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.names import ValueName, AbstractNameDefinition, ParamName
+from jedi.inference.names import ValueName, AbstractNameDefinition, SimpleParamName
 from jedi.inference.base_value import ContextualizedNode, NO_VALUES, \
     ValueSet, TreeValue, ValueWrapper
 from jedi.inference.lazy_value import LazyKnownValues, LazyKnownValue, \
@@ -69,8 +69,7 @@ class FunctionMixin(object):
         return ValueSet([BoundMethod(instance, self)])
 
     def get_param_names(self):
-        arguments = AnonymousArguments()
+        return [SimpleParamName(self, param.name)
-        return [ParamName(self, param.name, arguments)
                 for param in self.tree_node.get_params()]
 
     @property