# The only null type
var null_type = new MNullType(self)
+ # The only bottom type
+ var bottom_type: MBottomType = null_type.as_notnull
+
# Build an ordered tree with from `concerns`
fun concerns_tree(mconcerns: Collection[MConcern]): ConcernsTree do
var seen = new HashSet[MConcern]
# Is `self` and abstract class?
var is_abstract: Bool is lazy do return kind == abstract_kind
- redef fun mdoc_or_fallback do return intro.mdoc_or_fallback
+ redef fun mdoc_or_fallback
+ do
+ # Don’t use `intro.mdoc_or_fallback` because it would create an infinite
+ # recursion.
+ return intro.mdoc
+ end
end
# All property introductions and redefinitions (not inheritance) in `self` by its associated property.
var mpropdefs_by_property = new HashMap[MProperty, MPropDef]
+
+ redef fun mdoc_or_fallback do return mdoc or else mclass.mdoc_or_fallback
end
# A global static type
# because "redef type U: Y". Therefore, Map[T, U] is bound to
# Map[B, Y]
#
+ # REQUIRE: `self.need_anchor implies anchor != null`
# ENSURE: `not self.need_anchor implies result == self`
# ENSURE: `not result.need_anchor`
- fun anchor_to(mmodule: MModule, anchor: MClassType): MType
+ fun anchor_to(mmodule: MModule, anchor: nullable MClassType): MType
do
if not need_anchor then return self
- assert not anchor.need_anchor
+ assert anchor != null and not anchor.need_anchor
# Just resolve to the anchor and clear all the virtual types
var res = self.resolve_for(anchor, null, mmodule, true)
assert not res.need_anchor
# * H[G[A], B] -> 3
#
# Formal types have a depth of 1.
+ # Only `MClassType` and `MFormalType` nodes are counted.
fun depth: Int
do
return 1
# * H[G[A], B] -> 4
#
# Formal types have a length of 1.
+ # Only `MClassType` and `MFormalType` nodes are counted.
fun length: Int
do
return 1
redef fun need_anchor do return false
- redef fun anchor_to(mmodule: MModule, anchor: MClassType): MClassType
+ redef fun anchor_to(mmodule, anchor): MClassType
do
return super.as(MClassType)
end
private var collect_mclasses_cache = new HashMap[MModule, Set[MClass]]
private var collect_mtypes_cache = new HashMap[MModule, Set[MClassType]]
+ redef fun mdoc_or_fallback do return mclass.mdoc_or_fallback
end
# A type based on a generic class.
redef fun full_name do return self.mproperty.full_name
redef fun c_name do return self.mproperty.c_name
+
+ redef fun mdoc_or_fallback do return mproperty.mdoc_or_fallback
end
# The type associated to a formal parameter generic type of a class
redef fun c_name do return "null"
redef fun as_nullable do return self
- redef var as_notnull = new MBottomType(model) is lazy
+ redef var as_notnull: MBottomType = new MBottomType(model) is lazy
redef fun need_anchor do return false
redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual) do return self
redef fun can_resolve_for(mtype, anchor, mmodule) do return true
redef var location
- redef fun mdoc_or_fallback do return intro.mdoc_or_fallback
+ redef fun mdoc_or_fallback
+ do
+ # Don’t use `intro.mdoc_or_fallback` because it would create an infinite
+ # recursion.
+ return intro.mdoc
+ end
# The canonical name of the property.
#
assert has_next_property: i.is_ok
return i.item
end
+
+ redef fun mdoc_or_fallback do return mdoc or else mproperty.mdoc_or_fallback
end
# A local definition of a method