super OrderedTree[MConcern]
end
+redef class MGroup
+ redef var is_test is lazy do
+ var parent = self.parent
+ if parent != null and parent.is_test then return true
+ return name == "tests"
+ end
+end
+
redef class MModule
# All the classes introduced in the module
var intro_mclasses = new Array[MClass]
do
var res = self.flatten_mclass_hierarchy_cache
if res != null then return res
- res = new POSet[MClass]
+ self.flatten_mclass_hierarchy_cache = new POSet[MClass]
for m in self.in_importation.greaters do
for cd in m.mclassdefs do
- var c = cd.mclass
- res.add_node(c)
- for s in cd.supertypes do
- res.add_edge(c, s.mclass)
- end
+ unsafe_update_hierarchy_cache(cd)
end
end
- self.flatten_mclass_hierarchy_cache = res
- return res
- end
+ return self.flatten_mclass_hierarchy_cache.as(not null)
+ end
+
+ # Adds another class definition in the modue.
+ # Updates the class hierarchy cache.
+ fun add_mclassdef(mclassdef: MClassDef)
+ do
+ self.mclassdefs.add(mclassdef)
+ if self.flatten_mclass_hierarchy_cache != null then
+ unsafe_update_hierarchy_cache(mclassdef)
+ end
+ end
+
+ # Adds a class definition inside `flatten_mclass_hierarchy_cache` without
+ # null check. The caller must have initialized the cache.
+ protected fun unsafe_update_hierarchy_cache(mclassdef: MClassDef)
+ do
+ var hierarchy = self.flatten_mclass_hierarchy_cache.as(not null)
+ # Update the cache
+ var c = mclassdef.mclass
+ hierarchy.add_node(c)
+ for s in mclassdef.supertypes do
+ hierarchy.add_edge(c, s.mclass)
+ end
+ end
# Sort a given array of classes using the linearization order of the module
# The most general is first, the most specific is last
init
do
self.mclass = bound_mtype.mclass
- mmodule.mclassdefs.add(self)
+ mmodule.add_mclassdef(self)
mclass.mclassdefs.add(self)
if mclass.intro_mmodule == mmodule then
assert not isset mclass._intro
# All property introductions and redefinitions in `self` (not inheritance).
var mpropdefs = new Array[MPropDef]
+ # The special default_init constructor
+ var default_init: nullable MMethodDef = null is writable
+
# All property introductions and redefinitions (not inheritance) in `self` by its associated property.
var mpropdefs_by_property = new HashMap[MProperty, MPropDef]
+ # Return the direct parent mtype of `self`
+ # Exemple
+ # ~~~nitish
+ # module 1
+ #
+ # class A
+ # class B
+ # super A
+ #
+ # module 2
+ #
+ # redef class A
+ # class C
+ # super B
+ #
+ # mclassdef_C.get_direct_supermtype == [B]
+ # ~~~~
+ fun get_direct_supermtype: Collection[MClassType]
+ do
+ # Get the potentiel direct parents
+ var parents = in_hierarchy.direct_greaters
+ # Stock the potentiel direct parents
+ var res = supertypes
+ for parent in parents do
+ # remove all super parents of the potentiel direct parents
+ res.remove_all(parent.supertypes)
+ # if the length of the potentiel direct parent equal 1 break
+ if res.length == 1 then break
+ end
+ return res
+ end
+
redef fun mdoc_or_fallback do return mdoc or else mclass.mdoc_or_fallback
end
if t == mtype then return self
return t.as_nullable
end
+
+ redef fun mdoc_or_fallback do return mtype.mdoc_or_fallback
end
# A non-null version of a formal type.
# A specific method that is safe to call on null.
# Currently, only `==`, `!=` and `is_same_instance` are safe
fun is_null_safe: Bool do return name == "==" or name == "!=" or name == "is_same_instance"
+
+ # Is this method a getter (auto or not)?
+ #
+ # See `getter_for`.
+ fun is_getter: Bool do return getter_for != null
+
+ # The attribute this getter is for
+ #
+ # Return `null` is this method is not a getter.
+ var getter_for: nullable MAttribute = null is writable
+
+ # Is this method a setter (auto or not)?
+ #
+ # See `setter_for`.
+ fun is_setter: Bool do return setter_for != null
+
+ # The attribute this setter is for
+ #
+ # Return `null` is this method is not a setter.
+ var setter_for: nullable MAttribute = null is writable
+
+ # Is this method a getter or a setter?
+ fun is_accessor: Bool do return is_getter or is_setter
end
# A global attribute
redef type MPROPDEF: MAttributeDef
+ # Does this attribute have a getter (auto or not)?
+ #
+ # See `getter`.
+ fun has_getter: Bool do return getter != null
+
+ # The getter of this attribute (if any)
+ var getter: nullable MProperty = null is writable
+
+ # Does this attribute have a setter (auto or not)?
+ #
+ # See `setter`.
+ fun has_setter: Bool do return setter != null
+
+ # The setter of this attribute (if any)
+ var setter: nullable MProperty = null is writable
end
# A global virtual type
# The associated global property
var mproperty: MPROPERTY
- redef var location: Location
+ redef var location
redef fun visibility do return mproperty.visibility
# The signature attached to the property definition
var msignature: nullable MSignature = null is writable
- # The signature attached to the `new` call on a root-init
- # This is a concatenation of the signatures of the initializers
- #
- # REQUIRE `mproperty.is_root_init == (new_msignature != null)`
- var new_msignature: nullable MSignature = null is writable
-
# List of initialisers to call in root-inits
#
# They could be setters or attributes
- #
- # REQUIRE `mproperty.is_root_init == (new_msignature != null)`
var initializers = new Array[MProperty]
+ # Does the method take the responsibility to call `init`?
+ #
+ # If the method is used as an initializer, then
+ # using this information prevents to call `init` twice.
+ var is_calling_init = false is writable
+
+ # Does the method is a old_style_init?
+ #
+ var is_old_style_init = false is writable
+
# Is the method definition abstract?
var is_abstract: Bool = false is writable