def add_arguments(method: 'MethodDefinition', arguments: TypeList):
if method._return_type is not None:
raise VectorReductionError(
'Argument list must come before return type',
[method, arguments])
method.arguments = ArgumentList(arguments)
return method
def from_serialized(cls, code, argument_names, argument_types):
ast = preprocess.preprocess(SourceContext.wrap(code))
return cls(
ast.children,
ArgumentList([
Identifier(name, type_name=arg_type)
for name, arg_type in zip(argument_names, argument_types)
]))
def __init__(self,
target,
arguments=None,
stack_args=False,
stack_target=False,
is_captured=None):
super(MethodCall, self).__init__([target, arguments])
self.target, self.arguments, self.stack_args, self.stack_target, self._is_captured = target, (
arguments if arguments is not None else
ArgumentList()), stack_args, stack_target, is_captured
def compile(self, context: CompilationBuffer):
if not self.values:
return
buffer = context.optional()
ref = self[0].compile(buffer) # TODO: remove unnecessary recompilation of first element (used to infer type)
list_type = GenericIdentifier(Identifier('list'), (ref.type,))
last_call = MethodCall(NamedAccess([list_type, Identifier.constructor()])).deriving_from(self)
for value in self: # TODO: validate list is homogeneous, and descend to lowest common type
last_call = MethodCall(NamedAccess([last_call, Identifier("append")]), ArgumentList([value])).deriving_from(self)
return last_call.compile(context)
def __init__(self,
name,
arguments=None,
return_type=None,
static=False,
implicit=False,
token=None):
super(MethodDefinition,
self).__init__([name, arguments, return_type, static, token])
self.name, self.arguments, self._return_type, self.static, self.implicit = name, (
arguments or ArgumentList()), return_type, static, implicit
self.index = None
self.locals = None
def assignment(self, value):
return MethodCall(NamedAccess.extend(self.target, Identifier('set')), ArgumentList([self.index, value]),
is_captured=False) \
.deriving_from(self)
def compile(self, context: CompilationBuffer):
return MethodCall(NamedAccess.extend(self.target, Identifier('get')), ArgumentList([self.index])) \
.deriving_from(self) \
.compile(context)
def parse_instantiating_call(target: Identifier,
arguments: 'ParenthesesVector'):
return MethodCall(NamedAccess.extend(target, Identifier.constructor()),
ArgumentList(arguments))
def parse_method_call(target: NamedAccess, arguments: 'ParenthesesVector'):
return MethodCall(target, ArgumentList(arguments))
def replace_references(self, replacements):
return MethodCall(self.target,
ArgumentList([x.replace_references(replacements) for x in self.arguments]),
self.stack_args,
self._is_captured) \
.deriving_from(replacements.original)