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 if mclasses_by_name
.has_key
(name
) then
78 return mclasses_by_name
[name
]
84 # Collections of properties grouped by their short name
85 private var mproperties_by_name
= new MultiHashMap[String, MProperty]
87 # Return all properties named `name`.
89 # If such a property does not exist, null is returned
90 # (instead of an empty array)
92 # Visibility or modules are not considered
93 fun get_mproperties_by_name
(name
: String): nullable Array[MProperty]
95 if not mproperties_by_name
.has_key
(name
) then
98 return mproperties_by_name
[name
]
103 var null_type
= new MNullType(self)
105 # Build an ordered tree with from `concerns`
106 fun concerns_tree
(mconcerns
: Collection[MConcern]): ConcernsTree do
107 var seen
= new HashSet[MConcern]
108 var res
= new ConcernsTree
110 var todo
= new Array[MConcern]
111 todo
.add_all mconcerns
113 while not todo
.is_empty
do
115 if seen
.has
(c
) then continue
116 var pc
= c
.parent_concern
130 # An OrderedTree that can be easily refined for display purposes
132 super OrderedTree[MConcern]
136 # All the classes introduced in the module
137 var intro_mclasses
= new Array[MClass]
139 # All the class definitions of the module
140 # (introduction and refinement)
141 var mclassdefs
= new Array[MClassDef]
143 # Does the current module has a given class `mclass`?
144 # Return true if the mmodule introduces, refines or imports a class.
145 # Visibility is not considered.
146 fun has_mclass
(mclass
: MClass): Bool
148 return self.in_importation
<= mclass
.intro_mmodule
151 # Full hierarchy of introduced ans imported classes.
153 # Create a new hierarchy got by flattening the classes for the module
154 # and its imported modules.
155 # Visibility is not considered.
157 # Note: this function is expensive and is usually used for the main
158 # module of a program only. Do not use it to do you own subtype
160 fun flatten_mclass_hierarchy
: POSet[MClass]
162 var res
= self.flatten_mclass_hierarchy_cache
163 if res
!= null then return res
164 res
= new POSet[MClass]
165 for m
in self.in_importation
.greaters
do
166 for cd
in m
.mclassdefs
do
169 for s
in cd
.supertypes
do
170 res
.add_edge
(c
, s
.mclass
)
174 self.flatten_mclass_hierarchy_cache
= res
178 # Sort a given array of classes using the linearization order of the module
179 # The most general is first, the most specific is last
180 fun linearize_mclasses
(mclasses
: Array[MClass])
182 self.flatten_mclass_hierarchy
.sort
(mclasses
)
185 # Sort a given array of class definitions using the linearization order of the module
186 # the refinement link is stronger than the specialisation link
187 # The most general is first, the most specific is last
188 fun linearize_mclassdefs
(mclassdefs
: Array[MClassDef])
190 var sorter
= new MClassDefSorter(self)
191 sorter
.sort
(mclassdefs
)
194 # Sort a given array of property definitions using the linearization order of the module
195 # the refinement link is stronger than the specialisation link
196 # The most general is first, the most specific is last
197 fun linearize_mpropdefs
(mpropdefs
: Array[MPropDef])
199 var sorter
= new MPropDefSorter(self)
200 sorter
.sort
(mpropdefs
)
203 private var flatten_mclass_hierarchy_cache
: nullable POSet[MClass] = null
205 # The primitive type `Object`, the root of the class hierarchy
206 fun object_type
: MClassType
208 var res
= self.object_type_cache
209 if res
!= null then return res
210 res
= self.get_primitive_class
("Object").mclass_type
211 self.object_type_cache
= res
215 private var object_type_cache
: nullable MClassType
217 # The type `Pointer`, super class to all extern classes
218 var pointer_type
: MClassType = self.get_primitive_class
("Pointer").mclass_type
is lazy
220 # The primitive type `Bool`
221 fun bool_type
: MClassType
223 var res
= self.bool_type_cache
224 if res
!= null then return res
225 res
= self.get_primitive_class
("Bool").mclass_type
226 self.bool_type_cache
= res
230 private var bool_type_cache
: nullable MClassType
232 # The primitive type `Sys`, the main type of the program, if any
233 fun sys_type
: nullable MClassType
235 var clas
= self.model
.get_mclasses_by_name
("Sys")
236 if clas
== null then return null
237 return get_primitive_class
("Sys").mclass_type
240 # The primitive type `Finalizable`
241 # Used to tag classes that need to be finalized.
242 fun finalizable_type
: nullable MClassType
244 var clas
= self.model
.get_mclasses_by_name
("Finalizable")
245 if clas
== null then return null
246 return get_primitive_class
("Finalizable").mclass_type
249 # Force to get the primitive class named `name` or abort
250 fun get_primitive_class
(name
: String): MClass
252 var cla
= self.model
.get_mclasses_by_name
(name
)
254 if name
== "Bool" then
255 var c
= new MClass(self, name
, null, enum_kind
, public_visibility
)
256 var cladef
= new MClassDef(self, c
.mclass_type
, new Location(null, 0,0,0,0))
259 print
("Fatal Error: no primitive class {name}")
262 if cla
.length
!= 1 then
263 var msg
= "Fatal Error: more than one primitive class {name}:"
264 for c
in cla
do msg
+= " {c.full_name}"
271 # Try to get the primitive method named `name` on the type `recv`
272 fun try_get_primitive_method
(name
: String, recv
: MClass): nullable MMethod
274 var props
= self.model
.get_mproperties_by_name
(name
)
275 if props
== null then return null
276 var res
: nullable MMethod = null
277 for mprop
in props
do
278 assert mprop
isa MMethod
279 var intro
= mprop
.intro_mclassdef
280 for mclassdef
in recv
.mclassdefs
do
281 if not self.in_importation
.greaters
.has
(mclassdef
.mmodule
) then continue
282 if not mclassdef
.in_hierarchy
.greaters
.has
(intro
) then continue
285 else if res
!= mprop
then
286 print
("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}")
295 private class MClassDefSorter
297 redef type COMPARED: MClassDef
299 redef fun compare
(a
, b
)
303 if ca
!= cb
then return mmodule
.flatten_mclass_hierarchy
.compare
(ca
, cb
)
304 return mmodule
.model
.mclassdef_hierarchy
.compare
(a
, b
)
308 private class MPropDefSorter
310 redef type COMPARED: MPropDef
312 redef fun compare
(pa
, pb
)
318 if ca
!= cb
then return mmodule
.flatten_mclass_hierarchy
.compare
(ca
, cb
)
319 return mmodule
.model
.mclassdef_hierarchy
.compare
(a
, b
)
325 # `MClass` are global to the model; it means that a `MClass` is not bound to a
326 # specific `MModule`.
328 # This characteristic helps the reasoning about classes in a program since a
329 # single `MClass` object always denote the same class.
331 # The drawback is that classes (`MClass`) contain almost nothing by themselves.
332 # These do not really have properties nor belong to a hierarchy since the property and the
333 # hierarchy of a class depends of the refinement in the modules.
335 # Most services on classes require the precision of a module, and no one can asks what are
336 # the super-classes of a class nor what are properties of a class without precising what is
337 # the module considered.
339 # For instance, during the typing of a source-file, the module considered is the module of the file.
340 # eg. the question *is the method `foo` exists in the class `Bar`?* must be reformulated into
341 # *is the method `foo` exists in the class `Bar` in the current module?*
343 # During some global analysis, the module considered may be the main module of the program.
347 # The module that introduce the class
348 # While classes are not bound to a specific module,
349 # the introducing module is used for naming an visibility
350 var intro_mmodule
: MModule
352 # The short name of the class
353 # In Nit, the name of a class cannot evolve in refinements
354 redef var name
: String
356 # The canonical name of the class
357 # Example: `"owner::module::MyClass"`
358 fun full_name
: String
360 return "{self.intro_mmodule.full_name}::{name}"
363 # The number of generic formal parameters
364 # 0 if the class is not generic
365 var arity
: Int is noinit
367 # Each generic formal parameters in order.
368 # is empty if the class is not generic
369 var mparameters
= new Array[MParameterType]
371 protected fun setup_parameter_names
(parameter_names
: nullable Array[String]) is
374 if parameter_names
== null then
377 self.arity
= parameter_names
.length
380 # Create the formal parameter types
382 assert parameter_names
!= null
383 var mparametertypes
= new Array[MParameterType]
384 for i
in [0..arity
[ do
385 var mparametertype
= new MParameterType(self, i
, parameter_names
[i
])
386 mparametertypes
.add
(mparametertype
)
388 self.mparameters
= mparametertypes
389 var mclass_type
= new MGenericType(self, mparametertypes
)
390 self.mclass_type
= mclass_type
391 self.get_mtype_cache
.add
(mclass_type
)
393 self.mclass_type
= new MClassType(self)
397 # The kind of the class (interface, abstract class, etc.)
398 # In Nit, the kind of a class cannot evolve in refinements
401 # The visibility of the class
402 # In Nit, the visibility of a class cannot evolve in refinements
403 var visibility
: MVisibility
407 intro_mmodule
.intro_mclasses
.add
(self)
408 var model
= intro_mmodule
.model
409 model
.mclasses_by_name
.add_one
(name
, self)
410 model
.mclasses
.add
(self)
413 redef fun model
do return intro_mmodule
.model
415 # All class definitions (introduction and refinements)
416 var mclassdefs
= new Array[MClassDef]
419 redef fun to_s
do return self.name
421 # The definition that introduces the class.
423 # Warning: such a definition may not exist in the early life of the object.
424 # In this case, the method will abort.
425 var intro
: MClassDef is noinit
427 # Return the class `self` in the class hierarchy of the module `mmodule`.
429 # SEE: `MModule::flatten_mclass_hierarchy`
430 # REQUIRE: `mmodule.has_mclass(self)`
431 fun in_hierarchy
(mmodule
: MModule): POSetElement[MClass]
433 return mmodule
.flatten_mclass_hierarchy
[self]
436 # The principal static type of the class.
438 # For non-generic class, mclass_type is the only `MClassType` based
441 # For a generic class, the arguments are the formal parameters.
442 # i.e.: for the class Array[E:Object], the `mclass_type` is Array[E].
443 # If you want Array[Object] the see `MClassDef::bound_mtype`
445 # For generic classes, the mclass_type is also the way to get a formal
446 # generic parameter type.
448 # To get other types based on a generic class, see `get_mtype`.
450 # ENSURE: `mclass_type.mclass == self`
451 var mclass_type
: MClassType is noinit
453 # Return a generic type based on the class
454 # Is the class is not generic, then the result is `mclass_type`
456 # REQUIRE: `mtype_arguments.length == self.arity`
457 fun get_mtype
(mtype_arguments
: Array[MType]): MClassType
459 assert mtype_arguments
.length
== self.arity
460 if self.arity
== 0 then return self.mclass_type
461 for t
in self.get_mtype_cache
do
462 if t
.arguments
== mtype_arguments
then
466 var res
= new MGenericType(self, mtype_arguments
)
467 self.get_mtype_cache
.add res
471 private var get_mtype_cache
= new Array[MGenericType]
475 # A definition (an introduction or a refinement) of a class in a module
477 # A `MClassDef` is associated with an explicit (or almost) definition of a
478 # class. Unlike `MClass`, a `MClassDef` is a local definition that belong to
479 # a specific class and a specific module, and contains declarations like super-classes
482 # It is the class definitions that are the backbone of most things in the model:
483 # ClassDefs are defined with regard with other classdefs.
484 # Refinement and specialization are combined to produce a big poset called the `Model::mclassdef_hierarchy`.
486 # Moreover, the extension and the intention of types is defined by looking at the MClassDefs.
490 # The module where the definition is
493 # The associated `MClass`
494 var mclass
: MClass is noinit
496 # The bounded type associated to the mclassdef
498 # For a non-generic class, `bound_mtype` and `mclass.mclass_type`
502 # For the classdef Array[E: Object], the bound_mtype is Array[Object].
503 # If you want Array[E], then see `mclass.mclass_type`
505 # ENSURE: `bound_mtype.mclass == self.mclass`
506 var bound_mtype
: MClassType
508 # The origin of the definition
509 var location
: Location
511 # Internal name combining the module and the class
512 # Example: "mymodule#MyClass"
513 redef var to_s
: String is noinit
517 self.mclass
= bound_mtype
.mclass
518 mmodule
.mclassdefs
.add
(self)
519 mclass
.mclassdefs
.add
(self)
520 if mclass
.intro_mmodule
== mmodule
then
521 assert not isset mclass
._intro
524 self.to_s
= "{mmodule}#{mclass}"
527 # Actually the name of the `mclass`
528 redef fun name
do return mclass
.name
530 redef fun model
do return mmodule
.model
532 # All declared super-types
533 # FIXME: quite ugly but not better idea yet
534 var supertypes
= new Array[MClassType]
536 # Register some super-types for the class (ie "super SomeType")
538 # The hierarchy must not already be set
539 # REQUIRE: `self.in_hierarchy == null`
540 fun set_supertypes
(supertypes
: Array[MClassType])
542 assert unique_invocation
: self.in_hierarchy
== null
543 var mmodule
= self.mmodule
544 var model
= mmodule
.model
545 var mtype
= self.bound_mtype
547 for supertype
in supertypes
do
548 self.supertypes
.add
(supertype
)
550 # Register in full_type_specialization_hierarchy
551 model
.full_mtype_specialization_hierarchy
.add_edge
(mtype
, supertype
)
552 # Register in intro_type_specialization_hierarchy
553 if mclass
.intro_mmodule
== mmodule
and supertype
.mclass
.intro_mmodule
== mmodule
then
554 model
.intro_mtype_specialization_hierarchy
.add_edge
(mtype
, supertype
)
560 # Collect the super-types (set by set_supertypes) to build the hierarchy
562 # This function can only invoked once by class
563 # REQUIRE: `self.in_hierarchy == null`
564 # ENSURE: `self.in_hierarchy != null`
567 assert unique_invocation
: self.in_hierarchy
== null
568 var model
= mmodule
.model
569 var res
= model
.mclassdef_hierarchy
.add_node
(self)
570 self.in_hierarchy
= res
571 var mtype
= self.bound_mtype
573 # Here we need to connect the mclassdef to its pairs in the mclassdef_hierarchy
574 # The simpliest way is to attach it to collect_mclassdefs
575 for mclassdef
in mtype
.collect_mclassdefs
(mmodule
) do
576 res
.poset
.add_edge
(self, mclassdef
)
580 # The view of the class definition in `mclassdef_hierarchy`
581 var in_hierarchy
: nullable POSetElement[MClassDef] = null
583 # Is the definition the one that introduced `mclass`?
584 fun is_intro
: Bool do return mclass
.intro
== self
586 # All properties introduced by the classdef
587 var intro_mproperties
= new Array[MProperty]
589 # All property definitions in the class (introductions and redefinitions)
590 var mpropdefs
= new Array[MPropDef]
593 # A global static type
595 # MType are global to the model; it means that a `MType` is not bound to a
596 # specific `MModule`.
597 # This characteristic helps the reasoning about static types in a program
598 # since a single `MType` object always denote the same type.
600 # However, because a `MType` is global, it does not really have properties
601 # nor have subtypes to a hierarchy since the property and the class hierarchy
602 # depends of a module.
603 # Moreover, virtual types an formal generic parameter types also depends on
604 # a receiver to have sense.
606 # Therefore, most method of the types require a module and an anchor.
607 # The module is used to know what are the classes and the specialization
609 # The anchor is used to know what is the bound of the virtual types and formal
610 # generic parameter types.
612 # MType are not directly usable to get properties. See the `anchor_to` method
613 # and the `MClassType` class.
615 # FIXME: the order of the parameters is not the best. We mus pick on from:
616 # * foo(mmodule, anchor, othertype)
617 # * foo(othertype, anchor, mmodule)
618 # * foo(anchor, mmodule, othertype)
619 # * foo(othertype, mmodule, anchor)
623 redef fun name
do return to_s
625 # Return true if `self` is an subtype of `sup`.
626 # The typing is done using the standard typing policy of Nit.
628 # REQUIRE: `anchor == null implies not self.need_anchor and not sup.need_anchor`
629 # REQUIRE: `anchor != null implies self.can_resolve_for(anchor, null, mmodule) and sup.can_resolve_for(anchor, null, mmodule)`
630 fun is_subtype
(mmodule
: MModule, anchor
: nullable MClassType, sup
: MType): Bool
633 if sub
== sup
then return true
635 #print "1.is {sub} a {sup}? ===="
637 if anchor
== null then
638 assert not sub
.need_anchor
639 assert not sup
.need_anchor
641 # First, resolve the formal types to the simplest equivalent forms in the receiver
642 assert sub
.can_resolve_for
(anchor
, null, mmodule
)
643 sub
= sub
.lookup_fixed
(mmodule
, anchor
)
644 assert sup
.can_resolve_for
(anchor
, null, mmodule
)
645 sup
= sup
.lookup_fixed
(mmodule
, anchor
)
648 # Does `sup` accept null or not?
649 # Discard the nullable marker if it exists
650 var sup_accept_null
= false
651 if sup
isa MNullableType then
652 sup_accept_null
= true
654 else if sup
isa MNullType then
655 sup_accept_null
= true
658 # Can `sub` provide null or not?
659 # Thus we can match with `sup_accept_null`
660 # Also discard the nullable marker if it exists
661 if sub
isa MNullableType then
662 if not sup_accept_null
then return false
664 else if sub
isa MNullType then
665 return sup_accept_null
667 # Now the case of direct null and nullable is over.
669 # If `sub` is a formal type, then it is accepted if its bound is accepted
670 while sub
isa MParameterType or sub
isa MVirtualType do
671 #print "3.is {sub} a {sup}?"
673 # A unfixed formal type can only accept itself
674 if sub
== sup
then return true
676 assert anchor
!= null
677 sub
= sub
.lookup_bound
(mmodule
, anchor
)
679 #print "3.is {sub} a {sup}?"
681 # Manage the second layer of null/nullable
682 if sub
isa MNullableType then
683 if not sup_accept_null
then return false
685 else if sub
isa MNullType then
686 return sup_accept_null
689 #print "4.is {sub} a {sup}? <- no more resolution"
691 assert sub
isa MClassType # It is the only remaining type
693 # A unfixed formal type can only accept itself
694 if sup
isa MParameterType or sup
isa MVirtualType then
698 if sup
isa MNullType then
699 # `sup` accepts only null
703 assert sup
isa MClassType # It is the only remaining type
705 # Now both are MClassType, we need to dig
707 if sub
== sup
then return true
709 if anchor
== null then anchor
= sub
# UGLY: any anchor will work
710 var resolved_sub
= sub
.anchor_to
(mmodule
, anchor
)
711 var res
= resolved_sub
.collect_mclasses
(mmodule
).has
(sup
.mclass
)
712 if res
== false then return false
713 if not sup
isa MGenericType then return true
714 var sub2
= sub
.supertype_to
(mmodule
, anchor
, sup
.mclass
)
715 assert sub2
.mclass
== sup
.mclass
716 for i
in [0..sup
.mclass
.arity
[ do
717 var sub_arg
= sub2
.arguments
[i
]
718 var sup_arg
= sup
.arguments
[i
]
719 res
= sub_arg
.is_subtype
(mmodule
, anchor
, sup_arg
)
720 if res
== false then return false
725 # The base class type on which self is based
727 # This base type is used to get property (an internally to perform
728 # unsafe type comparison).
730 # Beware: some types (like null) are not based on a class thus this
733 # Basically, this function transform the virtual types and parameter
734 # types to their bounds.
738 # class B super A end
740 # class Y super X end
748 # Map[T,U] anchor_to H #-> Map[B,Y]
750 # Explanation of the example:
751 # In H, T is set to B, because "H super G[B]", and U is bound to Y,
752 # because "redef type U: Y". Therefore, Map[T, U] is bound to
755 # ENSURE: `not self.need_anchor implies result == self`
756 # ENSURE: `not result.need_anchor`
757 fun anchor_to
(mmodule
: MModule, anchor
: MClassType): MType
759 if not need_anchor
then return self
760 assert not anchor
.need_anchor
761 # Just resolve to the anchor and clear all the virtual types
762 var res
= self.resolve_for
(anchor
, null, mmodule
, true)
763 assert not res
.need_anchor
767 # Does `self` contain a virtual type or a formal generic parameter type?
768 # In order to remove those types, you usually want to use `anchor_to`.
769 fun need_anchor
: Bool do return true
771 # Return the supertype when adapted to a class.
773 # In Nit, for each super-class of a type, there is a equivalent super-type.
777 # class H[V] super G[V, Bool] end
778 # H[Int] supertype_to G #-> G[Int, Bool]
780 # REQUIRE: `super_mclass` is a super-class of `self`
781 # REQUIRE: `self.need_anchor implies anchor != null and self.can_resolve_for(anchor, null, mmodule)`
782 # ENSURE: `result.mclass = super_mclass`
783 fun supertype_to
(mmodule
: MModule, anchor
: nullable MClassType, super_mclass
: MClass): MClassType
785 if super_mclass
.arity
== 0 then return super_mclass
.mclass_type
786 if self isa MClassType and self.mclass
== super_mclass
then return self
788 if self.need_anchor
then
789 assert anchor
!= null
790 resolved_self
= self.anchor_to
(mmodule
, anchor
)
794 var supertypes
= resolved_self
.collect_mtypes
(mmodule
)
795 for supertype
in supertypes
do
796 if supertype
.mclass
== super_mclass
then
797 # FIXME: Here, we stop on the first goal. Should we check others and detect inconsistencies?
798 return supertype
.resolve_for
(self, anchor
, mmodule
, false)
804 # Replace formals generic types in self with resolved values in `mtype`
805 # If `cleanup_virtual` is true, then virtual types are also replaced
808 # This function returns self if `need_anchor` is false.
813 # class H[F] super G[F] end
816 # * Array[E].resolve_for(H[Int]) #-> Array[Int]
817 # * Array[E].resolve_for(G[Z], X[Int]) #-> Array[Z]
819 # Explanation of the example:
820 # * Array[E].need_anchor is true because there is a formal generic parameter type E
821 # * E makes sense for H[Int] because E is a formal parameter of G and H specialize G
822 # * Since "H[F] super G[F]", E is in fact F for H
823 # * More specifically, in H[Int], E is Int
824 # * So, in H[Int], Array[E] is Array[Int]
826 # This function is mainly used to inherit a signature.
827 # Because, unlike `anchor_to`, we do not want a full resolution of
828 # a type but only an adapted version of it.
833 # fun foo(e:E):E is abstract
835 # class B super A[Int] end
837 # The signature on foo is (e: E): E
838 # If we resolve the signature for B, we get (e:Int):Int
843 # fun foo(e:E) is abstract
847 # fun bar do a.foo(x) # <- x is here
850 # The first question is: is foo available on `a`?
852 # The static type of a is `A[Array[F]]`, that is an open type.
853 # in order to find a method `foo`, whe must look at a resolved type.
855 # A[Array[F]].anchor_to(B[nullable Object]) #-> A[Array[nullable Object]]
857 # the method `foo` exists in `A[Array[nullable Object]]`, therefore `foo` exists for `a`.
859 # The next question is: what is the accepted types for `x`?
861 # the signature of `foo` is `foo(e:E)`, thus we must resolve the type E
863 # E.resolve_for(A[Array[F]],B[nullable Object]) #-> Array[F]
865 # The resolution can be done because `E` make sense for the class A (see `can_resolve_for`)
867 # FIXME: the parameter `cleanup_virtual` is just a bad idea, but having
868 # two function instead of one seems also to be a bad idea.
870 # REQUIRE: `can_resolve_for(mtype, anchor, mmodule)`
871 # ENSURE: `not self.need_anchor implies result == self`
872 fun resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule, cleanup_virtual
: Bool): MType is abstract
874 # Resolve formal type to its verbatim bound.
875 # If the type is not formal, just return self
877 # The result is returned exactly as declared in the "type" property (verbatim).
878 # So it could be another formal type.
880 # In case of conflict, the method aborts.
881 fun lookup_bound
(mmodule
: MModule, resolved_receiver
: MType): MType do return self
883 # Resolve the formal type to its simplest equivalent form.
885 # Formal types are either free or fixed.
886 # When it is fixed, it means that it is equivalent with a simpler type.
887 # When a formal type is free, it means that it is only equivalent with itself.
888 # This method return the most simple equivalent type of `self`.
890 # This method is mainly used for subtype test in order to sanely compare fixed.
892 # By default, return self.
893 # See the redefinitions for specific behavior in each kind of type.
894 fun lookup_fixed
(mmodule
: MModule, resolved_receiver
: MType): MType do return self
896 # Can the type be resolved?
898 # In order to resolve open types, the formal types must make sence.
907 # * E.can_resolve_for(A[Int]) #-> true, E make sense in A
908 # * E.can_resolve_for(B[Int]) #-> false, E does not make sense in B
909 # * B[E].can_resolve_for(A[F], B[Object]) #-> true,
910 # B[E] is a red hearing only the E is important,
913 # REQUIRE: `anchor != null implies not anchor.need_anchor`
914 # REQUIRE: `mtype.need_anchor implies anchor != null and mtype.can_resolve_for(anchor, null, mmodule)`
915 # ENSURE: `not self.need_anchor implies result == true`
916 fun can_resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule): Bool is abstract
918 # Return the nullable version of the type
919 # If the type is already nullable then self is returned
920 fun as_nullable
: MType
922 var res
= self.as_nullable_cache
923 if res
!= null then return res
924 res
= new MNullableType(self)
925 self.as_nullable_cache
= res
929 # Return the not nullable version of the type
930 # Is the type is already not nullable, then self is returned.
932 # Note: this just remove the `nullable` notation, but the result can still contains null.
933 # For instance if `self isa MNullType` or self is a formal type bounded by a nullable type.
934 fun as_notnullable
: MType
939 private var as_nullable_cache
: nullable MType = null
942 # The depth of the type seen as a tree.
949 # Formal types have a depth of 1.
955 # The length of the type seen as a tree.
962 # Formal types have a length of 1.
968 # Compute all the classdefs inherited/imported.
969 # The returned set contains:
970 # * the class definitions from `mmodule` and its imported modules
971 # * the class definitions of this type and its super-types
973 # This function is used mainly internally.
975 # REQUIRE: `not self.need_anchor`
976 fun collect_mclassdefs
(mmodule
: MModule): Set[MClassDef] is abstract
978 # Compute all the super-classes.
979 # This function is used mainly internally.
981 # REQUIRE: `not self.need_anchor`
982 fun collect_mclasses
(mmodule
: MModule): Set[MClass] is abstract
984 # Compute all the declared super-types.
985 # Super-types are returned as declared in the classdefs (verbatim).
986 # This function is used mainly internally.
988 # REQUIRE: `not self.need_anchor`
989 fun collect_mtypes
(mmodule
: MModule): Set[MClassType] is abstract
991 # Is the property in self for a given module
992 # This method does not filter visibility or whatever
994 # REQUIRE: `not self.need_anchor`
995 fun has_mproperty
(mmodule
: MModule, mproperty
: MProperty): Bool
997 assert not self.need_anchor
998 return self.collect_mclassdefs
(mmodule
).has
(mproperty
.intro_mclassdef
)
1002 # A type based on a class.
1004 # `MClassType` have properties (see `has_mproperty`).
1008 # The associated class
1011 redef fun model
do return self.mclass
.intro_mmodule
.model
1013 # TODO: private init because strongly bounded to its mclass. see `mclass.mclass_type`
1015 # The formal arguments of the type
1016 # ENSURE: `result.length == self.mclass.arity`
1017 var arguments
= new Array[MType]
1019 redef fun to_s
do return mclass
.to_s
1021 redef fun need_anchor
do return false
1023 redef fun anchor_to
(mmodule
: MModule, anchor
: MClassType): MClassType
1025 return super.as(MClassType)
1028 redef fun resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule, cleanup_virtual
: Bool): MClassType do return self
1030 redef fun can_resolve_for
(mtype
, anchor
, mmodule
) do return true
1032 redef fun collect_mclassdefs
(mmodule
)
1034 assert not self.need_anchor
1035 var cache
= self.collect_mclassdefs_cache
1036 if not cache
.has_key
(mmodule
) then
1037 self.collect_things
(mmodule
)
1039 return cache
[mmodule
]
1042 redef fun collect_mclasses
(mmodule
)
1044 assert not self.need_anchor
1045 var cache
= self.collect_mclasses_cache
1046 if not cache
.has_key
(mmodule
) then
1047 self.collect_things
(mmodule
)
1049 return cache
[mmodule
]
1052 redef fun collect_mtypes
(mmodule
)
1054 assert not self.need_anchor
1055 var cache
= self.collect_mtypes_cache
1056 if not cache
.has_key
(mmodule
) then
1057 self.collect_things
(mmodule
)
1059 return cache
[mmodule
]
1062 # common implementation for `collect_mclassdefs`, `collect_mclasses`, and `collect_mtypes`.
1063 private fun collect_things
(mmodule
: MModule)
1065 var res
= new HashSet[MClassDef]
1066 var seen
= new HashSet[MClass]
1067 var types
= new HashSet[MClassType]
1068 seen
.add
(self.mclass
)
1069 var todo
= [self.mclass
]
1070 while not todo
.is_empty
do
1071 var mclass
= todo
.pop
1072 #print "process {mclass}"
1073 for mclassdef
in mclass
.mclassdefs
do
1074 if not mmodule
.in_importation
<= mclassdef
.mmodule
then continue
1075 #print " process {mclassdef}"
1077 for supertype
in mclassdef
.supertypes
do
1078 types
.add
(supertype
)
1079 var superclass
= supertype
.mclass
1080 if seen
.has
(superclass
) then continue
1081 #print " add {superclass}"
1082 seen
.add
(superclass
)
1083 todo
.add
(superclass
)
1087 collect_mclassdefs_cache
[mmodule
] = res
1088 collect_mclasses_cache
[mmodule
] = seen
1089 collect_mtypes_cache
[mmodule
] = types
1092 private var collect_mclassdefs_cache
= new HashMap[MModule, Set[MClassDef]]
1093 private var collect_mclasses_cache
= new HashMap[MModule, Set[MClass]]
1094 private var collect_mtypes_cache
= new HashMap[MModule, Set[MClassType]]
1098 # A type based on a generic class.
1099 # A generic type a just a class with additional formal generic arguments.
1105 # TODO: private init because strongly bounded to its mclass. see `mclass.get_mtype`
1109 assert self.mclass
.arity
== arguments
.length
1111 self.need_anchor
= false
1112 for t
in arguments
do
1113 if t
.need_anchor
then
1114 self.need_anchor
= true
1119 self.to_s
= "{mclass}[{arguments.join(", ")}]"
1122 # Recursively print the type of the arguments within brackets.
1123 # Example: `"Map[String, List[Int]]"`
1124 redef var to_s
: String is noinit
1126 redef var need_anchor
: Bool is noinit
1128 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1130 if not need_anchor
then return self
1131 assert can_resolve_for
(mtype
, anchor
, mmodule
)
1132 var types
= new Array[MType]
1133 for t
in arguments
do
1134 types
.add
(t
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
))
1136 return mclass
.get_mtype
(types
)
1139 redef fun can_resolve_for
(mtype
, anchor
, mmodule
)
1141 if not need_anchor
then return true
1142 for t
in arguments
do
1143 if not t
.can_resolve_for
(mtype
, anchor
, mmodule
) then return false
1152 for a
in self.arguments
do
1154 if d
> dmax
then dmax
= d
1162 for a
in self.arguments
do
1169 # A virtual formal type.
1173 # The property associated with the type.
1174 # Its the definitions of this property that determine the bound or the virtual type.
1175 var mproperty
: MVirtualTypeProp
1177 redef fun model
do return self.mproperty
.intro_mclassdef
.mmodule
.model
1179 redef fun lookup_bound
(mmodule
: MModule, resolved_receiver
: MType): MType
1181 return lookup_single_definition
(mmodule
, resolved_receiver
).bound
.as(not null)
1184 private fun lookup_single_definition
(mmodule
: MModule, resolved_receiver
: MType): MVirtualTypeDef
1186 assert not resolved_receiver
.need_anchor
1187 var props
= self.mproperty
.lookup_definitions
(mmodule
, resolved_receiver
)
1188 if props
.is_empty
then
1190 else if props
.length
== 1 then
1193 var types
= new ArraySet[MType]
1194 var res
= props
.first
1196 types
.add
(p
.bound
.as(not null))
1197 if not res
.is_fixed
then res
= p
1199 if types
.length
== 1 then
1205 # A VT is fixed when:
1206 # * the VT is (re-)defined with the annotation `is fixed`
1207 # * the VT is (indirectly) bound to an enum class (see `enum_kind`) since there is no subtype possible
1208 # * the receiver is an enum class since there is no subtype possible
1209 redef fun lookup_fixed
(mmodule
: MModule, resolved_receiver
: MType): MType
1211 assert not resolved_receiver
.need_anchor
1212 resolved_receiver
= resolved_receiver
.as_notnullable
1213 assert resolved_receiver
isa MClassType # It is the only remaining type
1215 var prop
= lookup_single_definition
(mmodule
, resolved_receiver
)
1216 var res
= prop
.bound
.as(not null)
1218 # Recursively lookup the fixed result
1219 res
= res
.lookup_fixed
(mmodule
, resolved_receiver
)
1221 # 1. For a fixed VT, return the resolved bound
1222 if prop
.is_fixed
then return res
1224 # 2. For a enum boud, return the bound
1225 if res
isa MClassType and res
.mclass
.kind
== enum_kind
then return res
1227 # 3. for a enum receiver return the bound
1228 if resolved_receiver
.mclass
.kind
== enum_kind
then return res
1233 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1235 if not cleanup_virtual
then return self
1236 assert can_resolve_for
(mtype
, anchor
, mmodule
)
1237 # self is a virtual type declared (or inherited) in mtype
1238 # The point of the function it to get the bound of the virtual type that make sense for mtype
1239 # But because mtype is maybe a virtual/formal type, we need to get a real receiver first
1240 #print "{class_name}: {self}/{mtype}/{anchor}?"
1241 var resolved_receiver
1242 if mtype
.need_anchor
then
1243 assert anchor
!= null
1244 resolved_receiver
= mtype
.resolve_for
(anchor
, null, mmodule
, true)
1246 resolved_receiver
= mtype
1248 # Now, we can get the bound
1249 var verbatim_bound
= lookup_bound
(mmodule
, resolved_receiver
)
1250 # The bound is exactly as declared in the "type" property, so we must resolve it again
1251 var res
= verbatim_bound
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1256 redef fun can_resolve_for
(mtype
, anchor
, mmodule
)
1258 if mtype
.need_anchor
then
1259 assert anchor
!= null
1260 mtype
= mtype
.anchor_to
(mmodule
, anchor
)
1262 return mtype
.has_mproperty
(mmodule
, mproperty
)
1265 redef fun to_s
do return self.mproperty
.to_s
1268 # The type associated to a formal parameter generic type of a class
1270 # Each parameter type is associated to a specific class.
1271 # It means that all refinements of a same class "share" the parameter type,
1272 # but that a generic subclass has its own parameter types.
1274 # However, in the sense of the meta-model, a parameter type of a class is
1275 # a valid type in a subclass. The "in the sense of the meta-model" is
1276 # important because, in the Nit language, the programmer cannot refers
1277 # directly to the parameter types of the super-classes.
1281 # fun e: E is abstract
1286 # In the class definition B[F], `F` is a valid type but `E` is not.
1287 # However, `self.e` is a valid method call, and the signature of `e` is
1290 # Note that parameter types are shared among class refinements.
1291 # Therefore parameter only have an internal name (see `to_s` for details).
1292 class MParameterType
1295 # The generic class where the parameter belong
1298 redef fun model
do return self.mclass
.intro_mmodule
.model
1300 # The position of the parameter (0 for the first parameter)
1301 # FIXME: is `position` a better name?
1306 redef fun to_s
do return name
1308 redef fun lookup_bound
(mmodule
: MModule, resolved_receiver
: MType): MType
1310 assert not resolved_receiver
.need_anchor
1311 resolved_receiver
= resolved_receiver
.as_notnullable
1312 assert resolved_receiver
isa MClassType # It is the only remaining type
1313 var goalclass
= self.mclass
1314 if resolved_receiver
.mclass
== goalclass
then
1315 return resolved_receiver
.arguments
[self.rank
]
1317 var supertypes
= resolved_receiver
.collect_mtypes
(mmodule
)
1318 for t
in supertypes
do
1319 if t
.mclass
== goalclass
then
1320 # Yeah! c specialize goalclass with a "super `t'". So the question is what is the argument of f
1321 # FIXME: Here, we stop on the first goal. Should we check others and detect inconsistencies?
1322 var res
= t
.arguments
[self.rank
]
1329 # A PT is fixed when:
1330 # * Its bound is a enum class (see `enum_kind`).
1331 # The PT is just useless, but it is still a case.
1332 # * More usually, the `resolved_receiver` is a subclass of `self.mclass`,
1333 # so it is necessarily fixed in a `super` clause, either with a normal type
1334 # or with another PT.
1335 # See `resolve_for` for examples about related issues.
1336 redef fun lookup_fixed
(mmodule
: MModule, resolved_receiver
: MType): MType
1338 assert not resolved_receiver
.need_anchor
1339 resolved_receiver
= resolved_receiver
.as_notnullable
1340 assert resolved_receiver
isa MClassType # It is the only remaining type
1341 var res
= self.resolve_for
(resolved_receiver
.mclass
.mclass_type
, resolved_receiver
, mmodule
, false)
1345 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1347 assert can_resolve_for
(mtype
, anchor
, mmodule
)
1348 #print "{class_name}: {self}/{mtype}/{anchor}?"
1350 if mtype
isa MGenericType and mtype
.mclass
== self.mclass
then
1351 var res
= mtype
.arguments
[self.rank
]
1352 if anchor
!= null and res
.need_anchor
then
1353 # Maybe the result can be resolved more if are bound to a final class
1354 var r2
= res
.anchor_to
(mmodule
, anchor
)
1355 if r2
isa MClassType and r2
.mclass
.kind
== enum_kind
then return r2
1360 # self is a parameter type of mtype (or of a super-class of mtype)
1361 # The point of the function it to get the bound of the virtual type that make sense for mtype
1362 # But because mtype is maybe a virtual/formal type, we need to get a real receiver first
1363 # FIXME: What happens here is far from clear. Thus this part must be validated and clarified
1364 var resolved_receiver
1365 if mtype
.need_anchor
then
1366 assert anchor
!= null
1367 resolved_receiver
= mtype
.resolve_for
(anchor
.mclass
.mclass_type
, anchor
, mmodule
, true)
1369 resolved_receiver
= mtype
1371 if resolved_receiver
isa MNullableType then resolved_receiver
= resolved_receiver
.mtype
1372 if resolved_receiver
isa MParameterType then
1373 assert resolved_receiver
.mclass
== anchor
.mclass
1374 resolved_receiver
= anchor
.arguments
[resolved_receiver
.rank
]
1375 if resolved_receiver
isa MNullableType then resolved_receiver
= resolved_receiver
.mtype
1377 assert resolved_receiver
isa MClassType # It is the only remaining type
1379 # Eh! The parameter is in the current class.
1380 # So we return the corresponding argument, no mater what!
1381 if resolved_receiver
.mclass
== self.mclass
then
1382 var res
= resolved_receiver
.arguments
[self.rank
]
1383 #print "{class_name}: {self}/{mtype}/{anchor} -> direct {res}"
1387 if resolved_receiver
.need_anchor
then
1388 assert anchor
!= null
1389 resolved_receiver
= resolved_receiver
.resolve_for
(anchor
, null, mmodule
, false)
1391 # Now, we can get the bound
1392 var verbatim_bound
= lookup_bound
(mmodule
, resolved_receiver
)
1393 # The bound is exactly as declared in the "type" property, so we must resolve it again
1394 var res
= verbatim_bound
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1396 #print "{class_name}: {self}/{mtype}/{anchor} -> indirect {res}"
1401 redef fun can_resolve_for
(mtype
, anchor
, mmodule
)
1403 if mtype
.need_anchor
then
1404 assert anchor
!= null
1405 mtype
= mtype
.anchor_to
(mmodule
, anchor
)
1407 return mtype
.collect_mclassdefs
(mmodule
).has
(mclass
.intro
)
1411 # A type prefixed with "nullable"
1415 # The base type of the nullable type
1418 redef fun model
do return self.mtype
.model
1422 self.to_s
= "nullable {mtype}"
1425 redef var to_s
: String is noinit
1427 redef fun need_anchor
do return mtype
.need_anchor
1428 redef fun as_nullable
do return self
1429 redef fun as_notnullable
do return mtype
1430 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1432 var res
= self.mtype
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1433 return res
.as_nullable
1436 redef fun can_resolve_for
(mtype
, anchor
, mmodule
)
1438 return self.mtype
.can_resolve_for
(mtype
, anchor
, mmodule
)
1441 # Efficiently returns `mtype.lookup_fixed(mmodule, resolved_receiver).as_nullable`
1442 redef fun lookup_fixed
(mmodule
, resolved_receiver
)
1444 var t
= mtype
.lookup_fixed
(mmodule
, resolved_receiver
)
1445 if t
== mtype
then return self
1446 return t
.as_nullable
1449 redef fun depth
do return self.mtype
.depth
1451 redef fun length
do return self.mtype
.length
1453 redef fun collect_mclassdefs
(mmodule
)
1455 assert not self.need_anchor
1456 return self.mtype
.collect_mclassdefs
(mmodule
)
1459 redef fun collect_mclasses
(mmodule
)
1461 assert not self.need_anchor
1462 return self.mtype
.collect_mclasses
(mmodule
)
1465 redef fun collect_mtypes
(mmodule
)
1467 assert not self.need_anchor
1468 return self.mtype
.collect_mtypes
(mmodule
)
1472 # The type of the only value null
1474 # The is only one null type per model, see `MModel::null_type`.
1477 redef var model
: Model
1478 redef fun to_s
do return "null"
1479 redef fun as_nullable
do return self
1480 redef fun need_anchor
do return false
1481 redef fun resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
) do return self
1482 redef fun can_resolve_for
(mtype
, anchor
, mmodule
) do return true
1484 redef fun collect_mclassdefs
(mmodule
) do return new HashSet[MClassDef]
1486 redef fun collect_mclasses
(mmodule
) do return new HashSet[MClass]
1488 redef fun collect_mtypes
(mmodule
) do return new HashSet[MClassType]
1491 # A signature of a method
1495 # The each parameter (in order)
1496 var mparameters
: Array[MParameter]
1498 # The return type (null for a procedure)
1499 var return_mtype
: nullable MType
1504 var t
= self.return_mtype
1505 if t
!= null then dmax
= t
.depth
1506 for p
in mparameters
do
1507 var d
= p
.mtype
.depth
1508 if d
> dmax
then dmax
= d
1516 var t
= self.return_mtype
1517 if t
!= null then res
+= t
.length
1518 for p
in mparameters
do
1519 res
+= p
.mtype
.length
1524 # REQUIRE: 1 <= mparameters.count p -> p.is_vararg
1527 var vararg_rank
= -1
1528 for i
in [0..mparameters
.length
[ do
1529 var parameter
= mparameters
[i
]
1530 if parameter
.is_vararg
then
1531 assert vararg_rank
== -1
1535 self.vararg_rank
= vararg_rank
1538 # The rank of the ellipsis (`...`) for vararg (starting from 0).
1539 # value is -1 if there is no vararg.
1540 # Example: for "(a: Int, b: Bool..., c: Char)" #-> vararg_rank=1
1541 var vararg_rank
: Int is noinit
1543 # The number or parameters
1544 fun arity
: Int do return mparameters
.length
1548 var b
= new FlatBuffer
1549 if not mparameters
.is_empty
then
1551 for i
in [0..mparameters
.length
[ do
1552 var mparameter
= mparameters
[i
]
1553 if i
> 0 then b
.append
(", ")
1554 b
.append
(mparameter
.name
)
1556 b
.append
(mparameter
.mtype
.to_s
)
1557 if mparameter
.is_vararg
then
1563 var ret
= self.return_mtype
1571 redef fun resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule, cleanup_virtual
: Bool): MSignature
1573 var params
= new Array[MParameter]
1574 for p
in self.mparameters
do
1575 params
.add
(p
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
))
1577 var ret
= self.return_mtype
1579 ret
= ret
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1581 var res
= new MSignature(params
, ret
)
1586 # A parameter in a signature
1590 # The name of the parameter
1591 redef var name
: String
1593 # The static type of the parameter
1596 # Is the parameter a vararg?
1602 return "{name}: {mtype}..."
1604 return "{name}: {mtype}"
1608 fun resolve_for
(mtype
: MType, anchor
: nullable MClassType, mmodule
: MModule, cleanup_virtual
: Bool): MParameter
1610 if not self.mtype
.need_anchor
then return self
1611 var newtype
= self.mtype
.resolve_for
(mtype
, anchor
, mmodule
, cleanup_virtual
)
1612 var res
= new MParameter(self.name
, newtype
, self.is_vararg
)
1616 redef fun model
do return mtype
.model
1619 # A service (global property) that generalize method, attribute, etc.
1621 # `MProperty` are global to the model; it means that a `MProperty` is not bound
1622 # to a specific `MModule` nor a specific `MClass`.
1624 # A MProperty gather definitions (see `mpropdefs`) ; one for the introduction
1625 # and the other in subclasses and in refinements.
1627 # A `MProperty` is used to denotes services in polymorphic way (ie. independent
1628 # of any dynamic type).
1629 # For instance, a call site "x.foo" is associated to a `MProperty`.
1630 abstract class MProperty
1633 # The associated MPropDef subclass.
1634 # The two specialization hierarchy are symmetric.
1635 type MPROPDEF: MPropDef
1637 # The classdef that introduce the property
1638 # While a property is not bound to a specific module, or class,
1639 # the introducing mclassdef is used for naming and visibility
1640 var intro_mclassdef
: MClassDef
1642 # The (short) name of the property
1643 redef var name
: String
1645 # The canonical name of the property
1646 # Example: "owner::my_module::MyClass::my_method"
1647 fun full_name
: String
1649 return "{self.intro_mclassdef.mmodule.full_name}::{self.intro_mclassdef.mclass.name}::{name}"
1652 # The visibility of the property
1653 var visibility
: MVisibility
1657 intro_mclassdef
.intro_mproperties
.add
(self)
1658 var model
= intro_mclassdef
.mmodule
.model
1659 model
.mproperties_by_name
.add_one
(name
, self)
1660 model
.mproperties
.add
(self)
1663 # All definitions of the property.
1664 # The first is the introduction,
1665 # The other are redefinitions (in refinements and in subclasses)
1666 var mpropdefs
= new Array[MPROPDEF]
1668 # The definition that introduces the property.
1670 # Warning: such a definition may not exist in the early life of the object.
1671 # In this case, the method will abort.
1672 var intro
: MPROPDEF is noinit
1674 redef fun model
do return intro
.model
1677 redef fun to_s
do return name
1679 # Return the most specific property definitions defined or inherited by a type.
1680 # The selection knows that refinement is stronger than specialization;
1681 # however, in case of conflict more than one property are returned.
1682 # If mtype does not know mproperty then an empty array is returned.
1684 # If you want the really most specific property, then look at `lookup_first_definition`
1685 fun lookup_definitions
(mmodule
: MModule, mtype
: MType): Array[MPROPDEF]
1687 assert not mtype
.need_anchor
1688 mtype
= mtype
.as_notnullable
1690 var cache
= self.lookup_definitions_cache
[mmodule
, mtype
]
1691 if cache
!= null then return cache
1693 #print "select prop {mproperty} for {mtype} in {self}"
1694 # First, select all candidates
1695 var candidates
= new Array[MPROPDEF]
1696 for mpropdef
in self.mpropdefs
do
1697 # If the definition is not imported by the module, then skip
1698 if not mmodule
.in_importation
<= mpropdef
.mclassdef
.mmodule
then continue
1699 # If the definition is not inherited by the type, then skip
1700 if not mtype
.is_subtype
(mmodule
, null, mpropdef
.mclassdef
.bound_mtype
) then continue
1702 candidates
.add
(mpropdef
)
1704 # Fast track for only one candidate
1705 if candidates
.length
<= 1 then
1706 self.lookup_definitions_cache
[mmodule
, mtype
] = candidates
1710 # Second, filter the most specific ones
1711 return select_most_specific
(mmodule
, candidates
)
1714 private var lookup_definitions_cache
= new HashMap2[MModule, MType, Array[MPROPDEF]]
1716 # Return the most specific property definitions inherited by a type.
1717 # The selection knows that refinement is stronger than specialization;
1718 # however, in case of conflict more than one property are returned.
1719 # If mtype does not know mproperty then an empty array is returned.
1721 # If you want the really most specific property, then look at `lookup_next_definition`
1723 # FIXME: Move to `MPropDef`?
1724 fun lookup_super_definitions
(mmodule
: MModule, mtype
: MType): Array[MPROPDEF]
1726 assert not mtype
.need_anchor
1727 mtype
= mtype
.as_notnullable
1729 # First, select all candidates
1730 var candidates
= new Array[MPROPDEF]
1731 for mpropdef
in self.mpropdefs
do
1732 # If the definition is not imported by the module, then skip
1733 if not mmodule
.in_importation
<= mpropdef
.mclassdef
.mmodule
then continue
1734 # If the definition is not inherited by the type, then skip
1735 if not mtype
.is_subtype
(mmodule
, null, mpropdef
.mclassdef
.bound_mtype
) then continue
1736 # If the definition is defined by the type, then skip (we want the super, so e skip the current)
1737 if mtype
== mpropdef
.mclassdef
.bound_mtype
and mmodule
== mpropdef
.mclassdef
.mmodule
then continue
1739 candidates
.add
(mpropdef
)
1741 # Fast track for only one candidate
1742 if candidates
.length
<= 1 then return candidates
1744 # Second, filter the most specific ones
1745 return select_most_specific
(mmodule
, candidates
)
1748 # Return an array containing olny the most specific property definitions
1749 # This is an helper function for `lookup_definitions` and `lookup_super_definitions`
1750 private fun select_most_specific
(mmodule
: MModule, candidates
: Array[MPROPDEF]): Array[MPROPDEF]
1752 var res
= new Array[MPROPDEF]
1753 for pd1
in candidates
do
1754 var cd1
= pd1
.mclassdef
1757 for pd2
in candidates
do
1758 if pd2
== pd1
then continue # do not compare with self!
1759 var cd2
= pd2
.mclassdef
1761 if c2
.mclass_type
== c1
.mclass_type
then
1762 if cd2
.mmodule
.in_importation
< cd1
.mmodule
then
1763 # cd2 refines cd1; therefore we skip pd1
1767 else if cd2
.bound_mtype
.is_subtype
(mmodule
, null, cd1
.bound_mtype
) and cd2
.bound_mtype
!= cd1
.bound_mtype
then
1768 # cd2 < cd1; therefore we skip pd1
1777 if res
.is_empty
then
1778 print
"All lost! {candidates.join(", ")}"
1779 # FIXME: should be abort!
1784 # Return the most specific definition in the linearization of `mtype`.
1786 # If you want to know the next properties in the linearization,
1787 # look at `MPropDef::lookup_next_definition`.
1789 # FIXME: the linearization is still unspecified
1791 # REQUIRE: `not mtype.need_anchor`
1792 # REQUIRE: `mtype.has_mproperty(mmodule, self)`
1793 fun lookup_first_definition
(mmodule
: MModule, mtype
: MType): MPROPDEF
1795 assert mtype
.has_mproperty
(mmodule
, self)
1796 return lookup_all_definitions
(mmodule
, mtype
).first
1799 # Return all definitions in a linearization order
1800 # Most specific first, most general last
1801 fun lookup_all_definitions
(mmodule
: MModule, mtype
: MType): Array[MPROPDEF]
1803 assert not mtype
.need_anchor
1804 mtype
= mtype
.as_notnullable
1806 var cache
= self.lookup_all_definitions_cache
[mmodule
, mtype
]
1807 if cache
!= null then return cache
1809 #print "select prop {mproperty} for {mtype} in {self}"
1810 # First, select all candidates
1811 var candidates
= new Array[MPROPDEF]
1812 for mpropdef
in self.mpropdefs
do
1813 # If the definition is not imported by the module, then skip
1814 if not mmodule
.in_importation
<= mpropdef
.mclassdef
.mmodule
then continue
1815 # If the definition is not inherited by the type, then skip
1816 if not mtype
.is_subtype
(mmodule
, null, mpropdef
.mclassdef
.bound_mtype
) then continue
1818 candidates
.add
(mpropdef
)
1820 # Fast track for only one candidate
1821 if candidates
.length
<= 1 then
1822 self.lookup_all_definitions_cache
[mmodule
, mtype
] = candidates
1826 mmodule
.linearize_mpropdefs
(candidates
)
1827 candidates
= candidates
.reversed
1828 self.lookup_all_definitions_cache
[mmodule
, mtype
] = candidates
1832 private var lookup_all_definitions_cache
= new HashMap2[MModule, MType, Array[MPROPDEF]]
1839 redef type MPROPDEF: MMethodDef
1841 # Is the property defined at the top_level of the module?
1842 # Currently such a property are stored in `Object`
1843 var is_toplevel
: Bool = false is writable
1845 # Is the property a constructor?
1846 # Warning, this property can be inherited by subclasses with or without being a constructor
1847 # therefore, you should use `is_init_for` the verify if the property is a legal constructor for a given class
1848 var is_init
: Bool = false is writable
1850 # The constructor is a (the) root init with empty signature but a set of initializers
1851 var is_root_init
: Bool = false is writable
1853 # Is the property a 'new' constructor?
1854 var is_new
: Bool = false is writable
1856 # Is the property a legal constructor for a given class?
1857 # As usual, visibility is not considered.
1858 # FIXME not implemented
1859 fun is_init_for
(mclass
: MClass): Bool
1865 # A global attribute
1869 redef type MPROPDEF: MAttributeDef
1873 # A global virtual type
1874 class MVirtualTypeProp
1877 redef type MPROPDEF: MVirtualTypeDef
1879 # The formal type associated to the virtual type property
1880 var mvirtualtype
= new MVirtualType(self)
1883 # A definition of a property (local property)
1885 # Unlike `MProperty`, a `MPropDef` is a local definition that belong to a
1886 # specific class definition (which belong to a specific module)
1887 abstract class MPropDef
1890 # The associated `MProperty` subclass.
1891 # the two specialization hierarchy are symmetric
1892 type MPROPERTY: MProperty
1895 type MPROPDEF: MPropDef
1897 # The class definition where the property definition is
1898 var mclassdef
: MClassDef
1900 # The associated global property
1901 var mproperty
: MPROPERTY
1903 # The origin of the definition
1904 var location
: Location
1908 mclassdef
.mpropdefs
.add
(self)
1909 mproperty
.mpropdefs
.add
(self)
1910 if mproperty
.intro_mclassdef
== mclassdef
then
1911 assert not isset mproperty
._intro
1912 mproperty
.intro
= self
1914 self.to_s
= "{mclassdef}#{mproperty}"
1917 # Actually the name of the `mproperty`
1918 redef fun name
do return mproperty
.name
1920 redef fun model
do return mclassdef
.model
1922 # Internal name combining the module, the class and the property
1923 # Example: "mymodule#MyClass#mymethod"
1924 redef var to_s
: String is noinit
1926 # Is self the definition that introduce the property?
1927 fun is_intro
: Bool do return mproperty
.intro
== self
1929 # Return the next definition in linearization of `mtype`.
1931 # This method is used to determine what method is called by a super.
1933 # REQUIRE: `not mtype.need_anchor`
1934 fun lookup_next_definition
(mmodule
: MModule, mtype
: MType): MPROPDEF
1936 assert not mtype
.need_anchor
1938 var mpropdefs
= self.mproperty
.lookup_all_definitions
(mmodule
, mtype
)
1939 var i
= mpropdefs
.iterator
1940 while i
.is_ok
and i
.item
!= self do i
.next
1941 assert has_property
: i
.is_ok
1943 assert has_next_property
: i
.is_ok
1948 # A local definition of a method
1952 redef type MPROPERTY: MMethod
1953 redef type MPROPDEF: MMethodDef
1955 # The signature attached to the property definition
1956 var msignature
: nullable MSignature = null is writable
1958 # The signature attached to the `new` call on a root-init
1959 # This is a concatenation of the signatures of the initializers
1961 # REQUIRE `mproperty.is_root_init == (new_msignature != null)`
1962 var new_msignature
: nullable MSignature = null is writable
1964 # List of initialisers to call in root-inits
1966 # They could be setters or attributes
1968 # REQUIRE `mproperty.is_root_init == (new_msignature != null)`
1969 var initializers
= new Array[MProperty]
1971 # Is the method definition abstract?
1972 var is_abstract
: Bool = false is writable
1974 # Is the method definition intern?
1975 var is_intern
= false is writable
1977 # Is the method definition extern?
1978 var is_extern
= false is writable
1980 # An optional constant value returned in functions.
1982 # Only some specific primitife value are accepted by engines.
1983 # Is used when there is no better implementation available.
1985 # Currently used only for the implementation of the `--define`
1986 # command-line option.
1987 # SEE: module `mixin`.
1988 var constant_value
: nullable Object = null is writable
1991 # A local definition of an attribute
1995 redef type MPROPERTY: MAttribute
1996 redef type MPROPDEF: MAttributeDef
1998 # The static type of the attribute
1999 var static_mtype
: nullable MType = null is writable
2002 # A local definition of a virtual type
2003 class MVirtualTypeDef
2006 redef type MPROPERTY: MVirtualTypeProp
2007 redef type MPROPDEF: MVirtualTypeDef
2009 # The bound of the virtual type
2010 var bound
: nullable MType = null is writable
2012 # Is the bound fixed?
2013 var is_fixed
= false is writable
2020 # * `interface_kind`
2024 # Note this class is basically an enum.
2025 # FIXME: use a real enum once user-defined enums are available
2027 redef var to_s
: String
2029 # Is a constructor required?
2032 # TODO: private init because enumeration.
2034 # Can a class of kind `self` specializes a class of kine `other`?
2035 fun can_specialize
(other
: MClassKind): Bool
2037 if other
== interface_kind
then return true # everybody can specialize interfaces
2038 if self == interface_kind
or self == enum_kind
then
2039 # no other case for interfaces
2041 else if self == extern_kind
then
2042 # only compatible with themselves
2043 return self == other
2044 else if other
== enum_kind
or other
== extern_kind
then
2045 # abstract_kind and concrete_kind are incompatible
2048 # remain only abstract_kind and concrete_kind
2053 # The class kind `abstract`
2054 fun abstract_kind
: MClassKind do return once
new MClassKind("abstract class", true)
2055 # The class kind `concrete`
2056 fun concrete_kind
: MClassKind do return once
new MClassKind("class", true)
2057 # The class kind `interface`
2058 fun interface_kind
: MClassKind do return once
new MClassKind("interface", false)
2059 # The class kind `enum`
2060 fun enum_kind
: MClassKind do return once
new MClassKind("enum", false)
2061 # The class kind `extern`
2062 fun extern_kind
: MClassKind do return once
new MClassKind("extern class", false)