Signed-off-by: Alexis Laferrière <alexis.laf@xymus.net>
return self.call(propdef, t, args)
end
return self.call(propdef, t, args)
end
+ # Generate a monomorphic super send from the method `m`, the type `t` and the arguments `args`
+ fun monomorphic_super_send(m: MMethodDef, t: MType, args: Array[RuntimeVariable]): nullable RuntimeVariable
+ do
+ assert t isa MClassType
+ m = m.lookup_next_definition(self.compiler.mainmodule, t)
+ return self.call(m, t, args)
+ end
+
# Attributes handling
# Generate a polymorphic attribute is_set test
# Attributes handling
# Generate a polymorphic attribute is_set test
redef fun send(mmethod, arguments)
do
self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), arguments)
redef fun send(mmethod, arguments)
do
self.varargize(mmethod.intro, mmethod.intro.msignature.as(not null), arguments)
- return table_send(mmethod, arguments, mmethod.const_color)
- end
- private fun table_send(mmethod: MMethod, arguments: Array[RuntimeVariable], const_color: String): nullable RuntimeVariable
- do
if arguments.first.mcasttype.ctype != "val*" then
# In order to shortcut the primitive, we need to find the most specific method
# Howverr, because of performance (no flattening), we always work on the realmainmodule
if arguments.first.mcasttype.ctype != "val*" then
# In order to shortcut the primitive, we need to find the most specific method
# Howverr, because of performance (no flattening), we always work on the realmainmodule
+ return table_send(mmethod, arguments, mmethod.const_color)
+ end
+
+ private fun table_send(mmethod: MMethod, arguments: Array[RuntimeVariable], const_color: String): nullable RuntimeVariable
+ do
var res: nullable RuntimeVariable
var msignature = mmethod.intro.msignature.resolve_for(mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.mmodule, true)
var ret = msignature.return_mtype
var res: nullable RuntimeVariable
var msignature = mmethod.intro.msignature.resolve_for(mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.bound_mtype, mmethod.intro.mclassdef.mmodule, true)
var ret = msignature.return_mtype
redef fun supercall(m: MMethodDef, recvtype: MClassType, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
do
redef fun supercall(m: MMethodDef, recvtype: MClassType, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
do
+ if arguments.first.mcasttype.ctype != "val*" then
+ # In order to shortcut the primitive, we need to find the most specific method
+ # However, because of performance (no flattening), we always work on the realmainmodule
+ var main = self.compiler.mainmodule
+ self.compiler.mainmodule = self.compiler.realmainmodule
+ var res = self.monomorphic_super_send(m, recvtype, arguments)
+ self.compiler.mainmodule = main
+ return res
+ end
return table_send(m.mproperty, arguments, m.const_color)
end
return table_send(m.mproperty, arguments, m.const_color)
end
--- /dev/null
+redef class Object
+ fun foo do print "Object"
+end
+
+redef enum Int
+ redef fun to_s
+ do
+ var s = "Int"
+ return "{s} < {super}"
+ end
+ redef fun foo
+ do
+ print "Int"
+ super
+ end
+end
+
+# call local::to_s and then standard::to_s
+print 123.to_s
+
+# call Int::foo and then Object::foo
+123.foo