# It is quite efficient but the type set is global and pollutes each call site.
module rapid_type_analysis
-import model
-import modelbuilder
-import typing
-import auto_super_init
+import semantize
-import csv # for live_types_to_csv
-import ordered_tree # for live_methods_to_tree
+private import csv # for live_types_to_csv
+private import ordered_tree # for live_methods_to_tree
private import more_collections
redef class ModelBuilder
+ # Performs a rapid-type-analysis on the program associated with `mainmodule`.
fun do_rapid_type_analysis(mainmodule: MModule): RapidTypeAnalysis
do
var analysis = new RapidTypeAnalysis(self, mainmodule)
add_send(maintype, mainprop)
end
+ var finalizable_type = mainmodule.finalizable_type
+ if finalizable_type != null then
+ var finalize_meth = mainmodule.try_get_primitive_method("finalize", finalizable_type.mclass)
+ if finalize_meth != null then add_send(finalizable_type, finalize_meth)
+ end
+
# Force primitive types
force_alive("Bool")
force_alive("Int")
force_alive("Float")
force_alive("Char")
+ force_alive("Pointer")
while not todo.is_empty do
var mmethoddef = todo.shift
v.add_monomorphic_send(vararg, self.modelbuilder.force_get_primitive_method(node, "with_native", vararg.mclass, self.mainmodule))
end
+ # TODO? new_msignature
var sig = mmethoddef.msignature.as(not null)
var osig = mmeth.intro.msignature.as(not null)
for i in [0..sig.arity[ do
# It is an init for a class?
if mmeth.name == "init" then
var nclassdef = self.modelbuilder.mclassdef2nclassdef[mmethoddef.mclassdef]
- var super_inits = nclassdef.super_inits
- if super_inits != null then
- #assert args.length == 1
- for su in super_inits do
- v.add_monomorphic_send(v.receiver, su)
- end
- end
+ assert mmethoddef == nclassdef.mfree_init
+ if mmethoddef.mproperty.is_root_init and not mmethoddef.is_intro then
+ self.add_super_send(v.receiver, mmethoddef)
+ end
+ else if mmethoddef.constant_value != null then
+ # Make the return type live
+ v.add_type(mmethoddef.msignature.return_mtype.as(MClassType))
else
abort
end
v.add_callsite(auto_super_init)
end
end
+ if npropdef.auto_super_call then
+ self.add_super_send(v.receiver, mmethoddef)
+ end
end
if mmeth.is_new then
fun add_super_send(recv: MType, mpropdef: MMethodDef)
do
+ assert mpropdef.has_supercall
if live_super_sends.has(mpropdef) then return
#print "new super prop: {mpropdef}"
live_super_sends.add(mpropdef)
- for t in live_types do
- try_super_send(t, mpropdef)
+ for c in live_classes do
+ try_super_send(c.intro.bound_mtype, mpropdef)
end
end
end
fun add_cast_type(mtype: MType) do analysis.add_cast(mtype)
fun add_callsite(callsite: nullable CallSite) do if callsite != null then
+ for m in callsite.mpropdef.initializers do
+ if m isa MMethod then
+ analysis.add_send(callsite.recv, m)
+ end
+ end
analysis.add_send(callsite.recv, callsite.mproperty)
analysis.live_callsites.add(callsite)
end
abort
end
v.add_callsite(self.method_next)
+ var mf = self.method_finish
+ if mf != null then v.add_callsite(mf)
end
end