def parse_AnnAssign(self):
typ = parse_type(
self.stmt.annotation,
sigs=self.context.sigs,
custom_structs=self.context.structs,
)
varname = self.stmt.target.id
pos = self.context.new_variable(varname, typ)
if self.stmt.value is None:
return
sub = Expr(self.stmt.value, self.context).ir_node
is_literal_bytes32_assign = (isinstance(sub.typ, ByteArrayType)
and sub.typ.maxlen == 32
and isinstance(typ, BaseType)
and typ.typ == "bytes32"
and sub.typ.is_literal)
# If bytes[32] to bytes32 assignment rewrite sub as bytes32.
if is_literal_bytes32_assign:
sub = IRnode(
util.bytes_to_int(self.stmt.value.s),
typ=BaseType("bytes32"),
)
variable_loc = IRnode.from_list(pos, typ=typ, location=MEMORY)
ir_node = make_setter(variable_loc, sub)
return ir_node
def parse_type(self, ast_node):
return parse_type(ast_node,
sigs=self.interface_names,
custom_structs=self._structs,
enums=self._enums)
def from_definition(
cls,
func_ast, # vy_ast.FunctionDef
sigs=None, # TODO replace sigs and custom_structs with GlobalContext?
custom_structs=None,
interface_def=False,
constant_override=False, # CMC 20210907 what does this do?
is_from_json=False,
):
if custom_structs is None:
custom_structs = {}
name = func_ast.name
args = []
for arg in func_ast.args.args:
argname = arg.arg
argtyp = parse_type(
arg.annotation,
sigs,
custom_structs=custom_structs,
)
args.append(FunctionArg(argname, argtyp, arg))
mutability = "nonpayable" # Assume nonpayable by default
nonreentrant_key = None
is_internal = None
# Update function properties from decorators
# NOTE: Can't import enums here because of circular import
for dec in func_ast.decorator_list:
if isinstance(dec, vy_ast.Name) and dec.id in ("payable", "view", "pure"):
mutability = dec.id
elif isinstance(dec, vy_ast.Name) and dec.id == "internal":
is_internal = True
elif isinstance(dec, vy_ast.Name) and dec.id == "external":
is_internal = False
elif isinstance(dec, vy_ast.Call) and dec.func.id == "nonreentrant":
nonreentrant_key = dec.args[0].s
if constant_override:
# In case this override is abused, match previous behavior
if mutability == "payable":
raise StructureException(f"Function {name} cannot be both constant and payable.")
mutability = "view"
# Determine the return type and whether or not it's constant. Expects something
# of the form:
# def foo(): ...
# def foo() -> int128: ...
# If there is no return type, ie. it's of the form def foo(): ...
# and NOT def foo() -> type: ..., then it's null
return_type = None
if func_ast.returns:
return_type = parse_type(
func_ast.returns,
sigs,
custom_structs=custom_structs,
)
# sanity check: Output type must be canonicalizable
assert return_type.abi_type.selector_name()
return cls(
name,
args,
return_type,
mutability,
is_internal,
nonreentrant_key,
func_ast,
is_from_json,
)
def parse_type(self, ast_node):
return parse_type(
ast_node,
sigs=self._contracts,
custom_structs=self._structs,
)