X-Git-Url: http://nitlanguage.org diff --git a/src/naive_interpreter.nit b/src/naive_interpreter.nit index 5c3db18..c17ec00 100644 --- a/src/naive_interpreter.nit +++ b/src/naive_interpreter.nit @@ -21,6 +21,17 @@ import literal import typing import auto_super_init +redef class ToolContext + # --discover-call-trace + var opt_discover_call_trace: OptionBool = new OptionBool("Trace calls of the first invocation of a method", "--discover-call-trace") + + redef init + do + super + self.option_context.add_option(self.opt_discover_call_trace) + end +end + redef class ModelBuilder # Execute the program from the entry point (Sys::main) of the `mainmodule' # `arguments' are the command-line arguments in order @@ -34,23 +45,27 @@ redef class ModelBuilder self.toolcontext.info("*** START INTERPRETING ***", 1) var interpreter = new NaiveInterpreter(self, mainmodule, arguments) + init_naive_interpreter(interpreter, mainmodule) + + var time1 = get_time + self.toolcontext.info("*** END INTERPRETING: {time1-time0} ***", 2) + end + + private fun init_naive_interpreter(interpreter: NaiveInterpreter, mainmodule: MModule) do var sys_type = mainmodule.sys_type if sys_type == null then return # no class Sys - var mainobj = new Instance(sys_type) + var mainobj = new MutableInstance(sys_type) interpreter.mainobj = mainobj interpreter.init_instance(mainobj) - var initprop = mainmodule.try_get_primitive_method("init", sys_type) + var initprop = mainmodule.try_get_primitive_method("init", sys_type.mclass) if initprop != null then interpreter.send(initprop, [mainobj]) end interpreter.check_init_instance(mainobj) - var mainprop = mainmodule.try_get_primitive_method("main", sys_type) + var mainprop = mainmodule.try_get_primitive_method("main", sys_type.mclass) if mainprop != null then interpreter.send(mainprop, [mainobj]) end - - var time1 = get_time - self.toolcontext.info("*** END INTERPRETING: {time1-time0} ***", 2) end end @@ -76,7 +91,7 @@ private class NaiveInterpreter self.arguments = arguments self.true_instance = new PrimitiveInstance[Bool](mainmodule.bool_type, true) self.false_instance = new PrimitiveInstance[Bool](mainmodule.bool_type, false) - self.null_instance = new Instance(mainmodule.model.null_type) + self.null_instance = new MutableInstance(mainmodule.model.null_type) end # Subtype test in the context of the mainmodule @@ -85,6 +100,12 @@ private class NaiveInterpreter return sub.is_subtype(self.mainmodule, self.frame.arguments.first.mtype.as(MClassType), sup) end + fun force_get_primitive_method(name: String, recv: MType): MMethod + do + assert recv isa MClassType + return self.modelbuilder.force_get_primitive_method(self.frame.current_node, name, recv.mclass, self.mainmodule) + end + # Is a return executed? # Set this mark to skip the evaluation until the end of the specified method frame var returnmark: nullable Frame = null @@ -145,6 +166,12 @@ private class NaiveInterpreter if i == null and not self.is_escaping then n.debug("inconsitance: no value and not escaping.") end + var implicit_cast_to = n.implicit_cast_to + if implicit_cast_to != null then + var mtype = self.unanchor_type(implicit_cast_to) + if not self.is_subtype(i.mtype, mtype) then n.fatal(self, "Cast failed") + end + #n.debug("OUT Execute expr: value is {i}") #if not is_subtype(i.mtype, n.mtype.as(not null)) then n.debug("Expected {n.mtype.as(not null)} got {i}") frame.current_node = old @@ -212,9 +239,9 @@ private class NaiveInterpreter assert not elttype.need_anchor var nat = new PrimitiveInstance[Array[Instance]](self.mainmodule.get_primitive_class("NativeArray").get_mtype([elttype]), values) var mtype = self.mainmodule.get_primitive_class("Array").get_mtype([elttype]) - var res = new Instance(mtype) + var res = new MutableInstance(mtype) self.init_instance(res) - self.send(self.mainmodule.force_get_primitive_method("with_native", mtype), [res, nat, self.int_instance(values.length)]) + self.send(self.force_get_primitive_method("with_native", mtype), [res, nat, self.int_instance(values.length)]) self.check_init_instance(res) return res end @@ -257,11 +284,28 @@ private class NaiveInterpreter exit(1) end + # Debug on the current node + fun debug(message: String) + do + if frames.is_empty then + print message + else + self.frame.current_node.debug(message) + end + end + + # Store known method, used to trace methods as thez are reached + var discover_call_trace: Set[MMethodDef] = new HashSet[MMethodDef] + # Execute `mpropdef' for a `args' (where args[0] is the receiver). # Return a falue if `mpropdef' is a function, or null if it is a procedure. # The call is direct/static. There is no message-seding/late-bindng. fun call(mpropdef: MMethodDef, args: Array[Instance]): nullable Instance do + if self.modelbuilder.toolcontext.opt_discover_call_trace.value and not self.discover_call_trace.has(mpropdef) then + self.discover_call_trace.add mpropdef + self.debug("Discovered {mpropdef}") + end var vararg_rank = mpropdef.msignature.vararg_rank if vararg_rank >= 0 then assert args.length >= mpropdef.msignature.arity + 1 # because of self @@ -287,15 +331,22 @@ private class NaiveInterpreter args.add(rawargs[i+1]) end end - #assert args.length == mpropdef.msignature.arity + 1 # because of self + if args.length < mpropdef.msignature.arity + 1 or args.length > mpropdef.msignature.arity + 1 + mpropdef.msignature.mclosures.length then + fatal("NOT YET IMPLEMENTED: Invalid arity for {mpropdef}. {args.length} arguments given.") + end + if args.length < mpropdef.msignature.arity + 1 + mpropdef.msignature.mclosures.length then + fatal("NOT YET IMPLEMENTED: default closures") + end # Look for the AST node that implements the property var mproperty = mpropdef.mproperty if self.modelbuilder.mpropdef2npropdef.has_key(mpropdef) then var npropdef = self.modelbuilder.mpropdef2npropdef[mpropdef] + self.parameter_check(npropdef, mpropdef, args) return npropdef.call(self, mpropdef, args) else if mproperty.name == "init" then var nclassdef = self.modelbuilder.mclassdef2nclassdef[mpropdef.mclassdef] + self.parameter_check(nclassdef, mpropdef, args) return nclassdef.call(self, mpropdef, args) else fatal("Fatal Error: method {mpropdef} not found in the AST") @@ -303,6 +354,28 @@ private class NaiveInterpreter end end + # Generate type checks in the C code to check covariant parameters + fun parameter_check(node: ANode, mpropdef: MMethodDef, args: Array[Instance]) + do + var msignature = mpropdef.msignature + for i in [0..msignature.arity[ do + # skip test for vararg since the array is instantiated with the correct polymorphic type + if msignature.vararg_rank == i then continue + + # skip if the cast is not required + var origmtype = mpropdef.mproperty.intro.msignature.mparameters[i].mtype + if not origmtype.need_anchor then continue + + # get the parameter type + var mtype = msignature.mparameters[i].mtype + var anchor = args.first.mtype.as(MClassType) + mtype = mtype.anchor_to(self.mainmodule, anchor) + if not args[i+1].mtype.is_subtype(self.mainmodule, anchor, mtype) then + node.fatal(self, "Cast failed") + end + end + end + fun call_closure(closure: ClosureInstance, args: Array[Instance]): nullable Instance do var nclosuredef = closure.nclosuredef @@ -343,16 +416,7 @@ private class NaiveInterpreter fatal("Reciever is null") abort end - var propdefs = mproperty.lookup_definitions(self.mainmodule, mtype) - if propdefs.length > 1 then - fatal("NOT YET IMPLEMETED ERROR: Property conflict: {propdefs.join(", ")}") - abort - end - assert propdefs.length == 1 else - fatal("Fatal Error: No property '{mproperty}' for '{recv}'") - abort - end - var propdef = propdefs.first + var propdef = mproperty.lookup_first_definition(self.mainmodule, mtype) return self.call(propdef, args) end @@ -360,6 +424,7 @@ private class NaiveInterpreter # If the attribute in not yet initialized, then aborts with an error message. fun read_attribute(mproperty: MAttribute, recv: Instance): Instance do + assert recv isa MutableInstance if not recv.attributes.has_key(mproperty) then fatal("Uninitialized attribute {mproperty.name}") abort @@ -367,34 +432,48 @@ private class NaiveInterpreter return recv.attributes[mproperty] end - # Fill the initial values of the newly created instance `recv'. - # `recv.mtype' is used to know what must be filled. - fun init_instance(recv: Instance) + # Collect attributes of a type in the order of their init + fun collect_attr_propdef(mtype: MType): Array[AAttrPropdef] do - for cd in recv.mtype.collect_mclassdefs(self.mainmodule) - do + var cache = self.collect_attr_propdef_cache + if cache.has_key(mtype) then return cache[mtype] + + var res = new Array[AAttrPropdef] + var cds = mtype.collect_mclassdefs(self.mainmodule).to_a + self.mainmodule.linearize_mclassdefs(cds) + for cd in cds do var n = self.modelbuilder.mclassdef2nclassdef[cd] for npropdef in n.n_propdefs do if npropdef isa AAttrPropdef then - npropdef.init_expr(self, recv) + res.add(npropdef) end end end + + cache[mtype] = res + return res + end + + var collect_attr_propdef_cache = new HashMap[MType, Array[AAttrPropdef]] + + # Fill the initial values of the newly created instance `recv'. + # `recv.mtype' is used to know what must be filled. + fun init_instance(recv: Instance) + do + for npropdef in collect_attr_propdef(recv.mtype) do + npropdef.init_expr(self, recv) + end end # Check that non nullable attributes of `recv' are correctly initialized. # This function is used as the last instruction of a new - # FIXME: this will work better once there is nullable types fun check_init_instance(recv: Instance) do - for cd in recv.mtype.collect_mclassdefs(self.mainmodule) - do - var n = self.modelbuilder.mclassdef2nclassdef[cd] - for npropdef in n.n_propdefs do - if npropdef isa AAttrPropdef and npropdef.n_expr == null then - # Force read to check the initialization - self.read_attribute(npropdef.mpropdef.mproperty, recv) - end + if not recv isa MutableInstance then return + for npropdef in collect_attr_propdef(recv.mtype) do + if npropdef.n_expr == null then + # Force read to check the initialization + self.read_attribute(npropdef.mpropdef.mproperty, recv) end end end @@ -407,14 +486,11 @@ private class NaiveInterpreter end # An instance represents a value of the executed program. -class Instance +abstract class Instance # The dynamic type of the instance # ASSERT: not self.mtype.is_anchored var mtype: MType - # The values of the attributes - var attributes: Map[MAttribute, Instance] = new HashMap[MAttribute, Instance] - # return true if the instance is the true value. # return false if the instance is the true value. # else aborts @@ -424,17 +500,29 @@ class Instance fun eq_is(o: Instance): Bool do return self is o # Human readable object identity "Type#number" - redef fun to_s do return "{mtype}#{object_id}" + redef fun to_s do return "{mtype}" - # Return the integer valur is the instance is an integer. + # Return the integer value if the instance is an integer. # else aborts fun to_i: Int do abort + # Return the integer value if the instance is a float. + # else aborts + fun to_f: Float do abort + # The real value encapsulated if the instance is primitive. # Else aborts. fun val: Object do abort end +# A instance with attribute (standards objects) +class MutableInstance + super Instance + + # The values of the attributes + var attributes: Map[MAttribute, Instance] = new HashMap[MAttribute, Instance] +end + # Special instance to handle primitives values (int, bool, etc.) # The trick it just to encapsulate the <> value class PrimitiveInstance[E: Object] @@ -471,6 +559,8 @@ class PrimitiveInstance[E: Object] redef fun to_s do return "{mtype}#{val.object_id}({val})" redef fun to_i do return val.as(Int) + + redef fun to_f do return val.as(Float) end private class ClosureInstance @@ -508,10 +598,11 @@ redef class ANode private fun fatal(v: NaiveInterpreter, message: String) do if v.modelbuilder.toolcontext.opt_no_color.value == true then - print("Runtime error: {message} ({location.file.filename}:{location.line_start})") + stderr.write("Runtime error: {message} ({location.file.filename}:{location.line_start})\n") else - print("{location}: Runtime error: {message}\n{location.colored_line("0;31")}") - print(v.stack_trace) + stderr.write("{location}: Runtime error: {message}\n{location.colored_line("0;31")}\n") + stderr.write(v.stack_trace) + stderr.write("\n") end exit(1) end @@ -587,11 +678,11 @@ redef class AInternMethPropdef end else if pname == "output_class_name" then var recv = args.first - print recv.mtype.as(MClassType).mclass + print recv.mtype return null else if pname == "native_class_name" then var recv = args.first - var txt = recv.mtype.as(MClassType).mclass.to_s + var txt = recv.mtype.to_s return v.native_string_instance(txt) else if pname == "==" then # == is correclt redefined for instances @@ -661,16 +752,27 @@ redef class AInternMethPropdef return v.int_instance(recv <=> args[1].val.as(Char)) end else if cname == "Float" then - if pname == "+" then - return v.float_instance(args[0].val.as(Float) + args[1].val.as(Float)) + var recv = args[0].to_f + if pname == "unary -" then + return v.float_instance(-recv) + else if pname == "+" then + return v.float_instance(recv + args[1].to_f) else if pname == "-" then - return v.float_instance(args[0].val.as(Float) - args[1].val.as(Float)) + return v.float_instance(recv - args[1].to_f) else if pname == "*" then - return v.float_instance(args[0].val.as(Float) * args[1].val.as(Float)) + return v.float_instance(recv * args[1].to_f) else if pname == "/" then - return v.float_instance(args[0].val.as(Float) / args[1].val.as(Float)) + return v.float_instance(recv / args[1].to_f) + else if pname == "<" then + return v.bool_instance(recv < args[1].to_f) + else if pname == ">" then + return v.bool_instance(recv > args[1].to_f) + else if pname == "<=" then + return v.bool_instance(recv <= args[1].to_f) + else if pname == ">=" then + return v.bool_instance(recv >= args[1].to_f) else if pname == "to_i" then - return v.int_instance(args[0].val.as(Float).to_i) + return v.int_instance(recv.to_i) end else if cname == "NativeString" then var recvval = args.first.val.as(Buffer) @@ -728,10 +830,16 @@ redef class AInternMethPropdef end else if pname == "calloc_array" then var recvtype = args.first.mtype.as(MClassType) - var mtype: MType = recvtype.supertype_to(v.mainmodule, recvtype, v.mainmodule.get_primitive_class("ArrayCapable")) - mtype = mtype.as(MGenericType).arguments.first + var mtype: MType + mtype = recvtype.supertype_to(v.mainmodule, recvtype, v.mainmodule.get_primitive_class("ArrayCapable")) + mtype = mtype.arguments.first var val = new Array[Instance].filled_with(v.null_instance, args[1].to_i) return new PrimitiveInstance[Array[Instance]](v.mainmodule.get_primitive_class("NativeArray").get_mtype([mtype]), val) + else if pname == "native_argc" then + return v.int_instance(v.arguments.length) + else if pname == "native_argv" then + var txt = v.arguments[args[1].to_i] + return v.native_string_instance(txt) end fatal(v, "NOT YET IMPLEMENTED intern {mpropdef}") abort @@ -808,6 +916,36 @@ redef class AExternMethPropdef else if pname == "system" then var res = sys.system(recvval.to_s) return v.int_instance(res) + else if pname == "atof" then + return v.float_instance(recvval.to_f) + end + else if cname == "Int" then + if pname == "rand" then + return v.int_instance(args[0].to_i.rand) + end + else if cname == "Float" then + if pname == "cos" then + return v.float_instance(args[0].to_f.cos) + else if pname == "sin" then + return v.float_instance(args[0].to_f.sin) + else if pname == "tan" then + return v.float_instance(args[0].to_f.tan) + else if pname == "acos" then + return v.float_instance(args[0].to_f.acos) + else if pname == "asin" then + return v.float_instance(args[0].to_f.asin) + else if pname == "atan" then + return v.float_instance(args[0].to_f.atan) + else if pname == "sqrt" then + return v.float_instance(args[0].to_f.sqrt) + else if pname == "exp" then + return v.float_instance(args[0].to_f.exp) + else if pname == "log" then + return v.float_instance(args[0].to_f.log) + else if pname == "pow" then + return v.float_instance(args[0].to_f.pow(args[1].to_f)) + else if pname == "rand" then + return v.float_instance(args[0].to_f.rand) end else if pname == "native_argc" then return v.int_instance(v.arguments.length) @@ -816,6 +954,13 @@ redef class AExternMethPropdef return v.native_string_instance(txt) else if pname == "get_time" then return v.int_instance(get_time) + else if pname == "srand_from" then + srand_from(args[1].to_i) + return null + else if pname == "atan2" then + return v.float_instance(atan2(args[1].to_f, args[2].to_f)) + else if pname == "pi" then + return v.float_instance(pi) else if pname == "lexer_goto" then return v.int_instance(lexer_goto(args[1].to_i, args[2].to_i)) else if pname == "lexer_accept" then @@ -833,12 +978,14 @@ end redef class AAttrPropdef redef fun call(v, mpropdef, args) do + var recv = args.first + assert recv isa MutableInstance var attr = self.mpropdef.mproperty if args.length == 1 then - return v.read_attribute(attr, args.first) + return v.read_attribute(attr, recv) else assert args.length == 2 - args.first.attributes[attr] = args[1] + recv.attributes[attr] = args[1] return null end end @@ -846,6 +993,7 @@ redef class AAttrPropdef # Evaluate and set the default value of the attribute in `recv' private fun init_expr(v: NaiveInterpreter, recv: Instance) do + assert recv isa MutableInstance var nexpr = self.n_expr if nexpr != null then var f = new Frame(self, self.mpropdef.as(not null), [recv]) @@ -858,14 +1006,21 @@ redef class AAttrPropdef return end var mtype = self.mpropdef.static_mtype.as(not null) - # TODO The needinit info is statically computed, move it to modelbuilder or whatever - mtype = mtype.resolve_for(self.mpropdef.mclassdef.bound_mtype, self.mpropdef.mclassdef.bound_mtype, self.mpropdef.mclassdef.mmodule, true) + mtype = mtype.anchor_to(v.mainmodule, recv.mtype.as(MClassType)) if mtype isa MNullableType then recv.attributes[self.mpropdef.mproperty] = v.null_instance end end end +redef class ADeferredMethPropdef + redef fun call(v, mpropdef, args) + do + fatal(v, "Deferred method called") + abort + end +end + redef class AClassdef # Execute an implicit `mpropdef' associated with the current node. private fun call(v: NaiveInterpreter, mpropdef: MMethodDef, args: Array[Instance]): nullable Instance @@ -879,6 +1034,7 @@ redef class AClassdef return null end var recv = args.first + assert recv isa MutableInstance var i = 1 # Collect undefined attributes for npropdef in self.n_propdefs do @@ -1083,19 +1239,19 @@ redef class AForExpr var col = v.expr(self.n_expr) if col == null then return #self.debug("col {col}") - var iter = v.send(v.mainmodule.force_get_primitive_method("iterator", col.mtype), [col]).as(not null) + var iter = v.send(v.force_get_primitive_method("iterator", col.mtype), [col]).as(not null) #self.debug("iter {iter}") loop - var isok = v.send(v.mainmodule.force_get_primitive_method("is_ok", iter.mtype), [iter]).as(not null) + var isok = v.send(v.force_get_primitive_method("is_ok", iter.mtype), [iter]).as(not null) if not isok.is_true then return if self.variables.length == 1 then - var item = v.send(v.mainmodule.force_get_primitive_method("item", iter.mtype), [iter]).as(not null) + var item = v.send(v.force_get_primitive_method("item", iter.mtype), [iter]).as(not null) #self.debug("item {item}") v.frame.map[self.variables.first] = item else if self.variables.length == 2 then - var key = v.send(v.mainmodule.force_get_primitive_method("key", iter.mtype), [iter]).as(not null) + var key = v.send(v.force_get_primitive_method("key", iter.mtype), [iter]).as(not null) v.frame.map[self.variables[0]] = key - var item = v.send(v.mainmodule.force_get_primitive_method("item", iter.mtype), [iter]).as(not null) + var item = v.send(v.force_get_primitive_method("item", iter.mtype), [iter]).as(not null) v.frame.map[self.variables[1]] = item else abort @@ -1104,7 +1260,7 @@ redef class AForExpr if v.is_break(self.escapemark) then return v.is_continue(self.escapemark) # Clear the break if v.is_escaping then return - v.send(v.mainmodule.force_get_primitive_method("next", iter.mtype), [iter]) + v.send(v.force_get_primitive_method("next", iter.mtype), [iter]) end end end @@ -1208,7 +1364,7 @@ redef class AArrayExpr if i == null then return null val.add(i) end - var mtype = v.unanchor_type(self.mtype.as(not null)).as(MGenericType) + var mtype = v.unanchor_type(self.mtype.as(not null)).as(MClassType) var elttype = mtype.arguments.first return v.array_instance(val, elttype) end @@ -1219,9 +1375,9 @@ redef class AStringFormExpr do var txt = self.value.as(not null) var nat = v.native_string_instance(txt) - var res = new Instance(v.mainmodule.get_primitive_class("String").mclass_type) + var res = new MutableInstance(v.mainmodule.get_primitive_class("String").mclass_type) v.init_instance(res) - v.send(v.mainmodule.force_get_primitive_method("from_cstring", res.mtype), [res, nat]) + v.send(v.force_get_primitive_method("from_cstring", res.mtype), [res, nat]) v.check_init_instance(res) return res end @@ -1237,7 +1393,7 @@ redef class ASuperstringExpr array.add(i) end var i = v.array_instance(array, v.mainmodule.get_primitive_class("Object").mclass_type) - var res = v.send(v.mainmodule.force_get_primitive_method("to_s", i.mtype), [i]) + var res = v.send(v.force_get_primitive_method("to_s", i.mtype), [i]) assert res != null return res end @@ -1251,9 +1407,9 @@ redef class ACrangeExpr var e2 = v.expr(self.n_expr2) if e2 == null then return null var mtype = v.unanchor_type(self.mtype.as(not null)) - var res = new Instance(mtype) + var res = new MutableInstance(mtype) v.init_instance(res) - v.send(v.mainmodule.force_get_primitive_method("init", mtype), [res, e1, e2]) + v.send(v.force_get_primitive_method("init", mtype), [res, e1, e2]) v.check_init_instance(res) return res end @@ -1267,9 +1423,9 @@ redef class AOrangeExpr var e2 = v.expr(self.n_expr2) if e2 == null then return null var mtype = v.unanchor_type(self.mtype.as(not null)) - var res = new Instance(mtype) + var res = new MutableInstance(mtype) v.init_instance(res) - v.send(v.mainmodule.force_get_primitive_method("without_last", mtype), [res, e1, e2]) + v.send(v.force_get_primitive_method("without_last", mtype), [res, e1, e2]) v.check_init_instance(res) return res end @@ -1360,7 +1516,7 @@ redef class ASendExpr var recv = v.expr(self.n_expr) if recv == null then return null var args = [recv] - for a in compute_raw_arguments do + for a in self.raw_arguments.as(not null) do var i = v.expr(a) if i == null then return null args.add(i) @@ -1387,7 +1543,7 @@ redef class ASendReassignFormExpr var recv = v.expr(self.n_expr) if recv == null then return var args = [recv] - for a in compute_raw_arguments do + for a in self.raw_arguments.as(not null) do var i = v.expr(a) if i == null then return args.add(i) @@ -1434,12 +1590,7 @@ redef class ASuperExpr # stantard call-next-method var mpropdef = v.frame.mpropdef - # FIXME: we do not want an ugly static call! - var mpropdefs = mpropdef.mproperty.lookup_super_definitions(mpropdef.mclassdef.mmodule, mpropdef.mclassdef.bound_mtype) - if mpropdefs.length != 1 then - debug("Warning: NOT YET IMPLEMENTED: multiple MPRODFEFS for super {mpropdef} for {recv}: {mpropdefs.join(", ")}") - end - mpropdef = mpropdefs.first + mpropdef = mpropdef.lookup_next_definition(v.mainmodule, recv.mtype) assert mpropdef isa MMethodDef var res = v.call(mpropdef, args) return res @@ -1450,7 +1601,7 @@ redef class ANewExpr redef fun expr(v) do var mtype = v.unanchor_type(self.mtype.as(not null)) - var recv = new Instance(mtype) + var recv: Instance = new MutableInstance(mtype) v.init_instance(recv) var args = [recv] for a in self.n_args.n_exprs do @@ -1474,6 +1625,7 @@ redef class AAttrExpr do var recv = v.expr(self.n_expr) if recv == null then return null + if recv.mtype isa MNullType then fatal(v, "Reciever is null") var mproperty = self.mproperty.as(not null) return v.read_attribute(mproperty, recv) end @@ -1484,9 +1636,11 @@ redef class AAttrAssignExpr do var recv = v.expr(self.n_expr) if recv == null then return + if recv.mtype isa MNullType then fatal(v, "Reciever is null") var i = v.expr(self.n_value) if i == null then return var mproperty = self.mproperty.as(not null) + assert recv isa MutableInstance recv.attributes[mproperty] = i end end @@ -1496,12 +1650,14 @@ redef class AAttrReassignExpr do var recv = v.expr(self.n_expr) if recv == null then return + if recv.mtype isa MNullType then fatal(v, "Reciever is null") var value = v.expr(self.n_value) if value == null then return var mproperty = self.mproperty.as(not null) var attr = v.read_attribute(mproperty, recv) var res = v.send(reassign_property.mproperty, [attr, value]) assert res != null + assert recv isa MutableInstance recv.attributes[mproperty] = res end end @@ -1511,7 +1667,9 @@ redef class AIssetAttrExpr do var recv = v.expr(self.n_expr) if recv == null then return null + if recv.mtype isa MNullType then fatal(v, "Reciever is null") var mproperty = self.mproperty.as(not null) + assert recv isa MutableInstance return v.bool_instance(recv.attributes.has_key(mproperty)) end end