parameters: (parent, argslist_list)
docstring: `argslist_list` is a list that can contain an argslist as a first item, but
      most not. It's basically the items between the parameter brackets (which is
      at most one item).
      This function modifies the parser structure. It generates `Param` objects
      from the normal ast. Those param objects do not exist in a normal ast, but
      make the evaluation of the ast tree so much easier.
      You could also say that this function replaces the argslist node with a
      list of Param objects.
docstring_summary: `argslist_list` is a list that can contain an argslist as a first item, but
      most not. It's basically the items between the parameter brackets (which is
      at most one item).
      This function modifies the parser structure. It generates `Param` objects
      from the normal ast. Those param objects do not exist in a normal ast, but
      make the evaluation of the ast tree so much easier.
      You could also say that this function replaces the argslist node with a
      list of Param objects.
docstring_tokens: argslist_list is a list that can contain an argslist as a first item but most not . It s basically the items between the parameter brackets ( which is at most one item ) . This function modifies the parser structure . It generates Param objects from the normal ast . Those param objects do not exist in a normal ast but make the evaluation of the ast tree so much easier . You could also say that this function replaces the argslist node with a list of Param objects .
function: def _create_params(parent, argslist_list):
      """
      `argslist_list` is a list that can contain an argslist as a first item, but
      most not. It's basically the items between the parameter brackets (which is
      at most one item).
      This function modifies the parser structure. It generates `Param` objects
      from the normal ast. Those param objects do not exist in a normal ast, but
      make the evaluation of the ast tree so much easier.
      You could also say that this function replaces the argslist node with a
      list of Param objects.
      """
      def check_python2_nested_param(node):
          """
          Python 2 allows params to look like ``def x(a, (b, c))``, which is
          basically a way of unpacking tuples in params. Python 3 has ditched
          this behavior. Jedi currently just ignores those constructs.
          """
          return node.type == 'fpdef' and node.children[0] == '('
  
      try:
          first = argslist_list[0]
      except IndexError:
          return []
  
      if first.type in ('name', 'fpdef'):
          if check_python2_nested_param(first):
              return [first]
          else:
              return [Param([first], parent)]
      elif first == '*':
          return [first]
      else:  # argslist is a `typedargslist` or a `varargslist`.
          if first.type == 'tfpdef':
              children = [first]
          else:
              children = first.children
          new_children = []
          start = 0
          # Start with offset 1, because the end is higher.
          for end, child in enumerate(children + [None], 1):
              if child is None or child == ',':
                  param_children = children[start:end]
                  if param_children:  # Could as well be comma and then end.
                      if param_children[0] == '*' and param_children[1] == ',' \
                              or check_python2_nested_param(param_children[0]):
                          for p in param_children:
                              p.parent = parent
                          new_children += param_children
                      else:
                          new_children.append(Param(param_children, parent))
                      start = end
          return new_children
function_tokens: def _create_params ( parent , argslist_list ) : def check_python2_nested_param ( node ) : """
          Python 2 allows params to look like ``def x(a, (b, c))``, which is
          basically a way of unpacking tuples in params. Python 3 has ditched
          this behavior. Jedi currently just ignores those constructs.
          """ return node . type == 'fpdef' and node . children [ 0 ] == '(' try : first = argslist_list [ 0 ] except IndexError : return [ ] if first . type in ( 'name' , 'fpdef' ) : if check_python2_nested_param ( first ) : return [ first ] else : return [ Param ( [ first ] , parent ) ] elif first == '*' : return [ first ] else : # argslist is a `typedargslist` or a `varargslist`. if first . type == 'tfpdef' : children = [ first ] else : children = first . children new_children = [ ] start = 0 # Start with offset 1, because the end is higher. for end , child in enumerate ( children + [ None ] , 1 ) : if child is None or child == ',' : param_children = children [ start : end ] if param_children : # Could as well be comma and then end. if param_children [ 0 ] == '*' and param_children [ 1 ] == ',' or check_python2_nested_param ( param_children [ 0 ] ) : for p in param_children : p . parent = parent new_children += param_children else : new_children . append ( Param ( param_children , parent ) ) start = end return new_children