1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Copyright 2012 Jean Privat <jean@pryen.org>
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
18 # Rapid type analysis on the AST with heterogenous generics and customization
20 # Rapid type analysis is an analyse that aproximates the set of live classes
21 # and the set of live methods starting from the entry point of the program.
22 # These two sets are interdependant and computed together.
23 # It is quite efficient but the type set is global and pollutes each call site.
25 # Heterogenous generics means that each intancied generic class is associated
26 # to a distinct rapid type.
27 # Heterogenous generics has the advantage to resolve the formal generic
28 # parameters types but increase the number of types.
29 # More important, heterogenous generics cannot deal with infinite number of rapid
30 # types since the analyse tries to list them all (so some programs will be badly refused)
32 # Customization means that each method definition is analyzed one per rapid
34 # Customization have the following advantages:
35 # * `self' is monomorphic
36 # * virtual types are all resolved
37 # * live attributes can be determined on each class
38 # But has the disadvantage to explode the number of rapid method: each method
39 # definition for each rapid type that need it
40 module rapid_type_analysis
45 import auto_super_init
47 redef class ModelBuilder
48 fun do_rapid_type_analysis
(mainmodule
: MModule): RapidTypeAnalysis
51 self.toolcontext
.info
("*** RAPID TYPE ANALYSIS ***", 1)
53 var model
= self.model
54 var analysis
= new RapidTypeAnalysis(self, mainmodule
)
55 var nmodule
= self.nmodules
.first
56 var maintype
= mainmodule
.sys_type
57 if maintype
== null then return analysis
# No entry point
58 analysis
.add_type
(maintype
)
59 var initprop
= mainmodule
.try_get_primitive_method
("init", maintype
)
60 if initprop
!= null then
61 analysis
.add_monomorphic_send
(maintype
, initprop
)
63 var mainprop
= mainmodule
.try_get_primitive_method
("main", maintype
)
64 if mainprop
!= null then
65 analysis
.add_monomorphic_send
(maintype
, mainprop
)
70 self.toolcontext
.info
("*** END RAPID TYPE ANALYSIS: {time1-time0} ***", 2)
76 # RapidTypeAnalysis looks for alive rapid types in application.
77 # The entry point of the analysis is the mainmodule of the application.
78 class RapidTypeAnalysis
79 # The modelbuilder used to get the AST.
80 var modelbuilder
: ModelBuilder
82 # The main module of the analysis.
83 # Used to perform types operations.
84 var mainmodule
: MModule
86 # The pool to live types.
87 # During the analysis, new types are added and combined with
88 # live_send_sites to determine new customized_methoddefs to visit
89 var live_types
: HashSet[MClassType] = new HashSet[MClassType]
91 # The pool of types used to perform type checks (isa and as).
92 var live_cast_types
: HashSet[MClassType] = new HashSet[MClassType]
94 # Live method definitions.
95 # These method definitions are:
96 # * visited trough a add_send on an already known live_type
97 # * visited trough a add_type for an already known live_send_sites
98 # * visided by a add_monomorphic_send or a add_static_call
99 var live_methoddefs
: HashSet[MMethodDef] = new HashSet[MMethodDef]
101 # The pool of live customized method definitions
102 var live_customized_methoddefs
: HashSet[CustomizedMethodDef] = new HashSet[CustomizedMethodDef]
104 # The pool of live RTA send site
105 # During the analysis, new live_send_sites are added and combined with
106 # live_types to determine new live_customized_methoddefs to visit
107 var live_send_sites
: HashSet[RTASendSite] = new HashSet[RTASendSite]
109 # The customized method definitions that remain to visit
110 private var todo
: List[CustomizedMethodDef] = new List[CustomizedMethodDef]
112 # Adapt and remove nullable
113 # return null if we got the null type
114 fun cleanup_type
(mtype
: MType, recvtype
: MClassType): nullable MClassType
116 mtype
= mtype
.anchor_to
(self.mainmodule
, recvtype
)
117 if mtype
isa MNullType then return null
118 if mtype
isa MNullableType then mtype
= mtype
.mtype
119 assert mtype
isa MClassType
120 assert not mtype
.need_anchor
124 # Add a live type to the pool
126 # If the types is already live, then do nothing.
128 # REQUIRE: not mtype.need_anchor
129 fun add_type
(mtype
: MClassType)
131 if self.live_types
.has
(mtype
) then return
133 assert not mtype
.need_anchor
134 self.live_types
.add
(mtype
)
135 self.check_depth
(mtype
)
137 # Collect default attributes
138 for cd
in mtype
.collect_mclassdefs
(self.mainmodule
)
140 var nclassdef
= self.modelbuilder
.mclassdef2nclassdef
[cd
]
141 for npropdef
in nclassdef
.n_propdefs
do
142 if not npropdef
isa AAttrPropdef then continue
143 var nexpr
= npropdef
.n_expr
144 if nexpr
== null then continue
145 var v
= new RapidTypeVisitor(self, nclassdef
, npropdef
.mpropdef
.as(not null), mtype
)
150 for rss
in self.live_send_sites
do
151 if not mtype
.is_subtype
(self.mainmodule
, null, rss
.receiver
) then continue
152 if mtype
.has_mproperty
(self.mainmodule
, rss
.mmethod
) then
153 self.add_monomorphic_send
(mtype
, rss
.mmethod
)
158 # Add a send site to the pool
160 # If the send site is already live, then do nothing.
161 fun add_send
(mtype
: MClassType, mmethod
: MMethod)
163 var rss
= new RTASendSite(mmethod
, mtype
)
164 if self.live_send_sites
.has
(rss
) then return
166 self.live_send_sites
.add
(rss
)
168 for mtype2
in self.live_types
do
169 if not mtype2
.is_subtype
(self.mainmodule
, null, mtype
) then continue
170 if mtype2
.has_mproperty
(self.mainmodule
, mmethod
) then
171 self.add_monomorphic_send
(mtype2
, mmethod
)
176 # Add a monomoprhic send.
177 # The send site is not added to the pool.
178 # The method just determine the associated method definition then
179 # performs a static_call
180 fun add_monomorphic_send
(mtype
: MClassType, mmethod
: MMethod)
182 assert self.live_types
.has
(mtype
)
183 if not mtype
.has_mproperty
(self.mainmodule
, mmethod
) then return
184 var def
= mmethod
.lookup_first_definition
(self.mainmodule
, mtype
)
185 self.add_static_call
(mtype
, def
)
188 # Add a customized_methoddefs to the pool
189 # Is the customized_methoddefs is already live, then do nothing
190 fun add_static_call
(mtype
: MClassType, mmethoddef
: MMethodDef)
192 assert self.live_types
.has
(mtype
)
193 var rm
= new CustomizedMethodDef(mmethoddef
, mtype
)
194 if self.live_customized_methoddefs
.has
(rm
) then return
195 self.live_customized_methoddefs
.add
(rm
)
197 self.live_methoddefs
.add
(mmethoddef
)
200 # Add mtype to the cast pool.
201 fun add_cast_type
(mtype
: MClassType)
203 if self.live_cast_types
.has
(mtype
) then return
205 assert not mtype
.need_anchor
206 self.live_cast_types
.add
(mtype
)
207 self.check_depth
(mtype
)
210 fun check_depth
(mtype
: MClassType)
214 self.modelbuilder
.toolcontext
.fatal_error
(null, "Fatal error: limitation in the rapidtype analysis engine: a type depth of {d} is too important, the problematic type is {mtype}.")
218 # Run the analysis until all visitable method definitions are visited.
222 var classes
= self.modelbuilder
.model
.get_mclasses_by_name
("Bool")
223 if classes
!= null then for c
in classes
do self.add_type
(c
.mclass_type
)
225 while not todo
.is_empty
do
228 var vararg_rank
= mr
.mmethoddef
.msignature
.vararg_rank
229 if vararg_rank
> -1 then
230 var node
= self.modelbuilder
.mpropdef2npropdef
[mr
.mmethoddef
]
231 var elttype
= mr
.mmethoddef
.msignature
.mparameters
[vararg_rank
].mtype
232 elttype
= elttype
.anchor_to
(self.mainmodule
, mr
.receiver
)
233 var vararg
= self.mainmodule
.get_primitive_class
("Array").get_mtype
([elttype
])
234 self.add_type
(vararg
)
235 self.add_monomorphic_send
(vararg
, self.modelbuilder
.force_get_primitive_method
(node
, "with_native", vararg
, self.mainmodule
))
236 var native
= self.mainmodule
.get_primitive_class
("NativeArray").get_mtype
([elttype
])
237 self.add_type
(native
)
240 for i
in [0..mr
.mmethoddef
.msignature
.arity
[ do
241 var origtype
= mr
.mmethoddef
.mproperty
.intro
.msignature
.mparameters
[i
].mtype
242 if not origtype
.need_anchor
then continue # skip non covariant stuff
243 var paramtype
= mr
.mmethoddef
.msignature
.mparameters
[i
].mtype
244 paramtype
= self.cleanup_type
(paramtype
, mr
.receiver
).as(not null)
245 self.add_cast_type
(paramtype
)
248 if not self.modelbuilder
.mpropdef2npropdef
.has_key
(mr
.mmethoddef
) then
249 # It is an init for a class?
250 if mr
.mmethoddef
.mproperty
.name
== "init" then
251 var nclassdef
= self.modelbuilder
.mclassdef2nclassdef
[mr
.mmethoddef
.mclassdef
]
252 var super_inits
= nclassdef
.super_inits
253 if super_inits
!= null then
254 #assert args.length == 1
255 for su
in super_inits
do
256 self.add_monomorphic_send
(mr
.receiver
, su
)
265 var npropdef
= self.modelbuilder
.mpropdef2npropdef
[mr
.mmethoddef
]
266 if npropdef
isa AConcreteMethPropdef then
267 #npropdef.debug("Visit {mr.mmethoddef} for {mr.receiver}")
268 var nclassdef
= npropdef
.parent
.as(AClassdef)
269 var mmethoddef
= npropdef
.mpropdef
.as(not null)
270 var auto_super_inits
= npropdef
.auto_super_inits
271 if auto_super_inits
!= null then
272 for auto_super_init
in auto_super_inits
do
273 self.add_monomorphic_send
(mr
.receiver
, auto_super_init
)
276 var v
= new RapidTypeVisitor(self, nclassdef
, mmethoddef
, mr
.receiver
)
277 v
.enter_visit
(npropdef
.n_block
)
278 else if npropdef
isa ADeferredMethPropdef then
279 # nothing to do (maybe add a waring?)
280 else if npropdef
isa AAttrPropdef then
282 else if npropdef
isa AInternMethPropdef or npropdef
isa AExternMethPropdef then
283 # UGLY: We force the "instantation" of the concrete return type if any
284 var ret
= mr
.mmethoddef
.msignature
.return_mtype
285 if ret
!= null and ret
isa MClassType and ret
.mclass
.kind
!= abstract_kind
and ret
.mclass
.kind
!= interface_kind
then
286 ret
= ret
.anchor_to
(self.mainmodule
, mr
.receiver
)
289 else if npropdef
isa AExternInitPropdef then
290 self.add_type
(mr
.receiver
)
292 npropdef
.debug
("Not yet implemented")
299 # A method definitions customized to a specific receiver
300 class CustomizedMethodDef
301 var mmethoddef
: MMethodDef
302 var receiver
: MClassType
306 return "{self.mmethoddef}({receiver})"
311 return o
isa CustomizedMethodDef and o
.mmethoddef
== self.mmethoddef
and o
.receiver
== self.receiver
316 return self.mmethoddef
.hash
+ self.receiver
.hash
320 # A method invokation site bounded by a specific receiver
323 var receiver
: MClassType
327 return o
isa RTASendSite and o
.mmethod
== self.mmethod
and o
.receiver
== self.receiver
332 return self.mmethod
.hash
+ self.receiver
.hash
336 private class RapidTypeVisitor
339 var analysis
: RapidTypeAnalysis
341 var nclassdef
: AClassdef
343 var mpropdef
: MPropDef
345 var receiver
: MClassType
347 init(analysis
: RapidTypeAnalysis, nclassdef
: AClassdef, mpropdef
: MPropDef, receiver
: MClassType)
349 self.analysis
= analysis
350 self.nclassdef
= nclassdef
351 self.mpropdef
= mpropdef
352 self.receiver
= receiver
355 # Adapt and remove nullable
356 # return null if we got the null type
357 fun cleanup_type
(mtype
: MType): nullable MClassType
359 mtype
= mtype
.anchor_to
(self.analysis
.mainmodule
, self.receiver
)
360 if mtype
isa MNullType then return null
361 if mtype
isa MNullableType then mtype
= mtype
.mtype
362 assert mtype
isa MClassType
363 assert not mtype
.need_anchor
367 fun add_type
(mtype
: MType)
369 var rapidtype
= cleanup_type
(mtype
)
370 if rapidtype
== null then return # we do not care about null
372 self.analysis
.add_type
(rapidtype
)
373 #self.current_node.debug("add_type {rapidtype}")
376 fun add_send
(mtype
: MType, mproperty
: MMethod)
378 var rapidtype
= cleanup_type
(mtype
)
379 if rapidtype
== null then return # we do not care about null
381 analysis
.add_send
(rapidtype
, mproperty
)
382 #self.current_node.debug("add_send {mproperty}")
385 fun add_monomorphic_send
(mtype
: MType, mproperty
: MMethod)
387 var rapidtype
= cleanup_type
(mtype
)
388 if rapidtype
== null then return # we do not care about null
390 self.analysis
.add_monomorphic_send
(rapidtype
, mproperty
)
391 #self.current_node.debug("add_monomorphic_send {rapidtype} {mproperty}")
394 fun add_cast_type
(mtype
: MType)
396 var rapidtype
= cleanup_type
(mtype
)
397 if rapidtype
== null then return # we do not care about null
399 self.analysis
.add_cast_type
(rapidtype
)
400 #self.current_node.debug("add_cast_type {rapidtype}")
403 redef fun visit
(node
)
405 if node
== null then return
406 node
.accept_rapid_type_vistor
(self)
407 if node
isa AExpr then
408 var implicit_cast_to
= node
.implicit_cast_to
409 if implicit_cast_to
!= null then self.add_cast_type
(implicit_cast_to
)
411 # RTA does not enter in AAnnotations
412 if not node
isa AAnnotations then
417 # Force to get the primitive class named `name' or abort
418 fun get_class
(name
: String): MClass
420 return self.analysis
.mainmodule
.get_primitive_class
(name
)
423 # Force to get the primitive property named `name' in the instance `recv' or abort
424 fun get_method
(recv
: MType, name
: String): MMethod
426 var rapidtype
= cleanup_type
(recv
)
427 if rapidtype
== null then abort
429 return self.analysis
.modelbuilder
.force_get_primitive_method
(self.current_node
.as(not null), name
, rapidtype
, self.analysis
.mainmodule
)
436 private fun accept_rapid_type_vistor
(v
: RapidTypeVisitor)
442 redef fun accept_rapid_type_vistor
(v
)
444 v
.add_type
(self.mtype
.as(not null))
448 redef class AFloatExpr
449 redef fun accept_rapid_type_vistor
(v
)
451 v
.add_type
(self.mtype
.as(not null))
455 redef class ACharExpr
456 redef fun accept_rapid_type_vistor
(v
)
458 v
.add_type
(self.mtype
.as(not null))
462 redef class AArrayExpr
463 redef fun accept_rapid_type_vistor
(v
)
465 var mtype
= self.mtype
.as(MClassType)
467 var native
= v
.get_class
("NativeArray").get_mtype
([mtype
.arguments
.first
])
469 var prop
= v
.get_method
(mtype
, "with_native")
470 v
.add_monomorphic_send
(mtype
, prop
)
474 redef class AStringFormExpr
475 redef fun accept_rapid_type_vistor
(v
)
477 var mtype
= self.mtype
.as(not null)
479 var native
= v
.get_class
("NativeString").mclass_type
481 var prop
= v
.get_method
(mtype
, "from_cstring")
482 v
.add_monomorphic_send
(mtype
, prop
)
486 redef class ASuperstringExpr
487 redef fun accept_rapid_type_vistor
(v
)
489 var arraytype
= v
.get_class
("Array").get_mtype
([v
.get_class
("Object").mclass_type
])
490 v
.add_type
(arraytype
)
491 v
.add_type
(v
.get_class
("NativeArray").get_mtype
([v
.get_class
("Object").mclass_type
]))
492 var prop
= v
.get_method
(arraytype
, "join")
493 v
.add_monomorphic_send
(arraytype
, prop
)
494 var prop2
= v
.get_method
(arraytype
, "with_native")
495 v
.add_monomorphic_send
(arraytype
, prop2
)
499 redef class ACrangeExpr
500 redef fun accept_rapid_type_vistor
(v
)
502 var mtype
= self.mtype
.as(not null)
504 var prop
= v
.get_method
(mtype
, "init")
505 v
.add_monomorphic_send
(mtype
, prop
)
509 redef class AOrangeExpr
510 redef fun accept_rapid_type_vistor
(v
)
512 var mtype
= self.mtype
.as(not null)
514 var prop
= v
.get_method
(mtype
, "without_last")
515 v
.add_monomorphic_send
(mtype
, prop
)
519 redef class ATrueExpr
520 redef fun accept_rapid_type_vistor
(v
)
522 v
.add_type
(self.mtype
.as(not null))
526 redef class AFalseExpr
527 redef fun accept_rapid_type_vistor
(v
)
529 v
.add_type
(self.mtype
.as(not null))
534 redef fun accept_rapid_type_vistor
(v
)
536 v
.add_cast_type
(self.cast_type
.as(not null))
540 redef class AAsCastExpr
541 redef fun accept_rapid_type_vistor
(v
)
543 v
.add_cast_type
(self.mtype
.as(not null))
549 redef class ASendExpr
550 redef fun accept_rapid_type_vistor
(v
)
552 var mproperty
= self.mproperty
.as(not null)
553 if n_expr
isa ASelfExpr then
554 v
.add_monomorphic_send
(v
.receiver
, mproperty
)
556 var recvtype
= self.n_expr
.mtype
.as(not null)
557 v
.add_send
(recvtype
, mproperty
)
562 redef class ASendReassignFormExpr
563 redef fun accept_rapid_type_vistor
(v
)
565 v
.add_send
(self.read_type
.as(not null), self.reassign_property
.mproperty
)
566 var mproperty
= self.mproperty
.as(not null)
567 var write_mproperty
= self.write_mproperty
.as(not null)
568 if n_expr
isa ASelfExpr then
569 v
.add_monomorphic_send
(v
.receiver
, mproperty
)
570 v
.add_monomorphic_send
(v
.receiver
, write_mproperty
)
572 var recvtype
= self.n_expr
.mtype
.as(not null)
573 v
.add_send
(recvtype
, mproperty
)
574 v
.add_send
(recvtype
, write_mproperty
)
579 redef class AVarReassignExpr
580 redef fun accept_rapid_type_vistor
(v
)
582 v
.add_send
(self.read_type
.as(not null), self.reassign_property
.mproperty
)
586 redef class AAttrReassignExpr
587 redef fun accept_rapid_type_vistor
(v
)
589 v
.add_send
(self.read_type
.as(not null), self.reassign_property
.mproperty
)
593 redef class ASuperExpr
594 redef fun accept_rapid_type_vistor
(v
)
596 var mproperty
= self.mproperty
597 if mproperty
!= null then
598 v
.add_monomorphic_send
(v
.receiver
, mproperty
)
602 var mpropdef
= v
.mpropdef
.lookup_next_definition
(v
.analysis
.mainmodule
, v
.receiver
)
603 assert mpropdef
isa MMethodDef
604 v
.analysis
.add_static_call
(v
.receiver
, mpropdef
)
609 redef fun accept_rapid_type_vistor
(v
)
611 var recvtype
= self.n_expr
.mtype
.as(not null)
612 var colltype
= self.coltype
.as(not null)
613 var itmeth
= v
.get_method
(colltype
, "iterator")
614 v
.add_send
(recvtype
, itmeth
)
615 var iteratortype
= itmeth
.intro
.msignature
.return_mtype
.as(MClassType).mclass
.intro
.bound_mtype
616 var objtype
= v
.get_class
("Object").mclass_type
617 v
.add_send
(objtype
, v
.get_method
(iteratortype
, "is_ok"))
618 if self.variables
.length
== 1 then
619 v
.add_send
(objtype
, v
.get_method
(iteratortype
, "item"))
620 else if self.variables
.length
== 2 then
621 v
.add_send
(objtype
, v
.get_method
(iteratortype
, "key"))
622 v
.add_send
(objtype
, v
.get_method
(iteratortype
, "item"))
626 v
.add_send
(objtype
, v
.get_method
(iteratortype
, "next"))
631 redef fun accept_rapid_type_vistor
(v
)
633 var recvtype
= self.mtype
.as(not null)
635 v
.add_monomorphic_send
(recvtype
, mproperty
.as(not null))