'A handy helper method that returns a callable that accepts keyword
arguments that appear as variables in the expression.  If called it
returns the result of the expression.
This is useful if applications want to use the same rules as Jinja
in template "configuration files" or similar situations.
Example usage:
>>> env = Environment()
>>> expr = env.compile_expression(\'foo == 42\')
>>> expr(foo=23)
False
>>> expr(foo=42)
True
Per default the return value is converted to `None` if the
expression returns an undefined value.  This can be changed
by setting `undefined_to_none` to `False`.
>>> env.compile_expression(\'var\')() is None
True
>>> env.compile_expression(\'var\', undefined_to_none=False)()
Undefined
.. versionadded:: 2.1'

def compile_expression(self, source, undefined_to_none=True):

    parser = Parser(self, source, state='variable')
    exc_info = None
    try:
        expr = parser.parse_expression()
        if (not parser.stream.eos):
            raise TemplateSyntaxError('chunk    after    expression', parser.stream.current.lineno, None, None)
        expr.set_environment(self)
    except TemplateSyntaxError:
        exc_info = sys.exc_info()
    if (exc_info is not None):
        self.handle_exception(exc_info, source_hint=source)
    body = [nodes.Assign(nodes.Name('result', 'store'), expr, lineno=1)]
    template = self.from_string(nodes.Template(body, lineno=1))
    return TemplateExpression(template, undefined_to_none)
