def test_replace_constant_no(source):
unmodified_ast = vy_ast.parse_to_ast(source)
folded_ast = vy_ast.parse_to_ast(source)
folding.replace_constant(folded_ast, "FOO", vy_ast.Int(value=31337), True)
assert vy_ast.compare_nodes(unmodified_ast, folded_ast)
def abi_type_to_ast(atype, expected_size):
if atype in ("int128", "uint256", "bool", "address", "bytes32"):
return vy_ast.Name(id=atype)
elif atype == "fixed168x10":
return vy_ast.Name(id="decimal")
elif atype in ("bytes", "string"):
# expected_size is the maximum length for inputs, minimum length for outputs
return vy_ast.Subscript(
value=vy_ast.Name(id=atype), slice=vy_ast.Index(value=vy_ast.Int(value=expected_size))
)
else:
raise StructureException(f"Type {atype} not supported by vyper.")
def abi_type_to_ast(atype, expected_size):
if atype in ('int128', 'uint256', 'bool', 'address', 'bytes32'):
return vy_ast.Name(id=atype)
elif atype == 'fixed168x10':
return vy_ast.Name(id='decimal')
elif atype in ('bytes', 'string'):
# expected_size is the maximum length for inputs, minimum length for outputs
return vy_ast.Subscript(
value=vy_ast.Name(id=atype),
slice=vy_ast.Index(value=vy_ast.Int(value=expected_size)))
else:
raise StructureException(f'Type {atype} not supported by vyper.')
def arithmetic(self):
left = Expr.parse_value_expr(self.expr.left, self.context)
right = Expr.parse_value_expr(self.expr.right, self.context)
if not is_numeric_type(left.typ) or not is_numeric_type(right.typ):
raise TypeMismatchException(
f"Unsupported types for arithmetic op: {left.typ} {right.typ}",
self.expr,
)
arithmetic_pair = {left.typ.typ, right.typ.typ}
# Special Case: Simplify any literal to literal arithmetic at compile time.
if left.typ.is_literal and right.typ.is_literal and \
isinstance(right.value, int) and isinstance(left.value, int) and \
arithmetic_pair.issubset({'uint256', 'int128'}):
if isinstance(self.expr.op, vy_ast.Add):
val = left.value + right.value
elif isinstance(self.expr.op, vy_ast.Sub):
val = left.value - right.value
elif isinstance(self.expr.op, vy_ast.Mult):
val = left.value * right.value
elif isinstance(self.expr.op, vy_ast.Pow):
val = left.value ** right.value
elif isinstance(self.expr.op, (vy_ast.Div, vy_ast.Mod)):
if right.value == 0:
raise ZeroDivisionException(
"integer division or modulo by zero",
self.expr,
)
if isinstance(self.expr.op, vy_ast.Div):
val = left.value // right.value
elif isinstance(self.expr.op, vy_ast.Mod):
# modified modulo logic to remain consistent with EVM behaviour
val = abs(left.value) % abs(right.value)
if left.value < 0:
val = -val
else:
raise ParserException(
f'Unsupported literal operator: {type(self.expr.op)}',
self.expr,
)
num = vy_ast.Int(n=val)
num.full_source_code = self.expr.full_source_code
num.node_source_code = self.expr.node_source_code
num.lineno = self.expr.lineno
num.col_offset = self.expr.col_offset
num.end_lineno = self.expr.end_lineno
num.end_col_offset = self.expr.end_col_offset
return Expr.parse_value_expr(num, self.context)
pos = getpos(self.expr)
# Special case with uint256 were int literal may be casted.
if arithmetic_pair == {'uint256', 'int128'}:
# Check right side literal.
if right.typ.is_literal and SizeLimits.in_bounds('uint256', right.value):
right = LLLnode.from_list(
right.value,
typ=BaseType('uint256', None, is_literal=True),
pos=pos,
)
# Check left side literal.
elif left.typ.is_literal and SizeLimits.in_bounds('uint256', left.value):
left = LLLnode.from_list(
left.value,
typ=BaseType('uint256', None, is_literal=True),
pos=pos,
)
if left.typ.typ == "decimal" and isinstance(self.expr.op, vy_ast.Pow):
raise TypeMismatchException(
"Cannot perform exponentiation on decimal values.",
self.expr,
)
# Only allow explicit conversions to occur.
if left.typ.typ != right.typ.typ:
raise TypeMismatchException(
f"Cannot implicitly convert {left.typ.typ} to {right.typ.typ}.",
self.expr,
)
ltyp, rtyp = left.typ.typ, right.typ.typ
if isinstance(self.expr.op, (vy_ast.Add, vy_ast.Sub)):
if left.typ.unit != right.typ.unit and left.typ.unit != {} and right.typ.unit != {}:
raise TypeMismatchException(
f"Unit mismatch: {left.typ.unit} {right.typ.unit}",
self.expr,
)
if (
left.typ.positional and
right.typ.positional and
isinstance(self.expr.op, vy_ast.Add)
):
raise TypeMismatchException(
"Cannot add two positional units!",
self.expr,
)
new_unit = left.typ.unit or right.typ.unit
# xor, as subtracting two positionals gives a delta
new_positional = left.typ.positional ^ right.typ.positional
new_typ = BaseType(ltyp, new_unit, new_positional)
op = 'add' if isinstance(self.expr.op, vy_ast.Add) else 'sub'
if ltyp == 'uint256' and isinstance(self.expr.op, vy_ast.Add):
# safeadd
arith = ['seq',
['assert', ['ge', ['add', 'l', 'r'], 'l']],
['add', 'l', 'r']]
elif ltyp == 'uint256' and isinstance(self.expr.op, vy_ast.Sub):
# safesub
arith = ['seq',
['assert', ['ge', 'l', 'r']],
['sub', 'l', 'r']]
elif ltyp == rtyp:
arith = [op, 'l', 'r']
else:
raise Exception(f"Unsupported Operation '{op}({ltyp}, {rtyp})'")
elif isinstance(self.expr.op, vy_ast.Mult):
if left.typ.positional or right.typ.positional:
raise TypeMismatchException("Cannot multiply positional values!", self.expr)
new_unit = combine_units(left.typ.unit, right.typ.unit)
new_typ = BaseType(ltyp, new_unit)
if ltyp == rtyp == 'uint256':
arith = ['with', 'ans', ['mul', 'l', 'r'],
['seq',
['assert',
['or',
['eq', ['div', 'ans', 'l'], 'r'],
['iszero', 'l']]],
'ans']]
elif ltyp == rtyp == 'int128':
# TODO should this be 'smul' (note edge cases in YP for smul)
arith = ['mul', 'l', 'r']
elif ltyp == rtyp == 'decimal':
# TODO should this be smul
arith = ['with', 'ans', ['mul', 'l', 'r'],
['seq',
['assert',
['or',
['eq', ['sdiv', 'ans', 'l'], 'r'],
['iszero', 'l']]],
['sdiv', 'ans', DECIMAL_DIVISOR]]]
else:
raise Exception(f"Unsupported Operation 'mul({ltyp}, {rtyp})'")
elif isinstance(self.expr.op, vy_ast.Div):
if right.typ.is_literal and right.value == 0:
raise ZeroDivisionException("Cannot divide by 0.", self.expr)
if left.typ.positional or right.typ.positional:
raise TypeMismatchException("Cannot divide positional values!", self.expr)
new_unit = combine_units(left.typ.unit, right.typ.unit, div=True)
new_typ = BaseType(ltyp, new_unit)
if ltyp == rtyp == 'uint256':
arith = ['div', 'l', ['clamp_nonzero', 'r']]
elif ltyp == rtyp == 'int128':
arith = ['sdiv', 'l', ['clamp_nonzero', 'r']]
elif ltyp == rtyp == 'decimal':
arith = ['sdiv',
# TODO check overflow cases, also should it be smul
['mul', 'l', DECIMAL_DIVISOR],
['clamp_nonzero', 'r']]
else:
raise Exception(f"Unsupported Operation 'div({ltyp}, {rtyp})'")
elif isinstance(self.expr.op, vy_ast.Mod):
if right.typ.is_literal and right.value == 0:
raise ZeroDivisionException("Cannot calculate modulus of 0.", self.expr)
if left.typ.positional or right.typ.positional:
raise TypeMismatchException(
"Cannot use positional values as modulus arguments!",
self.expr,
)
if not are_units_compatible(left.typ, right.typ) and not (left.typ.unit or right.typ.unit): # noqa: E501
raise TypeMismatchException("Modulus arguments must have same unit", self.expr)
new_unit = left.typ.unit or right.typ.unit
new_typ = BaseType(ltyp, new_unit)
if ltyp == rtyp == 'uint256':
arith = ['mod', 'l', ['clamp_nonzero', 'r']]
elif ltyp == rtyp:
# TODO should this be regular mod
arith = ['smod', 'l', ['clamp_nonzero', 'r']]
else:
raise Exception(f"Unsupported Operation 'mod({ltyp}, {rtyp})'")
elif isinstance(self.expr.op, vy_ast.Pow):
if left.typ.positional or right.typ.positional:
raise TypeMismatchException(
"Cannot use positional values as exponential arguments!",
self.expr,
)
if right.typ.unit:
raise TypeMismatchException(
"Cannot use unit values as exponents",
self.expr,
)
if ltyp != 'int128' and ltyp != 'uint256' and isinstance(self.expr.right, vy_ast.Name):
raise TypeMismatchException(
"Cannot use dynamic values as exponents, for unit base types",
self.expr,
)
new_unit = left.typ.unit
if left.typ.unit and not isinstance(self.expr.right, vy_ast.Name):
new_unit = {left.typ.unit.copy().popitem()[0]: self.expr.right.n}
new_typ = BaseType(ltyp, new_unit)
if ltyp == rtyp == 'uint256':
arith = ['seq',
['assert',
['or',
# r == 1 | iszero(r)
# could be simplified to ~(r & 1)
['or', ['eq', 'r', 1], ['iszero', 'r']],
['lt', 'l', ['exp', 'l', 'r']]]],
['exp', 'l', 'r']]
elif ltyp == rtyp == 'int128':
arith = ['exp', 'l', 'r']
else:
raise TypeMismatchException('Only whole number exponents are supported', self.expr)
else:
raise ParserException(f"Unsupported binary operator: {self.expr.op}", self.expr)
p = ['seq']
if new_typ.typ == 'int128':
p.append([
'clamp',
['mload', MemoryPositions.MINNUM],
arith,
['mload', MemoryPositions.MAXNUM],
])
elif new_typ.typ == 'decimal':
p.append([
'clamp',
['mload', MemoryPositions.MINDECIMAL],
arith,
['mload', MemoryPositions.MAXDECIMAL],
])
elif new_typ.typ == 'uint256':
p.append(arith)
else:
raise Exception(f"{arith} {new_typ}")
p = ['with', 'l', left, ['with', 'r', right, p]]
return LLLnode.from_list(p, typ=new_typ, pos=pos)
