class_docstr: This implements a *very* limited decompiler. It only handles cases of
  lambda x: fn(a, b, x, ...)
  where a,b, etc are variables captured from the surrounding scope, and there
  may be some occurrences of x.
  No additional statements or expressions are permitted
code: def visit_Call(self, node):
      if self.state != self.INNER_CALL:
          raise NotImplementedError(
              "Unexpected call in position "
              + str(node.lineno)
              + ":"
              + str(node.col_offset)
          )
      self.state = self.INNER_CALL
  
      # this is the main closure function call
      if self.closure_fn_name != "":
          raise NotImplementedError(
              "Cannot translate function call "
              + str(node.lineno)
              + ":"
              + str(node.col_offset)
          )
      elif type(node.func) is ast.Name:
          self.closure_fn_name = node.func.id
      elif type(node.func) is ast.Attribute:
          self.closure_fn_name = attribute_reader().visit(node.func)
      else:
          raise NotImplementedError("Unexpected type of function call.")
  
      self.state = self.PARAMETER
  
      for i in range(len(node.args)):
          arg = node.args[i]
          if type(arg) is ast.Name and arg.id in self.input_arg_names:
              self.positional_args += [Parameter(arg.id)]
          else:
              try:
                  expression_validator(self.input_arg_names).visit(arg)
                  # try to evaluate the ast
                  result = eval(
                      compile(ast.Expression(arg), "<string>", "eval"),
                      self.caller_globals,
                  )
              except:
                  raise NotImplementedError(
                      "Only simple expressions not using the function arguments are permitted"
                  )
              self.positional_args += [result]
  
      # keyword arguments next
      keywordargs = {i.arg: i.value for i in node.keywords}
      for i in keywordargs:
          arg = keywordargs[i]
          if type(arg) is ast.Name and arg.id in self.input_arg_names:
              self.named_args[i] = Parameter(arg.id)
          else:
              try:
                  expression_validator(self.input_arg_names).visit(arg)
                  # try to evaluate the ast
                  result = eval(
                      compile(ast.Expression(arg), "<string>", "eval"),
                      self.caller_globals,
                  )
              except:
                  raise NotImplementedError(
                      "Only simple expressions not using the function arguments are permitted"
                  )
              self.named_args[i] = result
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  import sys
  import ast
  import inspect
  from ..None import meta
label_desc: Use image node_id 7 for calling the lambda_closure_visitor obj's underlying member method code with example usage: obj.visit_Call(node) without return types