model: try_get_primitive_method asks for a MClass (and not a MType)

Signed-off-by: Jean Privat <jean@pryen.org>

diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit
index c33cdc6..c2f4e1e 100644 (file)
--- a/src/abstract_compiler.nit
+++ b/src/abstract_compiler.nit
@@ -344,11 +344,11 @@ abstract class AbstractCompiler
                        var mainmodule = v.compiler.mainmodule
                        var glob_sys = v.init_instance(main_type)
                        v.add("glob_sys = {glob_sys};")
-                       var main_init = mainmodule.try_get_primitive_method("init", main_type)
+                       var main_init = mainmodule.try_get_primitive_method("init", main_type.mclass)
                        if main_init != null then
                                v.send(main_init, [glob_sys])
                        end
-                       var main_method = mainmodule.try_get_primitive_method("main", main_type)
+                       var main_method = mainmodule.try_get_primitive_method("main", main_type.mclass)
                        if main_method != null then
                                v.send(main_method, [glob_sys])
                        end
@@ -547,7 +547,8 @@ abstract class AbstractCompilerVisitor
        # Force to get the primitive property named `name' in the instance `recv' or abort
        fun get_property(name: String, recv: MType): MMethod
        do
-               return self.compiler.modelbuilder.force_get_primitive_method(self.current_node.as(not null), name, recv, self.compiler.mainmodule)
+               assert recv isa MClassType
+               return self.compiler.modelbuilder.force_get_primitive_method(self.current_node.as(not null), name, recv.mclass, self.compiler.mainmodule)
        end
 
        fun compile_callsite(callsite: CallSite, args: Array[RuntimeVariable]): nullable RuntimeVariable

diff --git a/src/model/model.nit b/src/model/model.nit
index 0888de1..ae55960 100644 (file)
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -227,19 +227,23 @@ redef class MModule
        end
 
        # Try to get the primitive method named `name' on the type `recv'
-       fun try_get_primitive_method(name: String, recv: MType): nullable MMethod
+       fun try_get_primitive_method(name: String, recv: MClass): nullable MMethod
        do
                var props = self.model.get_mproperties_by_name(name)
                if props == null then return null
                var res: nullable MMethod = null
                for mprop in props do
                        assert mprop isa MMethod
-                       if not recv.has_mproperty(self, mprop) then continue
-                       if res == null then
-                               res = mprop
-                       else
-                               print("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}")
-                               abort
+                       var intro = mprop.intro_mclassdef
+                       for mclassdef in recv.mclassdefs do
+                               if not self.in_importation.greaters.has(mclassdef.mmodule) then continue
+                               if not mclassdef.in_hierarchy.greaters.has(intro) then continue
+                               if res == null then
+                                       res = mprop
+                               else if res != mprop then
+                                       print("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}")
+                                       abort
+                               end
                        end
                end
                return res

diff --git a/src/modelbuilder.nit b/src/modelbuilder.nit
index af60c66..8186969 100644 (file)
--- a/src/modelbuilder.nit
+++ b/src/modelbuilder.nit
@@ -451,7 +451,7 @@ class ModelBuilder
        end
 
        # Force to get the primitive method named `name' on the type `recv' or do a fatal error on `n'
-       fun force_get_primitive_method(n: ANode, name: String, recv: MType, mmodule: MModule): MMethod
+       fun force_get_primitive_method(n: ANode, name: String, recv: MClass, mmodule: MModule): MMethod
        do
                var res = mmodule.try_get_primitive_method(name, recv)
                if res == null then

diff --git a/src/naive_interpreter.nit b/src/naive_interpreter.nit
index 9e29891..c17ec00 100644 (file)
--- a/src/naive_interpreter.nit
+++ b/src/naive_interpreter.nit
@@ -57,12 +57,12 @@ redef class ModelBuilder
                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
@@ -102,7 +102,8 @@ private class NaiveInterpreter
 
        fun force_get_primitive_method(name: String, recv: MType): MMethod
        do
-               return self.modelbuilder.force_get_primitive_method(self.frame.current_node, name, recv, self.mainmodule)
+               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?

diff --git a/src/rapid_type_analysis.nit b/src/rapid_type_analysis.nit
index c3fe70f..eb14c94 100644 (file)
--- a/src/rapid_type_analysis.nit
+++ b/src/rapid_type_analysis.nit
@@ -87,11 +87,11 @@ class RapidTypeAnalysis
                var maintype = mainmodule.sys_type
                if maintype == null then return # No entry point
                add_new(maintype, maintype)
-               var initprop = mainmodule.try_get_primitive_method("init", maintype)
+               var initprop = mainmodule.try_get_primitive_method("init", maintype.mclass)
                if initprop != null then
                        add_send(maintype, initprop)
                end
-               var mainprop = mainmodule.try_get_primitive_method("main", maintype)
+               var mainprop = mainmodule.try_get_primitive_method("main", maintype.mclass)
                if mainprop != null then
                        add_send(maintype, mainprop)
                end
@@ -112,8 +112,7 @@ class RapidTypeAnalysis
                                #elttype = elttype.anchor_to(self.mainmodule, v.receiver)
                                var vararg = self.mainmodule.get_primitive_class("Array").get_mtype([elttype])
                                v.add_type(vararg)
-                               vararg = v.cleanup_type(vararg).as(not null)
-                               v.add_monomorphic_send(vararg, self.modelbuilder.force_get_primitive_method(node, "with_native", vararg, self.mainmodule))
+                               v.add_monomorphic_send(vararg, self.modelbuilder.force_get_primitive_method(node, "with_native", vararg.mclass, self.mainmodule))
                                var native = self.mainmodule.get_primitive_class("NativeArray").get_mtype([elttype])
                                v.add_type(native)
                        end
@@ -371,7 +370,7 @@ class RapidTypeVisitor
        do
                var mtype = cleanup_type(recv)
                assert mtype != null
-               return self.analysis.modelbuilder.force_get_primitive_method(self.current_node.as(not null), name, mtype, self.analysis.mainmodule)
+               return self.analysis.modelbuilder.force_get_primitive_method(self.current_node.as(not null), name, mtype.mclass, self.analysis.mainmodule)
        end
 
        fun add_type(mtype: MClassType) do analysis.add_new(receiver, mtype)