class_docstr: This tree walk attempts to validate an expression: that the expression
  should *not* contain certain names.
  This is used for the case
  
      x = 10
      lambda x: fn(x+15, x)
  
  Really, the "x+15" expression is invalid since the expression uses an
  lambda argument. However, it does evaluate correctly in the scope
  since "x" also exists in the function scope.
  
  We thus need to validate the expression before attempting to evaluate it
  so that the expression must not contain a lambda argument.
  
  This validator here is a lot stricter than it should since it will also
  prevent all cases where something with the same name as the lambda argument
  is created in an inner scope. For instance:
  
      lambda x: fn((lambda x: x + 15)(5), x)
  
      lambda x: fn(([x for x in [1,2,3]], x)
code: def visit_Name(self, node):
      if node.id in self.blocked_symbols:
          raise RuntimeError("Blocked symbols encountered")
  
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 2 for calling the expression_validator obj's underlying member method code with example usage: obj.visit_Name(node) without return types