class_docstr: This is the central parsing class Jinja uses.  It's passed to
  extensions and can be used to parse expressions or statements.
class_docstr_tok: ["This","is","the","central","parsing","class","Jinja","uses",".","It","'s","passed","to","extensions","and","can","be","used","to","parse","expressions","or","statements","."]
code: def parse_call_args(self) -> t.Tuple:
      token = self.stream.expect("lparen")
      args = []
      kwargs = []
      dyn_args = None
      dyn_kwargs = None
      require_comma = False
  
      def ensure(expr: bool) -> None:
          if not expr:
              self.fail(
                  "invalid syntax for function call expression",
                  token.lineno,
              )
  
      while self.stream.current.type != "rparen":
          if require_comma:
              self.stream.expect("comma")
  
              # support for trailing comma
              if self.stream.current.type == "rparen":
                  break
  
          if self.stream.current.type == "mul":
              ensure(dyn_args is None and dyn_kwargs is None)
              next(self.stream)
              dyn_args = self.parse_expression()
          elif self.stream.current.type == "pow":
              ensure(dyn_kwargs is None)
              next(self.stream)
              dyn_kwargs = self.parse_expression()
          else:
              if (
                  self.stream.current.type == "name"
                  and self.stream.look().type == "assign"
              ):
                  # Parsing a kwarg
                  ensure(dyn_kwargs is None)
                  key = self.stream.current.value
                  self.stream.skip(2)
                  value = self.parse_expression()
                  kwargs.append(
                      nodes.Keyword(key, value, lineno=value.lineno)
                  )
              else:
                  # Parsing an arg
                  ensure(
                      dyn_args is None
                      and dyn_kwargs is None
                      and not kwargs
                  )
                  args.append(self.parse_expression())
  
          require_comma = True
  
      self.stream.expect("rparen")
      return args, kwargs, dyn_args, dyn_kwargs
  
imports: import typing
  import typing
  from .None import nodes
  from .exceptions import TemplateAssertionError
  from .exceptions import TemplateSyntaxError
  from .lexer import describe_token
  from .lexer import describe_token_expr
label_desc: Use image node_id 48 for calling the Parser obj's underlying member method code with example usage: obj.parse_call_args() and returns: args,  kwargs,  dyn_args,  dyn_kwargs