# --no-cc
var opt_no_cc: OptionBool = new OptionBool("Do not invoke C compiler", "--no-cc")
+ # --make-flags
+ var opt_make_flags: OptionString = new OptionString("Additional options to make", "--make-flags")
+
# --hardening
var opt_hardening: OptionBool = new OptionBool("Generate contracts in the C code against bugs in the compiler", "--hardening")
+ # --no-shortcut-range
+ var opt_no_shortcut_range: OptionBool = new OptionBool("Always insantiate a range and its iterator on 'for' loops", "--no-shortcut-range")
+
# --no-check-covariance
var opt_no_check_covariance: OptionBool = new OptionBool("Disable type tests of covariant parameters (dangerous)", "--no-check-covariance")
# --no-check-assert
var opt_no_check_assert: OptionBool = new OptionBool("Disable the evaluation of explicit 'assert' and 'as' (dangerous)", "--no-check-assert")
+ # --no-check-autocast
+ var opt_no_check_autocast: OptionBool = new OptionBool("Disable implicit casts on unsafe expression usage (dangerous)", "--no-check-autocast")
+
# --no-check-other
var opt_no_check_other: OptionBool = new OptionBool("Disable implicit tests: unset attribute, null receiver (dangerous)", "--no-check-other")
+ # --typing-test-metrics
+ var opt_typing_test_metrics: OptionBool = new OptionBool("Enable static and dynamic count of all type tests", "--typing-test-metrics")
+
redef init
do
super
- self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_hardening)
- self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_initialization, self.opt_no_check_assert, self.opt_no_check_other)
+ self.option_context.add_option(self.opt_output, self.opt_no_cc, self.opt_make_flags, self.opt_hardening, self.opt_no_shortcut_range)
+ self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_initialization, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_other)
+ self.option_context.add_option(self.opt_typing_test_metrics)
end
end
self.toolcontext.info("*** COMPILING TO C ***", 1)
var compiler = new GlobalCompiler(mainmodule, runtime_type_analysis, self)
- var v = compiler.new_visitor
-
- v.add_decl("#include <stdlib.h>")
- v.add_decl("#include <stdio.h>")
- v.add_decl("#include <string.h>")
-
- # TODO: Better way to activate the GC
- v.add_decl("#include <gc/gc.h>")
- #v.add_decl("#define GC_MALLOC(x) calloc(1, (x))")
-
- # Declaration of structures the live Nit types
- # Each live type is generated as an independent C `struct' type.
- # They only share a common first field `classid` used to implement the polymorphism.
- # Usualy, all C variables that refers to a Nit object are typed on the abstract struct `val' that contains only the `classid` field.
+ compiler.compile_header
+ var v = compiler.header
- v.add_decl("typedef struct \{int classid;\} val; /* general C type representing a Nit instance. */")
for t in runtime_type_analysis.live_types do
compiler.declare_runtimeclass(v, t)
end
- # Global variable used by the legacy native interface
-
- v.add_decl("extern int glob_argc;")
- v.add_decl("extern char **glob_argv;")
- v.add_decl("extern val *glob_sys;")
-
- # Class names (for the class_name and output_class_name methods)
-
- v.add_decl("extern const char const * class_names[];")
- v.add("const char const * class_names[] = \{")
- for t in runtime_type_analysis.live_types do
- v.add("\"{t}\", /* {compiler.classid(t)} */")
- end
- v.add("\};")
- compiler.header = v
+ compiler.compile_class_names
# Init instance code (allocate and init-arguments)
-
for t in runtime_type_analysis.live_types do
if t.ctype == "val*" then
compiler.generate_init_instance(t)
compiler.compile_main_function
# Compile until all runtime_functions are visited
-
while not compiler.todos.is_empty do
var m = compiler.todos.shift
self.toolcontext.info("Compile {m} ({compiler.seen.length-compiler.todos.length}/{compiler.seen.length})", 3)
end
self.toolcontext.info("Total methods to compile to C: {compiler.visitors.length}", 2)
+ compiler.display_stats
+
var time1 = get_time
self.toolcontext.info("*** END VISITING: {time1-time0} ***", 2)
write_and_make(compiler)
var i = 0
for vis in compiler.visitors do
count += vis.lines.length
- if file == null or count > 10000 then
+ if file == null or count > 10000 or vis.file_break then
i += 1
if file != null then file.close
var cfilename = ".nit_compile/{mainmodule.name}.{i}.c"
time0 = time1
self.toolcontext.info("*** COMPILING C ***", 1)
- self.toolcontext.info("make -B -f {makename} -j 4", 2)
+ var makeflags = self.toolcontext.opt_make_flags.value
+ if makeflags == null then makeflags = ""
+ self.toolcontext.info("make -B -f {makename} -j 4 {makeflags}", 2)
var res
if self.toolcontext.verbose_level >= 3 then
- res = sys.system("make -B -f {makename} -j 4 2>&1")
+ res = sys.system("make -B -f {makename} -j 4 {makeflags} 2>&1")
else
- res = sys.system("make -B -f {makename} -j 4 2>&1 >/dev/null")
+ res = sys.system("make -B -f {makename} -j 4 {makeflags} 2>&1 >/dev/null")
end
if res != 0 then
toolcontext.error(null, "make failed! Error code: {res}.")
# Singleton that store the knowledge about the compilation process
class GlobalCompiler
# The main module of the program
- var mainmodule: MModule
+ var mainmodule: MModule writable
# The result of the RTA (used to know live types and methods)
var runtime_type_analysis: RapidTypeAnalysis
init(mainmodule: MModule, runtime_type_analysis: RapidTypeAnalysis, modelbuilder: ModelBuilder)
do
+ self.header = new_visitor
self.mainmodule = mainmodule
self.runtime_type_analysis = runtime_type_analysis
self.modelbuilder = modelbuilder
end
end
+ # Force the creation of a new file
+ # The point is to avoid contamination between must-be-compiled-separately files
+ fun new_file
+ do
+ var v = self.new_visitor
+ v.file_break = true
+ end
+
+ fun compile_header do
+ var v = self.header
+ self.header.add_decl("#include <stdlib.h>")
+ self.header.add_decl("#include <stdio.h>")
+ self.header.add_decl("#include <string.h>")
+ self.header.add_decl("#ifndef NOBOEHM")
+ self.header.add_decl("#include <gc/gc.h>")
+ self.header.add_decl("#ifdef NOBOEHM_ATOMIC")
+ self.header.add_decl("#undef GC_MALLOC_ATOMIC")
+ self.header.add_decl("#define GC_MALLOC_ATOMIC(x) GC_MALLOC(x)")
+ self.header.add_decl("#endif /*NOBOEHM_ATOMIC*/")
+ self.header.add_decl("#else /*NOBOEHM*/")
+ self.header.add_decl("#define GC_MALLOC(x) calloc(1, (x))")
+ self.header.add_decl("#define GC_MALLOC_ATOMIC(x) calloc(1, (x))")
+ self.header.add_decl("#endif /*NOBOEHM*/")
+
+ compile_header_structs
+
+ # Global variable used by the legacy native interface
+ self.header.add_decl("extern int glob_argc;")
+ self.header.add_decl("extern char **glob_argv;")
+ self.header.add_decl("extern val *glob_sys;")
+ end
+
+ # Class names (for the class_name and output_class_name methods)
+ protected fun compile_class_names do
+ self.header.add_decl("extern const char const * class_names[];")
+ self.header.add("const char const * class_names[] = \{")
+ for t in self.runtime_type_analysis.live_types do
+ self.header.add("\"{t}\", /* {self.classid(t)} */")
+ end
+ self.header.add("\};")
+ end
+
+ # Declaration of structures the live Nit types
+ # Each live type is generated as an independent C `struct' type.
+ # They only share a common first field `classid` used to implement the polymorphism.
+ # Usualy, all C variables that refers to a Nit object are typed on the abstract struct `val' that contains only the `classid` field.
+ protected fun compile_header_structs do
+ self.header.add_decl("typedef struct \{int classid;\} val; /* general C type representing a Nit instance. */")
+ end
+
# Subset of runtime_type_analysis.live_types that contains only primitive types
# Used to implement the equal test
var live_primitive_types: Array[MClassType]
#
# FIXME: should not be a vistor but just somewhere to store lines
# FIXME: should not have a global .h since it does not help recompilations
- var header: nullable GlobalCompilerVisitor writable = null
+ var header: GlobalCompilerVisitor writable
# The list of all associated visitors
# Used to generate .c files
# Initialize a visitor specific for a compiler engine
fun new_visitor: GlobalCompilerVisitor do return new GlobalCompilerVisitor(self)
+ var count_type_test_tags: Array[String] = ["isa", "as", "auto", "covariance", "erasure"]
+ var count_type_test_resolved: HashMap[String, Int] = init_count_type_test_tags
+ var count_type_test_unresolved: HashMap[String, Int] = init_count_type_test_tags
+ var count_type_test_skipped: HashMap[String, Int] = init_count_type_test_tags
+
+ private fun init_count_type_test_tags: HashMap[String, Int]
+ do
+ var res = new HashMap[String, Int]
+ for tag in count_type_test_tags do
+ res[tag] = 0
+ end
+ return res
+ end
+
# Generate the main C function.
# This function:
# allocate the Sys object if it exists
v.add_decl("int glob_argc;")
v.add_decl("char **glob_argv;")
v.add_decl("val *glob_sys;")
+
+ if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
+ for tag in count_type_test_tags do
+ v.add_decl("long count_type_test_resolved_{tag};")
+ v.add_decl("long count_type_test_unresolved_{tag};")
+ v.add_decl("long count_type_test_skipped_{tag};")
+ v.compiler.header.add_decl("extern long count_type_test_resolved_{tag};")
+ v.compiler.header.add_decl("extern long count_type_test_unresolved_{tag};")
+ v.compiler.header.add_decl("extern long count_type_test_skipped_{tag};")
+ end
+ end
v.add_decl("int main(int argc, char** argv) \{")
v.add("glob_argc = argc; glob_argv = argv;")
var main_type = mainmodule.sys_type
v.send(main_method, [glob_sys])
end
end
+
+ if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
+ v.add_decl("long count_type_test_resolved_total = 0;")
+ v.add_decl("long count_type_test_unresolved_total = 0;")
+ v.add_decl("long count_type_test_skipped_total = 0;")
+ v.add_decl("long count_type_test_total_total = 0;")
+ for tag in count_type_test_tags do
+ v.add_decl("long count_type_test_total_{tag};")
+ v.add("count_type_test_total_{tag} = count_type_test_resolved_{tag} + count_type_test_unresolved_{tag} + count_type_test_skipped_{tag};")
+ v.add("count_type_test_resolved_total += count_type_test_resolved_{tag};")
+ v.add("count_type_test_unresolved_total += count_type_test_unresolved_{tag};")
+ v.add("count_type_test_skipped_total += count_type_test_skipped_{tag};")
+ v.add("count_type_test_total_total += count_type_test_total_{tag};")
+ end
+ v.add("printf(\"# dynamic count_type_test: total %l\\n\");")
+ v.add("printf(\"\\tresolved\\tunresolved\\tskipped\\ttotal\\n\");")
+ var tags = count_type_test_tags.to_a
+ tags.add("total")
+ for tag in tags do
+ v.add("printf(\"{tag}\");")
+ v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_resolved_{tag}, 100.0*count_type_test_resolved_{tag}/count_type_test_total_total);")
+ v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_unresolved_{tag}, 100.0*count_type_test_unresolved_{tag}/count_type_test_total_total);")
+ v.add("printf(\"\\t%ld (%.2f%%)\", count_type_test_skipped_{tag}, 100.0*count_type_test_skipped_{tag}/count_type_test_total_total);")
+ v.add("printf(\"\\t%ld (%.2f%%)\\n\", count_type_test_total_{tag}, 100.0*count_type_test_total_{tag}/count_type_test_total_total);")
+ end
+ end
v.add("return 0;")
v.add("\}")
end
+ fun div(a,b:Int):String
+ do
+ if b == 0 then return "n/a"
+ return ((a*10000/b).to_f / 100.0).to_precision(2)
+ end
+
+ fun display_stats
+ do
+ if self.modelbuilder.toolcontext.opt_typing_test_metrics.value then
+ print "# static count_type_test"
+ print "\tresolved:\tunresolved\tskipped\ttotal"
+ var count_type_test_total = init_count_type_test_tags
+ count_type_test_resolved["total"] = 0
+ count_type_test_unresolved["total"] = 0
+ count_type_test_skipped["total"] = 0
+ count_type_test_total["total"] = 0
+ for tag in count_type_test_tags do
+ count_type_test_total[tag] = count_type_test_resolved[tag] + count_type_test_unresolved[tag] + count_type_test_skipped[tag]
+ count_type_test_resolved["total"] += count_type_test_resolved[tag]
+ count_type_test_unresolved["total"] += count_type_test_unresolved[tag]
+ count_type_test_skipped["total"] += count_type_test_skipped[tag]
+ count_type_test_total["total"] += count_type_test_total[tag]
+ end
+ var count_type_test = count_type_test_total["total"]
+ var tags = count_type_test_tags.to_a
+ tags.add("total")
+ for tag in tags do
+ printn tag
+ printn "\t{count_type_test_resolved[tag]} ({div(count_type_test_resolved[tag],count_type_test)}%)"
+ printn "\t{count_type_test_unresolved[tag]} ({div(count_type_test_unresolved[tag],count_type_test)}%)"
+ printn "\t{count_type_test_skipped[tag]} ({div(count_type_test_skipped[tag],count_type_test)}%)"
+ printn "\t{count_type_test_total[tag]} ({div(count_type_test_total[tag],count_type_test)}%)"
+ print ""
+ end
+ end
+ end
+
private var collect_types_cache: HashMap[MType, Array[MClassType]] = new HashMap[MType, Array[MClassType]]
end
return "val*"
end
+ fun ctypename: String
+ do
+ return "val"
+ end
+
# Return the name of the C structure associated to a Nit live type
# FIXME: move to GlobalCompiler so we can check that self is a live type
fun c_name: String is abstract
return "val*"
end
end
+
+ redef fun ctypename: String
+ do
+ if mclass.name == "Int" then
+ return "l"
+ else if mclass.name == "Bool" then
+ return "s"
+ else if mclass.name == "Char" then
+ return "c"
+ else if mclass.name == "Float" then
+ return "d"
+ else if mclass.name == "NativeString" then
+ return "str"
+ else if mclass.name == "NativeArray" then
+ #return "{self.arguments.first.ctype}*"
+ return "val"
+ else if mclass.kind == extern_kind then
+ return "ptr"
+ else
+ return "val"
+ end
+ end
end
redef class MGenericType
end
end
-redef class MParameterType
- redef fun c_name
- do
- var res = self.c_name_cache
- if res != null then return res
- res = "FT{self.rank}"
- self.c_name_cache = res
- return res
- end
-end
-
-redef class MNullableType
- redef fun c_name
- do
- var res = self.c_name_cache
- if res != null then return res
- res = "nullable_{self.mtype.c_name}"
- self.c_name_cache = res
- return res
- end
-end
-
# A C function associated to a Nit method
# Because of customization, a given Nit method can be compiler more that once
abstract class AbstractRuntimeFunction
compiler.visitors.add(self)
end
+ var file_break: Bool = false
+
# Alias for self.compiler.mainmodule.object_type
fun object_type: MClassType do return self.compiler.mainmodule.object_type
mtype = self.anchor(mtype)
res = self.autobox(res, mtype)
end
+ res = autoadapt(res, nexpr.mtype.as(not null))
+ var implicit_cast_to = nexpr.implicit_cast_to
+ if implicit_cast_to != null and not self.compiler.modelbuilder.toolcontext.opt_no_check_autocast.value then
+ var castres = self.type_test(res, implicit_cast_to, "auto")
+ self.add("if (!{castres}) \{")
+ self.add_abort("Cast failed")
+ self.add("\}")
+ res = autoadapt(res, implicit_cast_to)
+ end
self.current_node = old
return res
end
end
end
+ fun compile_callsite(callsite: CallSite, args: Array[RuntimeVariable]): nullable RuntimeVariable
+ do
+ var ret = self.send(callsite.mproperty, args)
+ return ret
+ end
+
# Generate a polymorphic send for the method `m' and the arguments `args'
fun send(m: MMethod, args: Array[RuntimeVariable]): nullable RuntimeVariable
do
self.add("/* skip, no method {m} */")
return res
end
- var propdefs = m.lookup_definitions(self.compiler.mainmodule, mclasstype)
- if propdefs.length == 0 then
- self.add("/* skip, no method {m} */")
- return res
- end
- assert propdefs.length == 1
- var propdef = propdefs.first
+ var propdef = m.lookup_first_definition(self.compiler.mainmodule, mclasstype)
var res2 = self.call(propdef, mclasstype, args)
if res != null then self.assign(res, res2.as(not null))
return res
var last = types.last
var defaultpropdef: nullable MMethodDef = null
for t in types do
- var propdefs = m.lookup_definitions(self.compiler.mainmodule, t)
- if propdefs.length == 0 then
- self.add("/* skip {t}, no method {m} */")
- continue
- end
- if propdefs.length > 1 then
- self.debug("NOT YET IMPLEMENTED conflict for {t}.{m}: {propdefs.join(" ")}. choose the first")
- end
- var propdef = propdefs.first
+ var propdef = m.lookup_first_definition(self.compiler.mainmodule, t)
if propdef.mclassdef.mclass.name == "Object" and t.ctype == "val*" then
defaultpropdef = propdef
continue
fun monomorphic_send(m: MMethod, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable
do
assert t isa MClassType
- var propdefs = m.lookup_definitions(self.compiler.mainmodule, t)
- if propdefs.length == 0 then
- abort
- end
- if propdefs.length > 1 then
- self.debug("NOT YET IMPLEMENTED conflict for {t}.{m}: {propdefs.join(" ")}. choose the first")
- end
- var propdef = propdefs.first
+ var propdef = m.lookup_first_definition(self.compiler.mainmodule, t)
return self.call(propdef, t, args)
end
recv = self.autoadapt(recv, recvtype)
args = args.to_a
- self.varargize(m.msignature.as(not null), args)
+ self.varargize(m, m.msignature.as(not null), args)
if args.length != m.msignature.arity + 1 then # because of self
add("printf(\"NOT YET IMPLEMENTED: Invalid arity for {m}. {args.length} arguments given.\\n\"); exit(1);")
debug("NOT YET IMPLEMENTED: Invalid arity for {m}. {args.length} arguments given.")
# Transform varargs, in raw arguments, into a single argument of type Array
# Note: this method modify the given `args`
# If there is no vararg, then `args` is not modified.
- fun varargize(msignature: MSignature, args: Array[RuntimeVariable])
+ fun varargize(mpropdef: MPropDef, msignature: MSignature, args: Array[RuntimeVariable])
do
var recv = args.first
var vararg_rank = msignature.vararg_rank
for i in [vararg_rank..vararg_lastrank] do
vararg.add(rawargs[i+1])
end
- # FIXME: its it to late to determine the vararg type, this should have been done during a previous analysis
+
var elttype = msignature.mparameters[vararg_rank].mtype
- elttype = self.resolve_for(elttype, recv)
- args.add(self.array_instance(vararg, elttype))
+ args.add(self.vararg_instance(mpropdef, recv, vararg, elttype))
for i in [vararg_lastrank+1..rawargs.length-1[ do
args.add(rawargs[i+1])
end
end
+ # Get an instance of a anny for a vararg
+ fun vararg_instance(mpropdef: MPropDef, recv: RuntimeVariable, varargs: Array[RuntimeVariable], elttype: MType): RuntimeVariable
+ do
+ # FIXME: this is currently buggy since recv is not exact
+
+ elttype = self.resolve_for(elttype, recv)
+ return self.array_instance(varargs, elttype)
+ end
+
+
fun bugtype(recv: RuntimeVariable)
do
if recv.mtype.ctype != "val*" then return
end
# Generate a polymorphic subtype test
- fun type_test(value: RuntimeVariable, mtype: MType): RuntimeVariable
+ fun type_test(value: RuntimeVariable, mtype: MType, tag: String): RuntimeVariable
do
mtype = self.anchor(mtype)
var mclasstype = mtype
# generate the cast
# note that v decides if and how to implements the cast
v.add("/* Covariant cast for argument {i} ({self.msignature.mparameters[i].name}) {arguments[i+1].inspect} isa {mtype} */")
- var cond = v.type_test( arguments[i+1], mtype)
+ var cond = v.type_test(arguments[i+1], mtype, "covariance")
v.add("if (!{cond}) \{")
#var x = v.class_name_string(arguments[i+1])
#var y = v.class_name_string(arguments.first)
v.ret(v.new_expr("glob_sys", ret.as(not null)))
return
else if pname == "calloc_string" then
- v.ret(v.new_expr("(char*)GC_MALLOC({arguments[1]})", ret.as(not null)))
+ v.ret(v.new_expr("(char*)GC_MALLOC_ATOMIC({arguments[1]})", ret.as(not null)))
return
else if pname == "calloc_array" then
v.calloc_array(ret.as(not null), arguments)
var variable = self.variable.as(not null)
var vari = v.variable(variable)
var value = v.expr(self.n_value, variable.declared_type)
- var res = v.send(reassign_property.mproperty, [vari, value])
+ var res = v.compile_callsite(self.reassign_callsite.as(not null), [vari, value])
assert res != null
v.assign(v.variable(variable), res)
end
redef class AForExpr
redef fun stmt(v)
do
+ # Shortcut on explicit range
+ # Avoid the instantiation of the range and the iterator
+ var nexpr = self.n_expr
+ if self.variables.length == 1 and nexpr isa AOrangeExpr and not v.compiler.modelbuilder.toolcontext.opt_no_shortcut_range.value then
+ var from = v.expr(nexpr.n_expr, null)
+ var to = v.expr(nexpr.n_expr2, null)
+ var variable = v.variable(variables.first)
+
+ v.assign(variable, from)
+ v.add("for(;;) \{ /* shortcut range */")
+
+ var ok = v.send(v.get_property("<", variable.mtype), [variable, to])
+ assert ok != null
+ v.add("if(!{ok}) break;")
+
+ v.stmt(self.n_block)
+
+ v.add("CONTINUE_{v.escapemark_name(escapemark)}: (void)0;")
+ var succ = v.send(v.get_property("succ", variable.mtype), [variable])
+ assert succ != null
+ v.assign(variable, succ)
+ v.add("\}")
+ v.add("BREAK_{v.escapemark_name(escapemark)}: (void)0;")
+ return
+ end
+
var cl = v.expr(self.n_expr, null)
var it_meth = self.method_iterator
assert it_meth != null
redef fun expr(v)
do
var i = v.expr(self.n_expr, null)
- return v.type_test(i, self.cast_type.as(not null))
+ return v.type_test(i, self.cast_type.as(not null), "isa")
end
end
var i = v.expr(self.n_expr, null)
if v.compiler.modelbuilder.toolcontext.opt_no_check_assert.value then return i
- var cond = v.type_test(i, self.mtype.as(not null))
+ var cond = v.type_test(i, self.mtype.as(not null), "as")
v.add("if (!{cond}) \{")
v.add_abort("Cast failed")
v.add("\}")
for a in self.raw_arguments.as(not null) do
args.add(v.expr(a, null))
end
- var mproperty = self.mproperty.as(not null)
- return v.send(mproperty, args)
+ return v.compile_callsite(self.callsite.as(not null), args)
end
end
end
var value = v.expr(self.n_value, null)
- var mproperty = self.mproperty.as(not null)
- var left = v.send(mproperty, args)
+ var left = v.compile_callsite(self.callsite.as(not null), args)
assert left != null
- var res = v.send(reassign_property.mproperty, [left, value])
+ var res = v.compile_callsite(self.reassign_callsite.as(not null), [left, value])
assert res != null
args.add(res)
- v.send(self.write_mproperty.as(not null), args)
+ v.compile_callsite(self.write_callsite.as(not null), args)
end
end
redef class ANewExpr
redef fun expr(v)
do
- var mproperty = self.mproperty.as(not null)
var mtype = self.mtype.as(MClassType)
var recv
var ctype = mtype.ctype
for a in self.n_args.n_exprs do
args.add(v.expr(a, null))
end
- var res2 = v.send(mproperty, args)
+ var res2 = v.compile_callsite(self.callsite.as(not null), args)
if res2 != null then
#self.debug("got {res2} from {mproperty}. drop {recv}")
return res2
var value = v.expr(self.n_value, null)
var mproperty = self.mproperty.as(not null)
var attr = v.read_attribute(mproperty, recv)
- var res = v.send(reassign_property.mproperty, [attr, value])
+ var res = v.compile_callsite(self.reassign_callsite.as(not null), [attr, value])
assert res != null
v.write_attribute(mproperty, recv, res)
end
nitlanguage / nit.git / blobdiff