X-Git-Url: http://nitlanguage.org diff --git a/src/naive_interpreter.nit b/src/naive_interpreter.nit index 03973ef..4818e57 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 @@ -154,6 +165,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 @@ -266,11 +283,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 @@ -307,9 +341,11 @@ private class NaiveInterpreter 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") @@ -317,6 +353,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 @@ -357,16 +415,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 @@ -450,7 +499,7 @@ abstract 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 value if the instance is an integer. # else aborts @@ -548,10 +597,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 @@ -627,11 +677,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 @@ -770,8 +820,9 @@ 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) end @@ -1276,7 +1327,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 @@ -1542,6 +1593,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 @@ -1552,6 +1604,7 @@ 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) @@ -1565,6 +1618,7 @@ 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) @@ -1581,6 +1635,7 @@ 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))