'The starting point of the completion. A statement always owns a call
list, which are the calls, that a statement does. In case multiple
names are defined in the statement, `seek_name` returns the result for
this name.
:param stmt: A `tree.ExprStmt`.'

@debug.increase_indent
def _eval_stmt(self, context, stmt, seek_name=None):

    debug.dbg('eval_statement    %s    (%s)', stmt, seek_name)
    rhs = stmt.get_rhs()
    types = self.eval_element(context, rhs)
    if seek_name:
        c_node = ContextualizedName(context, seek_name)
        types = finder.check_tuple_assignments(self, c_node, types)
    first_operator = next(stmt.yield_operators(), None)
    if ((first_operator not in ('=', None)) and (first_operator.type == 'operator')):
        operator = copy.copy(first_operator)
        operator.value = operator.value[:(-1)]
        name = stmt.get_defined_names()[0].value
        left = context.py__getattribute__(name, position=stmt.start_pos, search_global=True)
        for_stmt = tree.search_ancestor(stmt, 'for_stmt')
        if ((for_stmt is not None) and (for_stmt.type == 'for_stmt') and types and parser_utils.for_stmt_defines_one_name(for_stmt)):
            node = for_stmt.get_testlist()
            cn = ContextualizedNode(context, node)
            ordered = list(iterable.py__iter__(self, cn.infer(), cn))
            for lazy_context in ordered:
                dct = {for_stmt.children[1].value: lazy_context.infer()}
                with helpers.predefine_names(context, for_stmt, dct):
                    t = self.eval_element(context, rhs)
                    left = precedence.calculate(self, context, left, operator, t)
            types = left
        else:
            types = precedence.calculate(self, context, left, operator, types)
    debug.dbg('eval_statement    result    %s', types)
    return types
