'Returns True if the line must split before the next token.'

def MustSplit(self):

    current = self.next_token
    previous = current.previous_token
    if current.is_pseudo_paren:
        return False
    if current.must_break_before:
        return True
    if (not previous):
        return False
    if (self.stack[(-1)].split_before_closing_bracket and (current.value in '}]')):
        return (current.node_split_penalty != split_penalty.UNBREAKABLE)
    if (style.Get('SPLIT_BEFORE_FIRST_ARGUMENT') and (self.line.first.value != 'def') and (self.line.first.value in _COMPOUND_STMTS)):
        return False
    if (style.Get('DEDENT_CLOSING_BRACKETS') or style.Get('SPLIT_BEFORE_FIRST_ARGUMENT')):
        bracket = (current if current.ClosesScope() else previous)
        if (format_token.Subtype.SUBSCRIPT_BRACKET not in bracket.subtypes):
            if bracket.OpensScope():
                if style.Get('COALESCE_BRACKETS'):
                    if current.OpensScope():
                        return False
                if ((not _IsLastScopeInLine(bracket)) or unwrapped_line.IsSurroundedByBrackets(bracket)):
                    last_token = bracket.matching_bracket
                else:
                    last_token = _LastTokenInLine(bracket.matching_bracket)
                if (not self._FitsOnLine(bracket, last_token)):
                    self.stack[(-1)].split_before_closing_bracket = True
                    return True
            elif (style.Get('DEDENT_CLOSING_BRACKETS') and current.ClosesScope()):
                return self.stack[(-1)].split_before_closing_bracket
    if ((current.is_name or current.is_string) and (previous.value == ',')):
        func_call_or_string_format = False
        if current.is_name:
            tok = current.next_token
            while (tok and (tok.is_name or (tok.value == '.'))):
                tok = tok.next_token
            func_call_or_string_format = (tok and (tok.value == '('))
        elif current.is_string:
            tok = current.next_token
            while (tok and tok.is_string):
                tok = tok.next_token
            func_call_or_string_format = (tok and (tok.value == '%'))
        if func_call_or_string_format:
            open_bracket = unwrapped_line.IsSurroundedByBrackets(current)
            if (open_bracket and (open_bracket.value in '[{')):
                if (not self._FitsOnLine(open_bracket, open_bracket.matching_bracket)):
                    return True
    if (style.Get('EACH_DICT_ENTRY_ON_SEPARATE_LINE') and (format_token.Subtype.DICTIONARY_KEY in current.subtypes) and (not current.is_comment)):
        if ((previous.value == '{') and previous.previous_token):
            opening = _GetOpeningBracket(previous.previous_token)
            if (opening and (opening.value == '(') and opening.previous_token and opening.previous_token.is_name):
                if self._FitsOnLine(previous, previous.matching_bracket):
                    return False
        return True
    if (style.Get('SPLIT_BEFORE_DICT_SET_GENERATOR') and (format_token.Subtype.DICT_SET_GENERATOR in current.subtypes)):
        return True
    if ((format_token.Subtype.DICTIONARY_VALUE in current.subtypes) or (previous.is_pseudo_paren and (previous.value == '(') and (not current.is_comment))):
        if (not current.OpensScope()):
            opening = _GetOpeningBracket(current)
            if (not self._EachDictEntryFitsOnOneLine(opening)):
                return True
    if (previous.value == '{'):
        closing = previous.matching_bracket
        if ((not self._FitsOnLine(previous, closing)) and (closing.previous_token.value == ',')):
            self.stack[(-1)].split_before_closing_bracket = True
            return True
    if (style.Get('SPLIT_BEFORE_NAMED_ASSIGNS') and (not current.is_comment) and (format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in current.subtypes)):
        if ((previous.value not in {'=', ':', '*', '**'}) and (current.value not in ':=,)') and (not _IsFunctionDefinition(previous))):
            if (previous.value == '('):
                if (self._FitsOnLine(previous, previous.matching_bracket) and unwrapped_line.IsSurroundedByBrackets(previous)):
                    return False
                column = (self.column - self.stack[(-1)].last_space)
                return (column > style.Get('CONTINUATION_INDENT_WIDTH'))
            opening = _GetOpeningBracket(current)
            if opening:
                arglist_length = ((opening.matching_bracket.total_length - opening.total_length) + self.stack[(-1)].indent)
                return (arglist_length > self.column_limit)
    if style.Get('SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED'):
        opening = _GetOpeningBracket(current)
        if (opening and opening.previous_token and opening.previous_token.is_name):
            if (previous.value in '(,'):
                if (opening.matching_bracket.previous_token.value == ','):
                    return True
    if ((current.is_name or (current.value in {'*', '**'})) and (previous.value == ',')):
        opening = _GetOpeningBracket(current)
        if (opening and (opening.value == '(') and opening.previous_token and (opening.previous_token.is_name or (opening.previous_token.value in {'*', '**'}))):
            is_func_call = False
            token = current
            while token:
                if (token.value == '('):
                    is_func_call = True
                    break
                if ((not (token.is_name or (token.value in {'*', '**'}))) and (token.value != '.')):
                    break
                token = token.next_token
            if is_func_call:
                if (not self._FitsOnLine(current, opening.matching_bracket)):
                    return True
    pprevious = previous.previous_token
    if (current.is_name and pprevious and pprevious.is_name and (previous.value == '(')):
        if ((not self._FitsOnLine(previous, previous.matching_bracket)) and _IsFunctionCallWithArguments(current)):
            return True
    if (previous.OpensScope() and (not current.OpensScope()) and (format_token.Subtype.SUBSCRIPT_BRACKET not in previous.subtypes)):
        if (not current.is_comment):
            if (pprevious and (not pprevious.is_keyword) and (not pprevious.is_name)):
                token = current
                while (token != previous.matching_bracket):
                    if token.is_comment:
                        return True
                    token = token.next_token
        if (previous.value == '('):
            pptoken = previous.previous_token
            if ((not pptoken) or (not pptoken.is_name)):
                if self._FitsOnLine(previous, previous.matching_bracket):
                    return False
            elif (not self._FitsOnLine(previous, previous.matching_bracket)):
                if (((self.column_limit - self.column) / float(self.column_limit)) < 0.3):
                    return (current.next_token != previous.matching_bracket)
        elif (not self._FitsOnLine(previous, previous.matching_bracket)):
            return True
    if ((format_token.Subtype.COMP_FOR in current.subtypes) and (format_token.Subtype.COMP_FOR not in previous.subtypes)):
        length = _GetLengthOfSubtype(current, format_token.Subtype.COMP_FOR, format_token.Subtype.COMP_IF)
        if ((length + self.column) > self.column_limit):
            return True
    if ((format_token.Subtype.COMP_IF in current.subtypes) and (format_token.Subtype.COMP_IF not in previous.subtypes)):
        length = _GetLengthOfSubtype(current, format_token.Subtype.COMP_IF)
        if ((length + self.column) > self.column_limit):
            return True
    if (style.Get('SPLIT_BEFORE_BITWISE_OPERATOR') and (current.value in '&|') and (previous.lineno < current.lineno)):
        return True
    if (current.is_comment and (previous.lineno < (current.lineno - current.value.count('\n')))):
        return True
    return False
