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.
17 # Classes, types and properties
19 # All three concepts are defined in this same module because these are strongly connected:
20 # * types are based on classes
21 # * classes contains properties
22 # * some properties are types (virtual types)
24 # TODO: liearization, extern stuff
25 # FIXME: better handling of the types
31 private import more_collections
35 var mclasses
= new Array[MClass]
37 # All known properties
38 var mproperties
= new Array[MProperty]
40 # Hierarchy of class definition.
42 # Each classdef is associated with its super-classdefs in regard to
43 # its module of definition.
44 var mclassdef_hierarchy
= new POSet[MClassDef]
46 # Class-type hierarchy restricted to the introduction.
48 # The idea is that what is true on introduction is always true whatever
49 # the module considered.
50 # Therefore, this hierarchy is used for a fast positive subtype check.
52 # This poset will evolve in a monotonous way:
53 # * Two non connected nodes will remain unconnected
54 # * New nodes can appear with new edges
55 private var intro_mtype_specialization_hierarchy
= new POSet[MClassType]
57 # Global overlapped class-type hierarchy.
58 # The hierarchy when all modules are combined.
59 # Therefore, this hierarchy is used for a fast negative subtype check.
61 # This poset will evolve in an anarchic way. Loops can even be created.
63 # FIXME decide what to do on loops
64 private var full_mtype_specialization_hierarchy
= new POSet[MClassType]
66 # Collections of classes grouped by their short name
67 private var mclasses_by_name
= new MultiHashMap[String, MClass]
69 # Return all class named `name`.
71 # If such a class does not exist, null is returned
72 # (instead of an empty array)
74 # Visibility or modules are not considered
75 fun get_mclasses_by_name
(name
: String): nullable Array[MClass]
77 return mclasses_by_name
.get_or_null
(name
)
80 # Collections of properties grouped by their short name
81 private var mproperties_by_name
= new MultiHashMap[String, MProperty]
83 # Return all properties named `name`.
85 # If such a property does not exist, null is returned
86 # (instead of an empty array)
88 # Visibility or modules are not considered
89 fun get_mproperties_by_name
(name
: String): nullable Array[MProperty]
91 return mproperties_by_name
.get_or_null
(name
)
95 var null_type
= new MNullType(self)
97 # Build an ordered tree with from `concerns`
98 fun concerns_tree
(mconcerns
: Collection[MConcern]): ConcernsTree do
99 var seen
= new HashSet[MConcern]
100 var res
= new ConcernsTree
102 var todo
= new Array[MConcern]
103 todo
.add_all mconcerns
105 while not todo
.is_empty
do
107 if seen
.has
(c
) then continue
108 var pc
= c
.parent_concern
122 # An OrderedTree that can be easily refined for display purposes
124 super OrderedTree[MConcern]
128 # All the classes introduced in the module
129 var intro_mclasses
= new Array[MClass]
131 # All the class definitions of the module
132 # (introduction and refinement)
133 var mclassdefs
= new Array[MClassDef]
135 # Does the current module has a given class `mclass`?
136 # Return true if the mmodule introduces, refines or imports a class.
137 # Visibility is not considered.
138 fun has_mclass
(mclass
: MClass): Bool
140 return self.in_importation
<= mclass
.intro_mmodule
143 # Full hierarchy of introduced ans imported classes.
145 # Create a new hierarchy got by flattening the classes for the module
146 # and its imported modules.
147 # Visibility is not considered.
149 # Note: this function is expensive and is usually used for the main
150 # module of a program only. Do not use it to do you own subtype
152 fun flatten_mclass_hierarchy
: POSet[MClass]
154 var res
= self.flatten_mclass_hierarchy_cache
155 if res
!= null then return res
156 res
= new POSet[MClass]
157 for m
in self.in_importation
.greaters
do
158 for cd
in m
.mclassdefs
do
161 for s
in cd
.supertypes
do
162 res
.add_edge
(c
, s
.mclass
)
166 self.flatten_mclass_hierarchy_cache
= res
170 # Sort a given array of classes using the linearization order of the module
171 # The most general is first, the most specific is last
172 fun linearize_mclasses
(mclasses
: Array[MClass])
174 self.flatten_mclass_hierarchy
.sort
(mclasses
)
177 # Sort a given array of class definitions using the linearization order of the module
178 # the refinement link is stronger than the specialisation link
179 # The most general is first, the most specific is last
180 fun linearize_mclassdefs
(mclassdefs
: Array[MClassDef])
182 var sorter
= new MClassDefSorter(self)
183 sorter
.sort
(mclassdefs
)
186 # Sort a given array of property definitions using the linearization order of the module
187 # the refinement link is stronger than the specialisation link
188 # The most general is first, the most specific is last
189 fun linearize_mpropdefs
(mpropdefs
: Array[MPropDef])
191 var sorter
= new MPropDefSorter(self)
192 sorter
.sort
(mpropdefs
)
195 private var flatten_mclass_hierarchy_cache
: nullable POSet[MClass] = null
197 # The primitive type `Object`, the root of the class hierarchy
198 var object_type
: MClassType = self.get_primitive_class
("Object").mclass_type
is lazy
200 # The type `Pointer`, super class to all extern classes
201 var pointer_type
: MClassType = self.get_primitive_class
("Pointer").mclass_type
is lazy
203 # The primitive type `Bool`
204 var bool_type
: MClassType = self.get_primitive_class
("Bool").mclass_type
is lazy
206 # The primitive type `Int`
207 var int_type
: MClassType = self.get_primitive_class
("Int").mclass_type
is lazy
209 # The primitive type `Char`
210 var char_type
: MClassType = self.get_primitive_class
("Char").mclass_type
is lazy
212 # The primitive type `Float`
213 var float_type
: MClassType = self.get_primitive_class
("Float").mclass_type
is lazy
215 # The primitive type `String`
216 var string_type
: MClassType = self.get_primitive_class
("String").mclass_type
is lazy
218 # The primitive type `NativeString`
219 var native_string_type
: MClassType = self.get_primitive_class
("NativeString").mclass_type
is lazy
221 # A primitive type of `Array`
222 fun array_type
(elt_type
: MType): MClassType do return array_class
.get_mtype
([elt_type
])
224 # The primitive class `Array`
225 var array_class
: MClass = self.get_primitive_class
("Array") is lazy
227 # A primitive type of `NativeArray`
228 fun native_array_type
(elt_type
: MType): MClassType do return native_array_class
.get_mtype
([elt_type
])
230 # The primitive class `NativeArray`
231 var native_array_class
: MClass = self.get_primitive_class
("NativeArray") is lazy
233 # The primitive type `Sys`, the main type of the program, if any
234 fun sys_type
: nullable MClassType
236 var clas
= self.model
.get_mclasses_by_name
("Sys")
237 if clas
== null then return null
238 return get_primitive_class
("Sys").mclass_type
241 # The primitive type `Finalizable`
242 # Used to tag classes that need to be finalized.
243 fun finalizable_type
: nullable MClassType
245 var clas
= self.model
.get_mclasses_by_name
("Finalizable")
246 if clas
== null then return null
247 return get_primitive_class
("Finalizable").mclass_type
250 # Force to get the primitive class named `name` or abort
251 fun get_primitive_class
(name
: String): MClass
253 var cla
= self.model
.get_mclasses_by_name
(name
)
254 # Filter classes by introducing module
255 if cla
!= null then cla
= [for c
in cla
do if self.in_importation
<= c
.intro_mmodule
then c
]
256 if cla
== null or cla
.is_empty
then
257 if name
== "Bool" and self.model
.get_mclasses_by_name
("Object") != null then
258 # Bool is injected because it is needed by engine to code the result
259 # of the implicit casts.
260 var c
= new MClass(self, name
, null, enum_kind
, public_visibility
)
261 var cladef
= new MClassDef(self, c
.mclass_type
, new Location(null, 0,0,0,0))
262 cladef
.set_supertypes
([object_type
])
263 cladef
.add_in_hierarchy
266 print
("Fatal Error: no primitive class {name} in {self}")
269 if cla
.length
!= 1 then
270 var msg
= "Fatal Error: more than one primitive class {name} in {self}:"
271 for c
in cla
do msg
+= " {c.full_name}"
278 # Try to get the primitive method named `name` on the type `recv`
279 fun try_get_primitive_method
(name
: String, recv
: MClass): nullable MMethod
281 var props
= self.model
.get_mproperties_by_name
(name
)
282 if props
== null then return null
283 var res
: nullable MMethod = null
284 for mprop
in props
do
285 assert mprop
isa MMethod
286 var intro
= mprop
.intro_mclassdef
287 for mclassdef
in recv
.mclassdefs
do
288 if not self.in_importation
.greaters
.has
(mclassdef
.mmodule
) then continue
289 if not mclassdef
.in_hierarchy
.greaters
.has
(intro
) then continue
292 else if res
!= mprop
then
293 print
("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}")
302 private class MClassDefSorter
304 redef type COMPARED: MClassDef
306 redef fun compare
(a
, b
)
310 if ca
!= cb
then return mmodule
.flatten_mclass_hierarchy
.compare
(ca
, cb
)
311 return mmodule
.model
.mclassdef_hierarchy
.compare
(a
, b
)
315 private class MPropDefSorter
317 redef type COMPARED: MPropDef
319 redef fun compare
(pa
, pb
)
325 if ca
!= cb
then return mmodule
.flatten_mclass_hierarchy
.compare
(ca
, cb
)
326 return mmodule
.model
.mclassdef_hierarchy
.compare
(a
, b
)
332 # `MClass` are global to the model; it means that a `MClass` is not bound to a
333 # specific `MModule`.
335 # This characteristic helps the reasoning about classes in a program since a
336 # single `MClass` object always denote the same class.
338 # The drawback is that classes (`MClass`) contain almost nothing by themselves.
339 # These do not really have properties nor belong to a hierarchy since the property and the
340 # hierarchy of a class depends of the refinement in the modules.
342 # Most services on classes require the precision of a module, and no one can asks what are
343 # the super-classes of a class nor what are properties of a class without precising what is
344 # the module considered.
346 # For instance, during the typing of a source-file, the module considered is the module of the file.
347 # eg. the question *is the method `foo` exists in the class `Bar`?* must be reformulated into
348 # *is the method `foo` exists in the class `Bar` in the current module?*
350 # During some global analysis, the module considered may be the main module of the program.
354 # The module that introduce the class
355 # While classes are not bound to a specific module,
356 # the introducing module is used for naming an visibility
357 var intro_mmodule
: MModule
359 # The short name of the class
360 # In Nit, the name of a class cannot evolve in refinements
361 redef var name
: String
363 # The canonical name of the class
365 # It is the name of the class prefixed by the full_name of the `intro_mmodule`
366 # Example: `"owner::module::MyClass"`
367 redef var full_name
is lazy
do
368 return "{self.intro_mmodule.namespace_for(visibility)}::{name}"
371 redef var c_name
is lazy
do
372 return "{intro_mmodule.c_namespace_for(visibility)}__{name.to_cmangle}"
375 # The number of generic formal parameters
376 # 0 if the class is not generic
377 var arity
: Int is noinit
379 # Each generic formal parameters in order.
380 # is empty if the class is not generic
381 var mparameters
= new Array[MParameterType]
383 # Initialize `mparameters` from their names.
384 protected fun setup_parameter_names
(parameter_names
: nullable Array[String]) is
387 if parameter_names
== null then
390 self.arity
= parameter_names
.length
393 # Create the formal parameter types
395 assert parameter_names
!= null
396 var mparametertypes
= new Array[MParameterType]
397 for i
in [0..arity
[ do
398 var mparametertype
= new MParameterType(self, i
, parameter_names
[i
])
399 mparametertypes
.add
(mparametertype
)
401 self.mparameters
= mparametertypes
402 var mclass_type
= new MGenericType(self, mparametertypes
)
403 self.mclass_type
= mclass_type
404 self.get_mtype_cache
[mparametertypes
] = mclass_type
406 self.mclass_type
= new MClassType(self)
410 # The kind of the class (interface, abstract class, etc.)
411 # In Nit, the kind of a class cannot evolve in refinements
414 # The visibility of the class
415 # In Nit, the visibility of a class cannot evolve in refinements
416 var visibility
: MVisibility
420 intro_mmodule
.intro_mclasses
.add
(self)
421 var model
= intro_mmodule
.model
422 model
.mclasses_by_name
.add_one
(name
, self)
423 model
.mclasses
.add
(self)
426 redef fun model
do return intro_mmodule
.model
428 # All class definitions (introduction and refinements)
429 var mclassdefs
= new Array[MClassDef]
432 redef fun to_s
do return self.name
434 # The definition that introduces the class.
436 # Warning: such a definition may not exist in the early life of the object.
437 # In this case, the method will abort.
439 # Use `try_intro` instead
440 var intro
: MClassDef is noinit
442 # The definition that introduces the class or null if not yet known.
445 fun try_intro
: nullable MClassDef do
446 if isset _intro
then return _intro
else return null
449 # Return the class `self` in the class hierarchy of the module `mmodule`.
451 # SEE: `MModule::flatten_mclass_hierarchy`
452 # REQUIRE: `mmodule.has_mclass(self)`
453 fun in_hierarchy
(mmodule
: MModule): POSetElement[MClass]
455 return mmodule
.flatten_mclass_hierarchy
[self]
458 # The principal static type of the class.
460 # For non-generic class, mclass_type is the only `MClassType` based
463 # For a generic class, the arguments are the formal parameters.
464 # i.e.: for the class Array[E:Object], the `mclass_type` is Array[E].
465 # If you want Array[Object] the see `MClassDef::bound_mtype`
467 # For generic classes, the mclass_type is also the way to get a formal
468 # generic parameter type.
470 # To get other types based on a generic class, see `get_mtype`.
472 # ENSURE: `mclass_type.mclass == self`
473 var mclass_type
: MClassType is noinit
475 # Return a generic type based on the class
476 # Is the class is not generic, then the result is `mclass_type`
478 # REQUIRE: `mtype_arguments.length == self.arity`
479 fun get_mtype
(mtype_arguments
: Array[MType]): MClassType
481 assert mtype_arguments
.length
== self.arity
482 if self.arity
== 0 then return self.mclass_type
483 var res
= get_mtype_cache
.get_or_null
(mtype_arguments
)
484 if res
!= null then return res
485 res
= new MGenericType(self, mtype_arguments
)
486 self.get_mtype_cache
[mtype_arguments
.to_a
] = res
490 private var get_mtype_cache
= new HashMap[Array[MType], MGenericType]
492 # Is there a `new` factory to allow the pseudo instantiation?
493 var has_new_factory
= false is writable
497 # A definition (an introduction or a refinement) of a class in a module
499 # A `MClassDef` is associated with an explicit (or almost) definition of a
500 # class. Unlike `MClass`, a `MClassDef` is a local definition that belong to
501 # a specific class and a specific module, and contains declarations like super-classes
504 # It is the class definitions that are the backbone of most things in the model:
505 # ClassDefs are defined with regard with other classdefs.
506 # Refinement and specialization are combined to produce a big poset called the `Model::mclassdef_hierarchy`.
508 # Moreover, the extension and the intention of types is defined by looking at the MClassDefs.
512 # The module where the definition is
515 # The associated `MClass`
516 var mclass
: MClass is noinit
518 # The bounded type associated to the mclassdef
520 # For a non-generic class, `bound_mtype` and `mclass.mclass_type`
524 # For the classdef Array[E: Object], the bound_mtype is Array[Object].
525 # If you want Array[E], then see `mclass.mclass_type`
527 # ENSURE: `bound_mtype.mclass == self.mclass`
528 var bound_mtype
: MClassType
530 # The origin of the definition
531 var location
: Location
533 # Internal name combining the module and the class
534 # Example: "mymodule#MyClass"
535 redef var to_s
: String is noinit
539 self.mclass
= bound_mtype
.mclass
540 mmodule
.mclassdefs
.add
(self)
541 mclass
.mclassdefs
.add
(self)
542 if mclass
.intro_mmodule
== mmodule
then
543 assert not isset mclass
._intro
546 self.to_s
= "{mmodule}#{mclass}"
549 # Actually the name of the `mclass`
550 redef fun name
do return mclass
.name
552 # The module and class name separated by a '#'.
554 # The short-name of the class is used for introduction.
555 # Example: "my_module#MyClass"
557 # The full-name of the class is used for refinement.
558 # Example: "my_module#intro_module::MyClass"
559 redef var full_name
is lazy
do
562 # private gives 'p::m#A'
563 return "{mmodule.namespace_for(mclass.visibility)}#{mclass.name}"
564 else if mclass
.intro_mmodule
.mproject
!= mmodule
.mproject
then
565 # public gives 'q::n#p::A'
566 # private gives 'q::n#p::m::A'
567 return "{mmodule.full_name}#{mclass.full_name}"
568 else if mclass
.visibility
> private_visibility
then
569 # public gives 'p::n#A'
570 return "{mmodule.full_name}#{mclass.name}"
572 # private gives 'p::n#::m::A' (redundant p is omitted)
573 return "{mmodule.full_name}#::{mclass.intro_mmodule.name}::{mclass.name}"
577 redef var c_name
is lazy
do
579 return "{mmodule.c_namespace_for(mclass.visibility)}___{mclass.c_name}"
580 else if mclass
.intro_mmodule
.mproject
== mmodule
.mproject
and mclass
.visibility
> private_visibility
then
581 return "{mmodule.c_name}___{mclass.name.to_cmangle}"
583 return "{mmodule.c_name}___{mclass.c_name}"
587 redef fun model
do return mmodule
.model
589 # All declared super-types
590 # FIXME: quite ugly but not better idea yet
591 var supertypes
= new Array[MClassType]
593 # Register some super-types for the class (ie "super SomeType")
595 # The hierarchy must not already be set
596 # REQUIRE: `self.in_hierarchy == null`
597 fun set_supertypes
(supertypes
: Array[MClassType])
599 assert unique_invocation
: self.in_hierarchy
== null
600 var mmodule
= self.mmodule
601 var model
= mmodule
.model
602 var mtype
= self.bound_mtype
604 for supertype
in supertypes
do
605 self.supertypes
.add
(supertype
)
607 # Register in full_type_specialization_hierarchy
608 model
.full_mtype_specialization_hierarchy
.add_edge
(mtype
, supertype
)
609 # Register in intro_type_specialization_hierarchy
610 if mclass
.intro_mmodule
== mmodule
and supertype
.mclass
.intro_mmodule
== mmodule
then
611 model
.intro_mtype_specialization_hierarchy
.add_edge
(mtype
, supertype
)
617 # Collect the super-types (set by set_supertypes) to build the hierarchy
619 # This function can only invoked once by class
620 # REQUIRE: `self.in_hierarchy == null`
621 # ENSURE: `self.in_hierarchy != null`
624 assert unique_invocation
: self.in_hierarchy
== null
625 var model
= mmodule
.model
626 var res
= model
.mclassdef_hierarchy
.add_node
(self)
627 self.in_hierarchy
= res
628 var mtype
= self.bound_mtype
630 # Here we need to connect the mclassdef to its pairs in the mclassdef_hierarchy
631 # The simpliest way is to attach it to collect_mclassdefs
632 for mclassdef
in mtype
.collect_mclassdefs
(mmodule
) do
633 res
.poset
.add_edge
(self, mclassdef
)
637 # The view of the class definition in `mclassdef_hierarchy`
638 var in_hierarchy
: nullable POSetElement[MClassDef] = null
640 # Is the definition the one that introduced `mclass`?
641 fun is_intro
: Bool do return isset mclass
._intro
and mclass
.intro
== self
643 # All properties introduced by the classdef
644 var intro_mproperties
= new Array[MProperty]
646 # All property definitions in the class (introductions and redefinitions)
647 var mpropdefs
= new Array[MPropDef]
650 # A global static type
652 # MType are global to the model; it means that a `MType` is not bound to a
653 # specific `MModule`.
654 # This characteristic helps the reasoning about static types in a program
655 # since a single `MType` object always denote the same type.
657 # However, because a `MType` is global, it does not really have properties
658 # nor have subtypes to a hierarchy since the property and the class hierarchy
659 # depends of a module.
660 # Moreover, virtual types an formal generic parameter types also depends on
661 # a receiver to have sense.
663 # Therefore, most method of the types require a module and an anchor.
664 # The module is used to know what are the classes and the specialization
666 # The anchor is used to know what is the bound of the virtual types and formal
667 # generic parameter types.
669 # MType are not directly usable to get properties. See the `anchor_to` method
670 # and the `MClassType` class.
672 # FIXME: the order of the parameters is not the best. We mus pick on from:
673 # * foo(mmodule, anchor, othertype)
674 # * foo(othertype, anchor, mmodule)
675 # * foo(anchor, mmodule, othertype)
676 # * foo(othertype, mmodule, anchor)
680 redef fun name
do return to_s
682 # Return true if `self` is an subtype of `sup`.
683 # The typing is done using the standard typing policy of Nit.
685 # REQUIRE: `anchor == null implies not self.need_anchor and not sup.need_anchor`
686 # REQUIRE: `anchor != null implies self.can_resolve_for(anchor, null, mmodule) and sup.can_resolve_for(anchor, null, mmodule)`
687 fun is_subtype
(mmodule
: MModule, anchor
: nullable MClassType, sup
: MType): Bool
690 if sub
== sup
then return true
692 #print "1.is {sub} a {sup}? ===="
694 if anchor
== null then
695 assert not sub
.need_anchor
696 assert not sup
.need_anchor
698 # First, resolve the formal types to the simplest equivalent forms in the receiver
699 assert sub
.can_resolve_for
(anchor
, null, mmodule
)
700 sub
= sub
.lookup_fixed
(mmodule
, anchor
)
701 assert sup
.can_resolve_for
(anchor
, null, mmodule
)
702 sup
= sup
.lookup_fixed
(mmodule
, anchor
)
705 # Does `sup` accept null or not?
706 # Discard the nullable marker if it exists
707 var sup_accept_null
= false
708 if sup
isa MNullableType then
709 sup_accept_null
= true
711 else if sup
isa MNullType then
712 sup_accept_null
= true
715 # Can `sub` provide null or not?
716 # Thus we can match with `sup_accept_null`
717 # Also discard the nullable marker if it exists
718 if sub
isa MNullableType then
719 if not sup_accept_null
then return false
721 else if sub
isa MNullType then
722 return sup_accept_null
724 # Now the case of direct null and nullable is over.
726 # If `sub` is a formal type, then it is accepted if its bound is accepted
727 while sub
isa MParameterType or sub
isa MVirtualType do
728 #print "3.is {sub} a {sup}?"
730 # A unfixed formal type can only accept itself
731 if sub
== sup
then return true
733 assert anchor
!= null
734 sub
= sub
.lookup_bound
(mmodule
, anchor
)
736 #print "3.is {sub} a {sup}?"
738 # Manage the second layer of null/nullable
739 if sub
isa MNullableType then
740 if not sup_accept_null
then return false
742 else if sub
isa MNullType then
743 return sup_accept_null
746 #print "4.is {sub} a {sup}? <- no more resolution"
748 assert sub
isa MClassType # It is the only remaining type
750 # A unfixed formal type can only accept itself
751 if sup
isa MParameterType or sup
isa MVirtualType then
755 if sup
isa MNullType then
756 # `sup` accepts only null
760 assert sup
isa MClassType # It is the only remaining type
762 # Now both are MClassType, we need to dig
764 if sub
== sup
then return true
766 if anchor
== null then anchor
= sub
# UGLY: any anchor will work
767 var resolved_sub
= sub
.anchor_to
(mmodule
, anchor
)
768 var res
= resolved_sub
.collect_mclasses
(mmodule
).has
(sup
.mclass
)
769 if res
== false then return false
770 if not sup
isa MGenericType then return true
771 var sub2
= sub
.supertype_to
(mmodule
, anchor
, sup
.mclass
)
772 assert sub2
.mclass
== sup
.mclass
773 for i
in [0..sup
.mclass
.arity
[ do
774 var sub_arg
= sub2
.arguments
[i
]
775 var sup_arg
= sup
.arguments
[i
]
776 res
= sub_arg
.is_subtype
(mmodule
, anchor
, sup_arg
)
777 if res
== false then return false
782 # The base class type on which self is based
784 # This base type is used to get property (an internally to perform
785 # unsafe type comparison).
787 # Beware: some types (like null) are not based on a class thus this
790 # Basically, this function transform the virtual types and parameter
791 # types to their bounds.
796 # class B super A end
798 # class Y super X end
807 # Map[T,U] anchor_to H #-> Map[B,Y]
809 # Explanation of the example:
810 # In H, T is set to B, because "H super G[B]", and U is bound to Y,
811 # because "redef type U: Y". Therefore, Map[T, U] is bound to
814 # ENSURE: `not self.need_anchor implies result == self`
815 # ENSURE: `not result.need_anchor`
816 fun anchor_to
(mmodule
: MModule, anchor
: MClassType): MType
818 if not need_anchor
then return self
819 assert not anchor
.need_anchor
820 # Just resolve to the anchor and clear all the virtual types
821 var res
= self.resolve_for
(anchor
, null, mmodule
, true)
822 assert not res
.need_anchor
826 # Does `self` contain a virtual type or a formal generic parameter type?
827 # In order to remove those types, you usually want to use `anchor_to`.
828 fun need_anchor
: Bool do return true
830 # Return the supertype when adapted to a class.
832 # In Nit, for each super-class of a type, there is a equivalent super-type.
838 # class H[V] super G[V, Bool] end
840 # H[Int] supertype_to G #-> G[Int, Bool]
843 # REQUIRE: `super_mclass` is a super-class of `self`
844 # REQUIRE: `self.need_anchor implies anchor != null and self.can_resolve_for(anchor, null, mmodule)`
845 # ENSURE: `result.mclass = super_mclass`
846 fun supertype_to
(mmodule
: MModule, anchor
: nullable MClassType, super_mclass
: MClass): MClassType
848 if super_mclass
.arity
== 0 then return super_mclass
.mclass_type
849 if self isa MClassType and self.mclass
== super_mclass
then return self
851 if self.need_anchor
then
852 assert anchor
!= null
853 resolved_self
= self.anchor_to
(mmodule
, anchor
)
857 var supertypes
= resolved_self
.collect_mtypes
(mmodule
)
858 for supertype
in supertypes
do
859 if supertype
.mclass
== super_mclass
then
860 # FIXME: Here, we stop on the first goal. Should we check others and detect inconsistencies?
861 return supertype
.resolve_for
(self, anchor
, mmodule
, false)
867 # Replace formals generic types in self with resolved values in `mtype`
868 # If `cleanup_virtual` is true, then virtual types are also replaced
871 # This function returns self if `need_anchor` is false.
877 # class H[F] super G[F] end
881 # * Array[E].resolve_for(H[Int]) #-> Array[Int]
882 # * Array[E].resolve_for(G[Z], X[Int]) #-> Array[Z]
884 # Explanation of the example:
885 # * Array[E].need_anchor is true because there is a formal generic parameter type E
886 # * E makes sense for H[Int] because E is a formal parameter of G and H specialize G
887 # * Since "H[F] super G[F]", E is in fact F for H
888 # * More specifically, in H[Int], E is Int
889 # * So, in H[Int], Array[E] is Array[Int]
891 # This function is mainly used to inherit a signature.
892 # Because, unlike `anchor_to`, we do not want a full resolution of
893 # a type but only an adapted version of it.
899 # fun foo(e:E):E is abstract
901 # class B super A[Int] end
904 # The signature on foo is (e: E): E
905 # If we resolve the signature for B, we get (e:Int):Int
911 # fun foo(e:E):E is abstract
915 # fun bar do a.foo(x) # <- x is here
919 # The first question is: is foo available on `a`?
921 # The static type of a is `A[Array[F]]`, that is an open type.
922 # in order to find a method `foo`, whe must look at a resolved type.
924 # A[Array[F]].anchor_to(C[nullable Object]) #-> A[Array[nullable Object]]
926 # the method `foo` exists in `A[Array[nullable Object]]`, therefore `foo` exists for `a`.
928 # The next question is: what is the accepted types for `x`?
930 # the signature of `foo` is `foo(e:E)`, thus we must resolve the type E
932 # E.resolve_for(A[Array[F]],C[nullable Object]) #-> Array[F]
934 # The resolution can be done because `E` make sense for the class A (see `can_resolve_for`)
936 # FIXME: the parameter `cleanup_virtual` is just a bad idea, but having
937 # two function instead of one seems also to be a bad idea.
939 # REQUIRE: `can_resolve_for(mtype, anchor, mmodule)`
940 # ENSURE: `not self.need_anchor implies result == self`
941 fun resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule, cleanup_virtual
: Bool): MType is abstract
943 # Resolve formal type to its verbatim bound.
944 # If the type is not formal, just return self
946 # The result is returned exactly as declared in the "type" property (verbatim).
947 # So it could be another formal type.
949 # In case of conflict, the method aborts.
950 fun lookup_bound
(mmodule
: MModule, resolved_receiver
: MType): MType do return self
952 # Resolve the formal type to its simplest equivalent form.
954 # Formal types are either free or fixed.
955 # When it is fixed, it means that it is equivalent with a simpler type.
956 # When a formal type is free, it means that it is only equivalent with itself.
957 # This method return the most simple equivalent type of `self`.
959 # This method is mainly used for subtype test in order to sanely compare fixed.
961 # By default, return self.
962 # See the redefinitions for specific behavior in each kind of type.
963 fun lookup_fixed
(mmodule
: MModule, resolved_receiver
: MType): MType do return self
965 # Can the type be resolved?
967 # In order to resolve open types, the formal types must make sence.
977 # E.can_resolve_for(A[Int]) #-> true, E make sense in A
979 # E.can_resolve_for(B[Int]) #-> false, E does not make sense in B
981 # B[E].can_resolve_for(A[F], B[Object]) #-> true,
982 # # B[E] is a red hearing only the E is important,
983 # # E make sense in A
986 # REQUIRE: `anchor != null implies not anchor.need_anchor`
987 # REQUIRE: `mtype.need_anchor implies anchor != null and mtype.can_resolve_for(anchor, null, mmodule)`
988 # ENSURE: `not self.need_anchor implies result == true`
989 fun can_resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule): Bool is abstract
991 # Return the nullable version of the type
992 # If the type is already nullable then self is returned
993 fun as_nullable
: MType
995 var res
= self.as_nullable_cache
996 if res
!= null then return res
997 res
= new MNullableType(self)
998 self.as_nullable_cache
= res
1002 # Return the not nullable version of the type
1003 # Is the type is already not nullable, then self is returned.
1005 # Note: this just remove the `nullable` notation, but the result can still contains null.
1006 # For instance if `self isa MNullType` or self is a formal type bounded by a nullable type.
1007 fun as_notnullable
: MType
1012 private var as_nullable_cache
: nullable MType = null
1015 # The depth of the type seen as a tree.
1022 # Formal types have a depth of 1.
1028 # The length of the type seen as a tree.
1035 # Formal types have a length of 1.
1041 # Compute all the classdefs inherited/imported.
1042 # The returned set contains:
1043 # * the class definitions from `mmodule` and its imported modules
1044 # * the class definitions of this type and its super-types
1046 # This function is used mainly internally.
1048 # REQUIRE: `not self.need_anchor`
1049 fun collect_mclassdefs
(mmodule
: MModule): Set[MClassDef] is abstract
1051 # Compute all the super-classes.
1052 # This function is used mainly internally.
1054 # REQUIRE: `not self.need_anchor`
1055 fun collect_mclasses
(mmodule
: MModule): Set[MClass] is abstract
1057 # Compute all the declared super-types.
1058 # Super-types are returned as declared in the classdefs (verbatim).
1059 # This function is used mainly internally.
1061 # REQUIRE: `not self.need_anchor`
1062 fun collect_mtypes
(mmodule
: MModule): Set[MClassType] is abstract
1064 # Is the property in self for a given module
1065 # This method does not filter visibility or whatever
1067 # REQUIRE: `not self.need_anchor`
1068 fun has_mproperty
(mmodule
: MModule, mproperty
: MProperty): Bool
1070 assert not self.need_anchor
1071 return self.collect_mclassdefs
(mmodule
).has
(mproperty
.intro_mclassdef
)
1075 # A type based on a class.
1077 # `MClassType` have properties (see `has_mproperty`).
1081 # The associated class
1084 redef fun model
do return self.mclass
.intro_mmodule
.model
1086 # TODO: private init because strongly bounded to its mclass. see `mclass.mclass_type`
1088 # The formal arguments of the type
1089 # ENSURE: `result.length == self.mclass.arity`
1090 var arguments
= new Array[MType]
1092 redef fun to_s
do return mclass
.to_s
1094 redef fun full_name
do return mclass
.full_name
1096 redef fun c_name
do return mclass
.c_name
1098 redef fun need_anchor
do return false
1100 redef fun anchor_to
(mmodule
: MModule, anchor
: MClassType): MClassType
1102 return super.as(MClassType)
1105 redef fun resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule, cleanup_virtual
: Bool): MClassType do return self
1107 redef fun can_resolve_for
(mtype
, anchor
, mmodule
) do return true
1109 redef fun collect_mclassdefs
(mmodule
)
1111 assert not self.need_anchor
1112 var cache
= self.collect_mclassdefs_cache
1113 if not cache
.has_key
(mmodule
) then
1114 self.collect_things
(mmodule
)
1116 return cache
[mmodule
]
1119 redef fun collect_mclasses
(mmodule
)
1121 if collect_mclasses_last_module
== mmodule
then return collect_mclasses_last_module_cache
1122 assert not self.need_anchor
1123 var cache
= self.collect_mclasses_cache
1124 if not cache
.has_key
(mmodule
) then
1125 self.collect_things
(mmodule
)
1127 var res
= cache
[mmodule
]
1128 collect_mclasses_last_module
= mmodule
1129 collect_mclasses_last_module_cache
= res
1133 private var collect_mclasses_last_module
: nullable MModule = null
1134 private var collect_mclasses_last_module_cache
: Set[MClass] is noinit
1136 redef fun collect_mtypes
(mmodule
)
1138 assert not self.need_anchor
1139 var cache
= self.collect_mtypes_cache
1140 if not cache
.has_key
(mmodule
) then
1141 self.collect_things
(mmodule
)
1143 return cache
[mmodule
]
1146 # common implementation for `collect_mclassdefs`, `collect_mclasses`, and `collect_mtypes`.
1147 private fun collect_things
(mmodule
: MModule)
1149 var res
= new HashSet[MClassDef]
1150 var seen
= new HashSet[MClass]
1151 var types
= new HashSet[MClassType]
1152 seen
.add
(self.mclass
)
1153 var todo
= [self.mclass
]
1154 while not todo
.is_empty
do
1155 var mclass
= todo
.pop
1156 #print "process {mclass}"
1157 for mclassdef
in mclass
.mclassdefs
do
1158 if not mmodule
.in_importation
<= mclassdef
.mmodule
then continue
1159 #print " process {mclassdef}"
1161 for supertype
in mclassdef
.supertypes
do
1162 types
.add
(supertype
)
1163 var superclass
= supertype
.mclass
1164 if seen
.has
(superclass
) then continue
1165 #print " add {superclass}"
1166 seen
.add
(superclass
)
1167 todo
.add
(superclass
)
1171 collect_mclassdefs_cache
[mmodule
] = res
1172 collect_mclasses_cache
[mmodule
] = seen
1173 collect_mtypes_cache
[mmodule
] = types
1176 private var collect_mclassdefs_cache
= new HashMap[MModule, Set[MClassDef]]
1177 private var collect_mclasses_cache
= new HashMap[MModule, Set[MClass]]
1178 private var collect_mtypes_cache
= new HashMap[MModule, Set[MClassType]]
1182 # A type based on a generic class.
1183 # A generic type a just a class with additional formal generic arguments.
1189 # TODO: private init because strongly bounded to its mclass. see `mclass.get_mtype`
1193 assert self.mclass
.arity
== arguments
.length
1195 self.need_anchor
= false
1196 for t
in arguments
do
1197 if t
.need_anchor
then
1198 self.need_anchor
= true
1203 self.to_s
= "{mclass}[{arguments.join(", ")}]"
1206 # The short-name of the class, then the full-name of each type arguments within brackets.
1207 # Example: `"Map[String, List[Int]]"`
1208 redef var to_s
: String is noinit
1210 # The full-name of the class, then the full-name of each type arguments within brackets.
1211 # Example: `"standard::Map[standard::String, standard::List[standard::Int]]"`
1212 redef var full_name
is lazy
do
1213 var args
= new Array[String]
1214 for t
in arguments
do
1215 args
.add t
.full_name
1217 return "{mclass.full_name}[{args.join(", ")}]"
1220 redef var c_name
is lazy
do
1221 var res
= mclass
.c_name
1222 # Note: because the arity is known, a prefix notation is enough
1223 for t
in arguments
do
1230 redef var need_anchor
: Bool is noinit
1232 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1234 if not need_anchor
then return self
1235 assert can_resolve_for
(mtype
, anchor
, mmodule
)
1236 var types
= new Array[MType]
1237 for t
in arguments
do
1238 types
.add
(t
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
))
1240 return mclass
.get_mtype
(types
)
1243 redef fun can_resolve_for
(mtype
, anchor
, mmodule
)
1245 if not need_anchor
then return true
1246 for t
in arguments
do
1247 if not t
.can_resolve_for
(mtype
, anchor
, mmodule
) then return false
1256 for a
in self.arguments
do
1258 if d
> dmax
then dmax
= d
1266 for a
in self.arguments
do
1273 # A virtual formal type.
1277 # The property associated with the type.
1278 # Its the definitions of this property that determine the bound or the virtual type.
1279 var mproperty
: MVirtualTypeProp
1281 redef fun model
do return self.mproperty
.intro_mclassdef
.mmodule
.model
1283 redef fun lookup_bound
(mmodule
: MModule, resolved_receiver
: MType): MType
1285 return lookup_single_definition
(mmodule
, resolved_receiver
).bound
.as(not null)
1288 private fun lookup_single_definition
(mmodule
: MModule, resolved_receiver
: MType): MVirtualTypeDef
1290 assert not resolved_receiver
.need_anchor
1291 var props
= self.mproperty
.lookup_definitions
(mmodule
, resolved_receiver
)
1292 if props
.is_empty
then
1294 else if props
.length
== 1 then
1297 var types
= new ArraySet[MType]
1298 var res
= props
.first
1300 types
.add
(p
.bound
.as(not null))
1301 if not res
.is_fixed
then res
= p
1303 if types
.length
== 1 then
1309 # A VT is fixed when:
1310 # * the VT is (re-)defined with the annotation `is fixed`
1311 # * the VT is (indirectly) bound to an enum class (see `enum_kind`) since there is no subtype possible
1312 # * the receiver is an enum class since there is no subtype possible
1313 redef fun lookup_fixed
(mmodule
: MModule, resolved_receiver
: MType): MType
1315 assert not resolved_receiver
.need_anchor
1316 resolved_receiver
= resolved_receiver
.as_notnullable
1317 assert resolved_receiver
isa MClassType # It is the only remaining type
1319 var prop
= lookup_single_definition
(mmodule
, resolved_receiver
)
1320 var res
= prop
.bound
.as(not null)
1322 # Recursively lookup the fixed result
1323 res
= res
.lookup_fixed
(mmodule
, resolved_receiver
)
1325 # 1. For a fixed VT, return the resolved bound
1326 if prop
.is_fixed
then return res
1328 # 2. For a enum boud, return the bound
1329 if res
isa MClassType and res
.mclass
.kind
== enum_kind
then return res
1331 # 3. for a enum receiver return the bound
1332 if resolved_receiver
.mclass
.kind
== enum_kind
then return res
1337 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1339 if not cleanup_virtual
then return self
1340 assert can_resolve_for
(mtype
, anchor
, mmodule
)
1341 # self is a virtual type declared (or inherited) in mtype
1342 # The point of the function it to get the bound of the virtual type that make sense for mtype
1343 # But because mtype is maybe a virtual/formal type, we need to get a real receiver first
1344 #print "{class_name}: {self}/{mtype}/{anchor}?"
1345 var resolved_receiver
1346 if mtype
.need_anchor
then
1347 assert anchor
!= null
1348 resolved_receiver
= mtype
.resolve_for
(anchor
, null, mmodule
, true)
1350 resolved_receiver
= mtype
1352 # Now, we can get the bound
1353 var verbatim_bound
= lookup_bound
(mmodule
, resolved_receiver
)
1354 # The bound is exactly as declared in the "type" property, so we must resolve it again
1355 var res
= verbatim_bound
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1360 redef fun can_resolve_for
(mtype
, anchor
, mmodule
)
1362 if mtype
.need_anchor
then
1363 assert anchor
!= null
1364 mtype
= mtype
.anchor_to
(mmodule
, anchor
)
1366 return mtype
.has_mproperty
(mmodule
, mproperty
)
1369 redef fun to_s
do return self.mproperty
.to_s
1371 redef fun full_name
do return self.mproperty
.full_name
1373 redef fun c_name
do return self.mproperty
.c_name
1376 # The type associated to a formal parameter generic type of a class
1378 # Each parameter type is associated to a specific class.
1379 # It means that all refinements of a same class "share" the parameter type,
1380 # but that a generic subclass has its own parameter types.
1382 # However, in the sense of the meta-model, a parameter type of a class is
1383 # a valid type in a subclass. The "in the sense of the meta-model" is
1384 # important because, in the Nit language, the programmer cannot refers
1385 # directly to the parameter types of the super-classes.
1390 # fun e: E is abstract
1396 # In the class definition B[F], `F` is a valid type but `E` is not.
1397 # However, `self.e` is a valid method call, and the signature of `e` is
1400 # Note that parameter types are shared among class refinements.
1401 # Therefore parameter only have an internal name (see `to_s` for details).
1402 class MParameterType
1405 # The generic class where the parameter belong
1408 redef fun model
do return self.mclass
.intro_mmodule
.model
1410 # The position of the parameter (0 for the first parameter)
1411 # FIXME: is `position` a better name?
1416 redef fun to_s
do return name
1418 redef var full_name
is lazy
do return "{mclass.full_name}::{name}"
1420 redef var c_name
is lazy
do return mclass
.c_name
+ "__" + "#{name}".to_cmangle
1422 redef fun lookup_bound
(mmodule
: MModule, resolved_receiver
: MType): MType
1424 assert not resolved_receiver
.need_anchor
1425 resolved_receiver
= resolved_receiver
.as_notnullable
1426 assert resolved_receiver
isa MClassType # It is the only remaining type
1427 var goalclass
= self.mclass
1428 if resolved_receiver
.mclass
== goalclass
then
1429 return resolved_receiver
.arguments
[self.rank
]
1431 var supertypes
= resolved_receiver
.collect_mtypes
(mmodule
)
1432 for t
in supertypes
do
1433 if t
.mclass
== goalclass
then
1434 # Yeah! c specialize goalclass with a "super `t'". So the question is what is the argument of f
1435 # FIXME: Here, we stop on the first goal. Should we check others and detect inconsistencies?
1436 var res
= t
.arguments
[self.rank
]
1443 # A PT is fixed when:
1444 # * Its bound is a enum class (see `enum_kind`).
1445 # The PT is just useless, but it is still a case.
1446 # * More usually, the `resolved_receiver` is a subclass of `self.mclass`,
1447 # so it is necessarily fixed in a `super` clause, either with a normal type
1448 # or with another PT.
1449 # See `resolve_for` for examples about related issues.
1450 redef fun lookup_fixed
(mmodule
: MModule, resolved_receiver
: MType): MType
1452 assert not resolved_receiver
.need_anchor
1453 resolved_receiver
= resolved_receiver
.as_notnullable
1454 assert resolved_receiver
isa MClassType # It is the only remaining type
1455 var res
= self.resolve_for
(resolved_receiver
.mclass
.mclass_type
, resolved_receiver
, mmodule
, false)
1459 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1461 assert can_resolve_for
(mtype
, anchor
, mmodule
)
1462 #print "{class_name}: {self}/{mtype}/{anchor}?"
1464 if mtype
isa MGenericType and mtype
.mclass
== self.mclass
then
1465 var res
= mtype
.arguments
[self.rank
]
1466 if anchor
!= null and res
.need_anchor
then
1467 # Maybe the result can be resolved more if are bound to a final class
1468 var r2
= res
.anchor_to
(mmodule
, anchor
)
1469 if r2
isa MClassType and r2
.mclass
.kind
== enum_kind
then return r2
1474 # self is a parameter type of mtype (or of a super-class of mtype)
1475 # The point of the function it to get the bound of the virtual type that make sense for mtype
1476 # But because mtype is maybe a virtual/formal type, we need to get a real receiver first
1477 # FIXME: What happens here is far from clear. Thus this part must be validated and clarified
1478 var resolved_receiver
1479 if mtype
.need_anchor
then
1480 assert anchor
!= null
1481 resolved_receiver
= mtype
.resolve_for
(anchor
.mclass
.mclass_type
, anchor
, mmodule
, true)
1483 resolved_receiver
= mtype
1485 if resolved_receiver
isa MNullableType then resolved_receiver
= resolved_receiver
.mtype
1486 if resolved_receiver
isa MParameterType then
1487 assert resolved_receiver
.mclass
== anchor
.mclass
1488 resolved_receiver
= anchor
.arguments
[resolved_receiver
.rank
]
1489 if resolved_receiver
isa MNullableType then resolved_receiver
= resolved_receiver
.mtype
1491 assert resolved_receiver
isa MClassType # It is the only remaining type
1493 # Eh! The parameter is in the current class.
1494 # So we return the corresponding argument, no mater what!
1495 if resolved_receiver
.mclass
== self.mclass
then
1496 var res
= resolved_receiver
.arguments
[self.rank
]
1497 #print "{class_name}: {self}/{mtype}/{anchor} -> direct {res}"
1501 if resolved_receiver
.need_anchor
then
1502 assert anchor
!= null
1503 resolved_receiver
= resolved_receiver
.resolve_for
(anchor
, null, mmodule
, false)
1505 # Now, we can get the bound
1506 var verbatim_bound
= lookup_bound
(mmodule
, resolved_receiver
)
1507 # The bound is exactly as declared in the "type" property, so we must resolve it again
1508 var res
= verbatim_bound
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1510 #print "{class_name}: {self}/{mtype}/{anchor} -> indirect {res}"
1515 redef fun can_resolve_for
(mtype
, anchor
, mmodule
)
1517 if mtype
.need_anchor
then
1518 assert anchor
!= null
1519 mtype
= mtype
.anchor_to
(mmodule
, anchor
)
1521 return mtype
.collect_mclassdefs
(mmodule
).has
(mclass
.intro
)
1525 # A type prefixed with "nullable"
1529 # The base type of the nullable type
1532 redef fun model
do return self.mtype
.model
1536 self.to_s
= "nullable {mtype}"
1539 redef var to_s
: String is noinit
1541 redef var full_name
is lazy
do return "nullable {mtype.full_name}"
1543 redef var c_name
is lazy
do return "nullable__{mtype.c_name}"
1545 redef fun need_anchor
do return mtype
.need_anchor
1546 redef fun as_nullable
do return self
1547 redef fun as_notnullable
do return mtype
1548 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1550 var res
= self.mtype
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1551 return res
.as_nullable
1554 redef fun can_resolve_for
(mtype
, anchor
, mmodule
)
1556 return self.mtype
.can_resolve_for
(mtype
, anchor
, mmodule
)
1559 # Efficiently returns `mtype.lookup_fixed(mmodule, resolved_receiver).as_nullable`
1560 redef fun lookup_fixed
(mmodule
, resolved_receiver
)
1562 var t
= mtype
.lookup_fixed
(mmodule
, resolved_receiver
)
1563 if t
== mtype
then return self
1564 return t
.as_nullable
1567 redef fun depth
do return self.mtype
.depth
1569 redef fun length
do return self.mtype
.length
1571 redef fun collect_mclassdefs
(mmodule
)
1573 assert not self.need_anchor
1574 return self.mtype
.collect_mclassdefs
(mmodule
)
1577 redef fun collect_mclasses
(mmodule
)
1579 assert not self.need_anchor
1580 return self.mtype
.collect_mclasses
(mmodule
)
1583 redef fun collect_mtypes
(mmodule
)
1585 assert not self.need_anchor
1586 return self.mtype
.collect_mtypes
(mmodule
)
1590 # The type of the only value null
1592 # The is only one null type per model, see `MModel::null_type`.
1595 redef var model
: Model
1596 redef fun to_s
do return "null"
1597 redef fun full_name
do return "null"
1598 redef fun c_name
do return "null"
1599 redef fun as_nullable
do return self
1600 redef fun need_anchor
do return false
1601 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
) do return self
1602 redef fun can_resolve_for
(mtype
, anchor
, mmodule
) do return true
1604 redef fun collect_mclassdefs
(mmodule
) do return new HashSet[MClassDef]
1606 redef fun collect_mclasses
(mmodule
) do return new HashSet[MClass]
1608 redef fun collect_mtypes
(mmodule
) do return new HashSet[MClassType]
1611 # A signature of a method
1615 # The each parameter (in order)
1616 var mparameters
: Array[MParameter]
1618 # The return type (null for a procedure)
1619 var return_mtype
: nullable MType
1624 var t
= self.return_mtype
1625 if t
!= null then dmax
= t
.depth
1626 for p
in mparameters
do
1627 var d
= p
.mtype
.depth
1628 if d
> dmax
then dmax
= d
1636 var t
= self.return_mtype
1637 if t
!= null then res
+= t
.length
1638 for p
in mparameters
do
1639 res
+= p
.mtype
.length
1644 # REQUIRE: 1 <= mparameters.count p -> p.is_vararg
1647 var vararg_rank
= -1
1648 for i
in [0..mparameters
.length
[ do
1649 var parameter
= mparameters
[i
]
1650 if parameter
.is_vararg
then
1651 assert vararg_rank
== -1
1655 self.vararg_rank
= vararg_rank
1658 # The rank of the ellipsis (`...`) for vararg (starting from 0).
1659 # value is -1 if there is no vararg.
1660 # Example: for "(a: Int, b: Bool..., c: Char)" #-> vararg_rank=1
1661 var vararg_rank
: Int is noinit
1663 # The number or parameters
1664 fun arity
: Int do return mparameters
.length
1668 var b
= new FlatBuffer
1669 if not mparameters
.is_empty
then
1671 for i
in [0..mparameters
.length
[ do
1672 var mparameter
= mparameters
[i
]
1673 if i
> 0 then b
.append
(", ")
1674 b
.append
(mparameter
.name
)
1676 b
.append
(mparameter
.mtype
.to_s
)
1677 if mparameter
.is_vararg
then
1683 var ret
= self.return_mtype
1691 redef fun resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule, cleanup_virtual
: Bool): MSignature
1693 var params
= new Array[MParameter]
1694 for p
in self.mparameters
do
1695 params
.add
(p
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
))
1697 var ret
= self.return_mtype
1699 ret
= ret
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1701 var res
= new MSignature(params
, ret
)
1706 # A parameter in a signature
1710 # The name of the parameter
1711 redef var name
: String
1713 # The static type of the parameter
1716 # Is the parameter a vararg?
1722 return "{name}: {mtype}..."
1724 return "{name}: {mtype}"
1728 # Returns a new parameter with the `mtype` resolved.
1729 # See `MType::resolve_for` for details.
1730 fun resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule, cleanup_virtual
: Bool): MParameter
1732 if not self.mtype
.need_anchor
then return self
1733 var newtype
= self.mtype
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1734 var res
= new MParameter(self.name
, newtype
, self.is_vararg
)
1738 redef fun model
do return mtype
.model
1741 # A service (global property) that generalize method, attribute, etc.
1743 # `MProperty` are global to the model; it means that a `MProperty` is not bound
1744 # to a specific `MModule` nor a specific `MClass`.
1746 # A MProperty gather definitions (see `mpropdefs`) ; one for the introduction
1747 # and the other in subclasses and in refinements.
1749 # A `MProperty` is used to denotes services in polymorphic way (ie. independent
1750 # of any dynamic type).
1751 # For instance, a call site "x.foo" is associated to a `MProperty`.
1752 abstract class MProperty
1755 # The associated MPropDef subclass.
1756 # The two specialization hierarchy are symmetric.
1757 type MPROPDEF: MPropDef
1759 # The classdef that introduce the property
1760 # While a property is not bound to a specific module, or class,
1761 # the introducing mclassdef is used for naming and visibility
1762 var intro_mclassdef
: MClassDef
1764 # The (short) name of the property
1765 redef var name
: String
1767 # The canonical name of the property.
1769 # It is the short-`name` prefixed by the short-name of the class and the full-name of the module.
1770 # Example: "my_project::my_module::MyClass::my_method"
1771 redef var full_name
is lazy
do
1772 return "{intro_mclassdef.mmodule.namespace_for(visibility)}::{intro_mclassdef.mclass.name}::{name}"
1775 redef var c_name
is lazy
do
1776 # FIXME use `namespace_for`
1777 return "{intro_mclassdef.mmodule.c_name}__{intro_mclassdef.mclass.name.to_cmangle}__{name.to_cmangle}"
1780 # The visibility of the property
1781 var visibility
: MVisibility
1783 # Is the property usable as an initializer?
1784 var is_autoinit
= false is writable
1788 intro_mclassdef
.intro_mproperties
.add
(self)
1789 var model
= intro_mclassdef
.mmodule
.model
1790 model
.mproperties_by_name
.add_one
(name
, self)
1791 model
.mproperties
.add
(self)
1794 # All definitions of the property.
1795 # The first is the introduction,
1796 # The other are redefinitions (in refinements and in subclasses)
1797 var mpropdefs
= new Array[MPROPDEF]
1799 # The definition that introduces the property.
1801 # Warning: such a definition may not exist in the early life of the object.
1802 # In this case, the method will abort.
1803 var intro
: MPROPDEF is noinit
1805 redef fun model
do return intro
.model
1808 redef fun to_s
do return name
1810 # Return the most specific property definitions defined or inherited by a type.
1811 # The selection knows that refinement is stronger than specialization;
1812 # however, in case of conflict more than one property are returned.
1813 # If mtype does not know mproperty then an empty array is returned.
1815 # If you want the really most specific property, then look at `lookup_first_definition`
1817 # REQUIRE: `not mtype.need_anchor` to simplify the API (no `anchor` parameter)
1818 # ENSURE: `not mtype.has_mproperty(mmodule, self) == result.is_empty`
1819 fun lookup_definitions
(mmodule
: MModule, mtype
: MType): Array[MPROPDEF]
1821 assert not mtype
.need_anchor
1822 mtype
= mtype
.as_notnullable
1824 var cache
= self.lookup_definitions_cache
[mmodule
, mtype
]
1825 if cache
!= null then return cache
1827 #print "select prop {mproperty} for {mtype} in {self}"
1828 # First, select all candidates
1829 var candidates
= new Array[MPROPDEF]
1830 for mpropdef
in self.mpropdefs
do
1831 # If the definition is not imported by the module, then skip
1832 if not mmodule
.in_importation
<= mpropdef
.mclassdef
.mmodule
then continue
1833 # If the definition is not inherited by the type, then skip
1834 if not mtype
.is_subtype
(mmodule
, null, mpropdef
.mclassdef
.bound_mtype
) then continue
1836 candidates
.add
(mpropdef
)
1838 # Fast track for only one candidate
1839 if candidates
.length
<= 1 then
1840 self.lookup_definitions_cache
[mmodule
, mtype
] = candidates
1844 # Second, filter the most specific ones
1845 return select_most_specific
(mmodule
, candidates
)
1848 private var lookup_definitions_cache
= new HashMap2[MModule, MType, Array[MPROPDEF]]
1850 # Return the most specific property definitions inherited by a type.
1851 # The selection knows that refinement is stronger than specialization;
1852 # however, in case of conflict more than one property are returned.
1853 # If mtype does not know mproperty then an empty array is returned.
1855 # If you want the really most specific property, then look at `lookup_next_definition`
1857 # REQUIRE: `not mtype.need_anchor` to simplify the API (no `anchor` parameter)
1858 # ENSURE: `not mtype.has_mproperty(mmodule, self) implies result.is_empty`
1859 fun lookup_super_definitions
(mmodule
: MModule, mtype
: MType): Array[MPROPDEF]
1861 assert not mtype
.need_anchor
1862 mtype
= mtype
.as_notnullable
1864 # First, select all candidates
1865 var candidates
= new Array[MPROPDEF]
1866 for mpropdef
in self.mpropdefs
do
1867 # If the definition is not imported by the module, then skip
1868 if not mmodule
.in_importation
<= mpropdef
.mclassdef
.mmodule
then continue
1869 # If the definition is not inherited by the type, then skip
1870 if not mtype
.is_subtype
(mmodule
, null, mpropdef
.mclassdef
.bound_mtype
) then continue
1871 # If the definition is defined by the type, then skip (we want the super, so e skip the current)
1872 if mtype
== mpropdef
.mclassdef
.bound_mtype
and mmodule
== mpropdef
.mclassdef
.mmodule
then continue
1874 candidates
.add
(mpropdef
)
1876 # Fast track for only one candidate
1877 if candidates
.length
<= 1 then return candidates
1879 # Second, filter the most specific ones
1880 return select_most_specific
(mmodule
, candidates
)
1883 # Return an array containing olny the most specific property definitions
1884 # This is an helper function for `lookup_definitions` and `lookup_super_definitions`
1885 private fun select_most_specific
(mmodule
: MModule, candidates
: Array[MPROPDEF]): Array[MPROPDEF]
1887 var res
= new Array[MPROPDEF]
1888 for pd1
in candidates
do
1889 var cd1
= pd1
.mclassdef
1892 for pd2
in candidates
do
1893 if pd2
== pd1
then continue # do not compare with self!
1894 var cd2
= pd2
.mclassdef
1896 if c2
.mclass_type
== c1
.mclass_type
then
1897 if cd2
.mmodule
.in_importation
< cd1
.mmodule
then
1898 # cd2 refines cd1; therefore we skip pd1
1902 else if cd2
.bound_mtype
.is_subtype
(mmodule
, null, cd1
.bound_mtype
) and cd2
.bound_mtype
!= cd1
.bound_mtype
then
1903 # cd2 < cd1; therefore we skip pd1
1912 if res
.is_empty
then
1913 print
"All lost! {candidates.join(", ")}"
1914 # FIXME: should be abort!
1919 # Return the most specific definition in the linearization of `mtype`.
1921 # If you want to know the next properties in the linearization,
1922 # look at `MPropDef::lookup_next_definition`.
1924 # FIXME: the linearization is still unspecified
1926 # REQUIRE: `not mtype.need_anchor` to simplify the API (no `anchor` parameter)
1927 # REQUIRE: `mtype.has_mproperty(mmodule, self)`
1928 fun lookup_first_definition
(mmodule
: MModule, mtype
: MType): MPROPDEF
1930 return lookup_all_definitions
(mmodule
, mtype
).first
1933 # Return all definitions in a linearization order
1934 # Most specific first, most general last
1936 # REQUIRE: `not mtype.need_anchor` to simplify the API (no `anchor` parameter)
1937 # REQUIRE: `mtype.has_mproperty(mmodule, self)`
1938 fun lookup_all_definitions
(mmodule
: MModule, mtype
: MType): Array[MPROPDEF]
1940 mtype
= mtype
.as_notnullable
1942 var cache
= self.lookup_all_definitions_cache
[mmodule
, mtype
]
1943 if cache
!= null then return cache
1945 assert not mtype
.need_anchor
1946 assert mtype
.has_mproperty
(mmodule
, self)
1948 #print "select prop {mproperty} for {mtype} in {self}"
1949 # First, select all candidates
1950 var candidates
= new Array[MPROPDEF]
1951 for mpropdef
in self.mpropdefs
do
1952 # If the definition is not imported by the module, then skip
1953 if not mmodule
.in_importation
<= mpropdef
.mclassdef
.mmodule
then continue
1954 # If the definition is not inherited by the type, then skip
1955 if not mtype
.is_subtype
(mmodule
, null, mpropdef
.mclassdef
.bound_mtype
) then continue
1957 candidates
.add
(mpropdef
)
1959 # Fast track for only one candidate
1960 if candidates
.length
<= 1 then
1961 self.lookup_all_definitions_cache
[mmodule
, mtype
] = candidates
1965 mmodule
.linearize_mpropdefs
(candidates
)
1966 candidates
= candidates
.reversed
1967 self.lookup_all_definitions_cache
[mmodule
, mtype
] = candidates
1971 private var lookup_all_definitions_cache
= new HashMap2[MModule, MType, Array[MPROPDEF]]
1978 redef type MPROPDEF: MMethodDef
1980 # Is the property defined at the top_level of the module?
1981 # Currently such a property are stored in `Object`
1982 var is_toplevel
: Bool = false is writable
1984 # Is the property a constructor?
1985 # Warning, this property can be inherited by subclasses with or without being a constructor
1986 # therefore, you should use `is_init_for` the verify if the property is a legal constructor for a given class
1987 var is_init
: Bool = false is writable
1989 # The constructor is a (the) root init with empty signature but a set of initializers
1990 var is_root_init
: Bool = false is writable
1992 # Is the property a 'new' constructor?
1993 var is_new
: Bool = false is writable
1995 # Is the property a legal constructor for a given class?
1996 # As usual, visibility is not considered.
1997 # FIXME not implemented
1998 fun is_init_for
(mclass
: MClass): Bool
2004 # A global attribute
2008 redef type MPROPDEF: MAttributeDef
2012 # A global virtual type
2013 class MVirtualTypeProp
2016 redef type MPROPDEF: MVirtualTypeDef
2018 # The formal type associated to the virtual type property
2019 var mvirtualtype
= new MVirtualType(self)
2022 # A definition of a property (local property)
2024 # Unlike `MProperty`, a `MPropDef` is a local definition that belong to a
2025 # specific class definition (which belong to a specific module)
2026 abstract class MPropDef
2029 # The associated `MProperty` subclass.
2030 # the two specialization hierarchy are symmetric
2031 type MPROPERTY: MProperty
2034 type MPROPDEF: MPropDef
2036 # The class definition where the property definition is
2037 var mclassdef
: MClassDef
2039 # The associated global property
2040 var mproperty
: MPROPERTY
2042 # The origin of the definition
2043 var location
: Location
2047 mclassdef
.mpropdefs
.add
(self)
2048 mproperty
.mpropdefs
.add
(self)
2049 if mproperty
.intro_mclassdef
== mclassdef
then
2050 assert not isset mproperty
._intro
2051 mproperty
.intro
= self
2053 self.to_s
= "{mclassdef}#{mproperty}"
2056 # Actually the name of the `mproperty`
2057 redef fun name
do return mproperty
.name
2059 # The full-name of mpropdefs combine the information about the `classdef` and the `mproperty`.
2061 # Therefore the combination of identifiers is awful,
2062 # the worst case being
2064 # * a property "p::m::A::x"
2065 # * redefined in a refinement of a class "q::n::B"
2066 # * in a module "r::o"
2067 # * so "r::o#q::n::B#p::m::A::x"
2069 # Fortunately, the full-name is simplified when entities are repeated.
2070 # For the previous case, the simplest form is "p#A#x".
2071 redef var full_name
is lazy
do
2072 var res
= new FlatBuffer
2074 # The first part is the mclassdef. Worst case is "r::o#q::n::B"
2075 res
.append mclassdef
.full_name
2079 if mclassdef
.mclass
== mproperty
.intro_mclassdef
.mclass
then
2080 # intro are unambiguous in a class
2083 # Just try to simplify each part
2084 if mclassdef
.mmodule
.mproject
!= mproperty
.intro_mclassdef
.mmodule
.mproject
then
2085 # precise "p::m" only if "p" != "r"
2086 res
.append mproperty
.intro_mclassdef
.mmodule
.full_name
2088 else if mproperty
.visibility
<= private_visibility
then
2089 # Same project ("p"=="q"), but private visibility,
2090 # does the module part ("::m") need to be displayed
2091 if mclassdef
.mmodule
.namespace_for
(mclassdef
.mclass
.visibility
) != mproperty
.intro_mclassdef
.mmodule
.mproject
then
2093 res
.append mproperty
.intro_mclassdef
.mmodule
.name
2097 if mclassdef
.mclass
!= mproperty
.intro_mclassdef
.mclass
then
2098 # precise "B" only if not the same class than "A"
2099 res
.append mproperty
.intro_mclassdef
.name
2102 # Always use the property name "x"
2103 res
.append mproperty
.name
2108 redef var c_name
is lazy
do
2109 var res
= new FlatBuffer
2110 res
.append mclassdef
.c_name
2112 if mclassdef
.mclass
== mproperty
.intro_mclassdef
.mclass
then
2113 res
.append name
.to_cmangle
2115 if mclassdef
.mmodule
!= mproperty
.intro_mclassdef
.mmodule
then
2116 res
.append mproperty
.intro_mclassdef
.mmodule
.c_name
2119 if mclassdef
.mclass
!= mproperty
.intro_mclassdef
.mclass
then
2120 res
.append mproperty
.intro_mclassdef
.name
.to_cmangle
2123 res
.append mproperty
.name
.to_cmangle
2128 redef fun model
do return mclassdef
.model
2130 # Internal name combining the module, the class and the property
2131 # Example: "mymodule#MyClass#mymethod"
2132 redef var to_s
: String is noinit
2134 # Is self the definition that introduce the property?
2135 fun is_intro
: Bool do return mproperty
.intro
== self
2137 # Return the next definition in linearization of `mtype`.
2139 # This method is used to determine what method is called by a super.
2141 # REQUIRE: `not mtype.need_anchor`
2142 fun lookup_next_definition
(mmodule
: MModule, mtype
: MType): MPROPDEF
2144 assert not mtype
.need_anchor
2146 var mpropdefs
= self.mproperty
.lookup_all_definitions
(mmodule
, mtype
)
2147 var i
= mpropdefs
.iterator
2148 while i
.is_ok
and i
.item
!= self do i
.next
2149 assert has_property
: i
.is_ok
2151 assert has_next_property
: i
.is_ok
2156 # A local definition of a method
2160 redef type MPROPERTY: MMethod
2161 redef type MPROPDEF: MMethodDef
2163 # The signature attached to the property definition
2164 var msignature
: nullable MSignature = null is writable
2166 # The signature attached to the `new` call on a root-init
2167 # This is a concatenation of the signatures of the initializers
2169 # REQUIRE `mproperty.is_root_init == (new_msignature != null)`
2170 var new_msignature
: nullable MSignature = null is writable
2172 # List of initialisers to call in root-inits
2174 # They could be setters or attributes
2176 # REQUIRE `mproperty.is_root_init == (new_msignature != null)`
2177 var initializers
= new Array[MProperty]
2179 # Is the method definition abstract?
2180 var is_abstract
: Bool = false is writable
2182 # Is the method definition intern?
2183 var is_intern
= false is writable
2185 # Is the method definition extern?
2186 var is_extern
= false is writable
2188 # An optional constant value returned in functions.
2190 # Only some specific primitife value are accepted by engines.
2191 # Is used when there is no better implementation available.
2193 # Currently used only for the implementation of the `--define`
2194 # command-line option.
2195 # SEE: module `mixin`.
2196 var constant_value
: nullable Object = null is writable
2199 # A local definition of an attribute
2203 redef type MPROPERTY: MAttribute
2204 redef type MPROPDEF: MAttributeDef
2206 # The static type of the attribute
2207 var static_mtype
: nullable MType = null is writable
2210 # A local definition of a virtual type
2211 class MVirtualTypeDef
2214 redef type MPROPERTY: MVirtualTypeProp
2215 redef type MPROPDEF: MVirtualTypeDef
2217 # The bound of the virtual type
2218 var bound
: nullable MType = null is writable
2220 # Is the bound fixed?
2221 var is_fixed
= false is writable
2228 # * `interface_kind`
2232 # Note this class is basically an enum.
2233 # FIXME: use a real enum once user-defined enums are available
2235 redef var to_s
: String
2237 # Is a constructor required?
2240 # TODO: private init because enumeration.
2242 # Can a class of kind `self` specializes a class of kine `other`?
2243 fun can_specialize
(other
: MClassKind): Bool
2245 if other
== interface_kind
then return true # everybody can specialize interfaces
2246 if self == interface_kind
or self == enum_kind
then
2247 # no other case for interfaces
2249 else if self == extern_kind
then
2250 # only compatible with themselves
2251 return self == other
2252 else if other
== enum_kind
or other
== extern_kind
then
2253 # abstract_kind and concrete_kind are incompatible
2256 # remain only abstract_kind and concrete_kind
2261 # The class kind `abstract`
2262 fun abstract_kind
: MClassKind do return once
new MClassKind("abstract class", true)
2263 # The class kind `concrete`
2264 fun concrete_kind
: MClassKind do return once
new MClassKind("class", true)
2265 # The class kind `interface`
2266 fun interface_kind
: MClassKind do return once
new MClassKind("interface", false)
2267 # The class kind `enum`
2268 fun enum_kind
: MClassKind do return once
new MClassKind("enum", false)
2269 # The class kind `extern`
2270 fun extern_kind
: MClassKind do return once
new MClassKind("extern class", false)