forked from VimPlug/jedi
355 lines
12 KiB
Python
355 lines
12 KiB
Python
"""
|
|
Handles operator precedence.
|
|
"""
|
|
import operator
|
|
|
|
from jedi._compatibility import unicode
|
|
from jedi.parser import tree as pr
|
|
from jedi import debug
|
|
from jedi.common import PushBackIterator
|
|
from jedi.evaluate.compiled import (CompiledObject, create, builtin,
|
|
keyword_from_value, true_obj, false_obj)
|
|
from jedi.evaluate import analysis
|
|
|
|
# Maps Python syntax to the operator module.
|
|
COMPARISON_OPERATORS = {
|
|
'==': operator.eq,
|
|
'!=': operator.ne,
|
|
'is': operator.is_,
|
|
'is not': operator.is_not,
|
|
'<': operator.lt,
|
|
'<=': operator.le,
|
|
'>': operator.gt,
|
|
'>=': operator.ge,
|
|
}
|
|
|
|
|
|
class PythonGrammar(object):
|
|
"""
|
|
Some kind of mirror of http://docs.python.org/3/reference/grammar.html.
|
|
"""
|
|
|
|
class MultiPart(str):
|
|
def __new__(cls, first, second):
|
|
self = str.__new__(cls, first)
|
|
self.second = second
|
|
return self
|
|
|
|
def __str__(self):
|
|
return str.__str__(self) + ' ' + self.second
|
|
|
|
FACTOR = '+', '-', '~'
|
|
POWER = '**',
|
|
TERM = '*', '/', '%', '//'
|
|
ARITH_EXPR = '+', '-'
|
|
|
|
SHIFT_EXPR = '<<', '>>'
|
|
AND_EXPR = '&',
|
|
XOR_EXPR = '^',
|
|
EXPR = '|',
|
|
|
|
COMPARISON = ('<', '>', '==', '>=', '<=', '!=', 'in',
|
|
MultiPart('not', 'in'), MultiPart('is', 'not'), 'is')
|
|
|
|
NOT_TEST = 'not',
|
|
AND_TEST = 'and',
|
|
OR_TEST = 'or',
|
|
|
|
#TEST = or_test ['if' or_test 'else' test] | lambdef
|
|
|
|
TERNARY = 'if',
|
|
SLICE = ':',
|
|
|
|
ORDER = (POWER, TERM, ARITH_EXPR, SHIFT_EXPR, AND_EXPR, XOR_EXPR,
|
|
EXPR, COMPARISON, AND_TEST, OR_TEST, TERNARY, SLICE)
|
|
|
|
FACTOR_PRIORITY = 0 # highest priority
|
|
LOWEST_PRIORITY = len(ORDER)
|
|
NOT_TEST_PRIORITY = LOWEST_PRIORITY - 4 # priority only lower for `and`/`or`
|
|
SLICE_PRIORITY = LOWEST_PRIORITY - 1 # priority only lower for `and`/`or`
|
|
|
|
|
|
class Precedence(object):
|
|
def __init__(self, left, operator, right):
|
|
self.left = left
|
|
self.operator = operator
|
|
self.right = right
|
|
|
|
def parse_tree(self, strip_literals=False):
|
|
def process(which):
|
|
try:
|
|
which = which.parse_tree(strip_literals)
|
|
except AttributeError:
|
|
pass
|
|
if strip_literals and isinstance(which, pr.Literal):
|
|
which = which.value
|
|
return which
|
|
|
|
return (process(self.left), self.operator.string, process(self.right))
|
|
|
|
def __repr__(self):
|
|
return '(%s %s %s)' % (self.left, self.operator, self.right)
|
|
|
|
|
|
class TernaryPrecedence(Precedence):
|
|
def __init__(self, left, operator, right, check):
|
|
super(TernaryPrecedence, self).__init__(left, operator, right)
|
|
self.check = check
|
|
|
|
|
|
def create_precedence(expression_list):
|
|
iterator = PushBackIterator(iter(expression_list))
|
|
return _check_operator(iterator)
|
|
|
|
|
|
def _syntax_error(element, msg='SyntaxError in precedence'):
|
|
debug.warning('%s: %s, %s' % (msg, element, element.start_pos))
|
|
|
|
|
|
def _get_number(iterator, priority=PythonGrammar.LOWEST_PRIORITY):
|
|
el = next(iterator)
|
|
if isinstance(el, pr.Operator):
|
|
if el in PythonGrammar.FACTOR:
|
|
right = _get_number(iterator, PythonGrammar.FACTOR_PRIORITY)
|
|
elif el in PythonGrammar.NOT_TEST \
|
|
and priority >= PythonGrammar.NOT_TEST_PRIORITY:
|
|
right = _get_number(iterator, PythonGrammar.NOT_TEST_PRIORITY)
|
|
elif el in PythonGrammar.SLICE \
|
|
and priority >= PythonGrammar.SLICE_PRIORITY:
|
|
iterator.push_back(el)
|
|
return None
|
|
else:
|
|
_syntax_error(el)
|
|
return _get_number(iterator, priority)
|
|
return Precedence(None, el, right)
|
|
elif isinstance(el, pr.tokenize.Token):
|
|
return _get_number(iterator, priority)
|
|
else:
|
|
return el
|
|
|
|
|
|
class MergedOperator(pr.Operator):
|
|
"""
|
|
A way to merge the two operators `is not` and `not int`, which are two
|
|
words instead of one.
|
|
Maybe there's a better way (directly in the tokenizer/parser? but for now
|
|
this is fine.)
|
|
"""
|
|
def __init__(self, first, second):
|
|
string = first.string + ' ' + second.string
|
|
super(MergedOperator, self).__init__(first._sub_module, string,
|
|
first.parent, first.start_pos)
|
|
self.first = first
|
|
self.second = second
|
|
|
|
|
|
def _check_operator(iterator, priority=PythonGrammar.LOWEST_PRIORITY):
|
|
try:
|
|
left = _get_number(iterator, priority)
|
|
except StopIteration:
|
|
return None
|
|
|
|
for el in iterator:
|
|
if not isinstance(el, pr.Operator):
|
|
_syntax_error(el)
|
|
continue
|
|
|
|
operator = None
|
|
for check_prio, check in enumerate(PythonGrammar.ORDER):
|
|
if check_prio >= priority:
|
|
# respect priorities.
|
|
iterator.push_back(el)
|
|
return left
|
|
|
|
try:
|
|
match_index = check.index(el)
|
|
except ValueError:
|
|
continue
|
|
|
|
match = check[match_index]
|
|
if isinstance(match, PythonGrammar.MultiPart):
|
|
next_tok = next(iterator)
|
|
if next_tok == match.second:
|
|
el = MergedOperator(el, next_tok)
|
|
else:
|
|
iterator.push_back(next_tok)
|
|
if el == 'not':
|
|
continue
|
|
|
|
operator = el
|
|
break
|
|
|
|
if operator is None:
|
|
_syntax_error(el)
|
|
continue
|
|
|
|
if operator in PythonGrammar.POWER:
|
|
check_prio += 1 # to the power of is right-associative
|
|
elif operator in PythonGrammar.TERNARY:
|
|
try:
|
|
middle = []
|
|
for each in iterator:
|
|
if each == 'else':
|
|
break
|
|
middle.append(each)
|
|
middle = create_precedence(middle)
|
|
except StopIteration:
|
|
_syntax_error(operator, 'SyntaxError ternary incomplete')
|
|
right = _check_operator(iterator, check_prio)
|
|
if right is None and not operator in PythonGrammar.SLICE:
|
|
_syntax_error(iterator.current, 'SyntaxError operand missing')
|
|
else:
|
|
if operator in PythonGrammar.TERNARY:
|
|
left = TernaryPrecedence(left, operator, right, middle)
|
|
else:
|
|
left = Precedence(left, operator, right)
|
|
return left
|
|
|
|
|
|
def _literals_to_types(evaluator, result):
|
|
# Changes literals ('a', 1, 1.0, etc) to its type instances (str(),
|
|
# int(), float(), etc).
|
|
for i, r in enumerate(result):
|
|
if is_literal(r):
|
|
# Literals are only valid as long as the operations are
|
|
# correct. Otherwise add a value-free instance.
|
|
cls = builtin.get_by_name(r.name.get_code())
|
|
result[i] = evaluator.execute(cls)[0]
|
|
return list(set(result))
|
|
|
|
|
|
def calculate_children(evaluator, children):
|
|
"""
|
|
Calculate a list of children with operators.
|
|
"""
|
|
iterator = iter(children)
|
|
types = evaluator.eval_element(next(iterator))
|
|
for operator in iterator:
|
|
right = next(iterator)
|
|
if pr.is_node(operator, 'comp_op'): # not in / is not
|
|
operator = ' '.join(str(c.value) for c in operator.children)
|
|
|
|
# handle lazy evaluation of and/or here.
|
|
if operator in ('and', 'or'):
|
|
left_bools = set([left.py__bool__() for left in types])
|
|
if left_bools == set([True]):
|
|
if operator == 'and':
|
|
types = evaluator.eval_element(right)
|
|
elif left_bools == set([False]):
|
|
if operator != 'and':
|
|
types = evaluator.eval_element(right)
|
|
# Otherwise continue, because of uncertainty.
|
|
else:
|
|
types = calculate(evaluator, types, operator,
|
|
evaluator.eval_element(right))
|
|
return types
|
|
|
|
|
|
def calculate(evaluator, left_result, operator, right_result):
|
|
result = []
|
|
if not left_result or not right_result:
|
|
# illegal slices e.g. cause left/right_result to be None
|
|
result = (left_result or []) + (right_result or [])
|
|
result = _literals_to_types(evaluator, result)
|
|
else:
|
|
# I don't think there's a reasonable chance that a string
|
|
# operation is still correct, once we pass something like six
|
|
# objects.
|
|
if len(left_result) * len(right_result) > 6:
|
|
result = _literals_to_types(evaluator, left_result + right_result)
|
|
else:
|
|
for left in left_result:
|
|
for right in right_result:
|
|
result += _element_calculate(evaluator, left, operator, right)
|
|
return result
|
|
|
|
|
|
def factor_calculate(evaluator, types, operator):
|
|
"""
|
|
Calculates `+`, `-`, `~` and `not` prefixes.
|
|
"""
|
|
for typ in types:
|
|
if _is_number(typ):
|
|
if operator == '-':
|
|
yield create(evaluator, -typ.obj)
|
|
if operator == 'not':
|
|
value = typ.py__bool__()
|
|
if value is None: # Uncertainty.
|
|
return
|
|
yield keyword_from_value(not value)
|
|
else:
|
|
yield typ
|
|
|
|
|
|
def _is_number(obj):
|
|
return isinstance(obj, CompiledObject) \
|
|
and isinstance(obj.obj, (int, float))
|
|
|
|
|
|
def is_string(obj):
|
|
return isinstance(obj, CompiledObject) \
|
|
and isinstance(obj.obj, (str, unicode))
|
|
|
|
|
|
def is_literal(obj):
|
|
return _is_number(obj) or is_string(obj)
|
|
|
|
|
|
def _is_tuple(obj):
|
|
from jedi.evaluate import iterable
|
|
return isinstance(obj, iterable.Array) and obj.type == pr.Array.TUPLE
|
|
|
|
|
|
def _is_list(obj):
|
|
from jedi.evaluate import iterable
|
|
return isinstance(obj, iterable.Array) and obj.type == pr.Array.LIST
|
|
|
|
|
|
def _element_calculate(evaluator, left, operator, right):
|
|
from jedi.evaluate import iterable, representation as er
|
|
l_is_num = _is_number(left)
|
|
r_is_num = _is_number(right)
|
|
if operator == '*':
|
|
# for iterables, ignore * operations
|
|
if isinstance(left, iterable.Array) or is_string(left):
|
|
return [left]
|
|
elif isinstance(right, iterable.Array) or is_string(right):
|
|
return [right]
|
|
elif operator == '+':
|
|
if l_is_num and r_is_num or is_string(left) and is_string(right):
|
|
return [create(evaluator, left.obj + right.obj)]
|
|
elif _is_tuple(left) and _is_tuple(right) or _is_list(left) and _is_list(right):
|
|
return [iterable.MergedArray(evaluator, (left, right))]
|
|
elif operator == '-':
|
|
if l_is_num and r_is_num:
|
|
return [create(evaluator, left.obj - right.obj)]
|
|
elif operator == '%':
|
|
# With strings and numbers the left type typically remains. Except for
|
|
# `int() % float()`.
|
|
return [left]
|
|
elif operator in COMPARISON_OPERATORS:
|
|
operation = COMPARISON_OPERATORS[operator]
|
|
if isinstance(left, CompiledObject) and isinstance(right, CompiledObject):
|
|
# Possible, because the return is not an option. Just compare.
|
|
left = left.obj
|
|
right = right.obj
|
|
|
|
try:
|
|
return [keyword_from_value(operation(left, right))]
|
|
except TypeError:
|
|
# Could be True or False.
|
|
return [true_obj, false_obj]
|
|
|
|
def check(obj):
|
|
"""Checks if a Jedi object is either a float or an int."""
|
|
return isinstance(obj, er.Instance) and obj.name.get_code() in ('int', 'float')
|
|
|
|
# Static analysis, one is a number, the other one is not.
|
|
if operator in ('+', '-') and l_is_num != r_is_num \
|
|
and not (check(left) or check(right)):
|
|
message = "TypeError: unsupported operand type(s) for +: %s and %s"
|
|
analysis.add(evaluator, 'type-error-operation', operator,
|
|
message % (left, right))
|
|
|
|
return [left, right]
|