X-Git-Url: http://nitlanguage.org diff --git a/src/model/model.nit b/src/model/model.nit index ea1e025..3ceb9f3 100644 --- a/src/model/model.nit +++ b/src/model/model.nit @@ -30,6 +30,15 @@ import mdoc import ordered_tree private import more_collections +redef class MEntity + # The visibility of the MEntity. + # + # MPackages, MGroups and MModules are always public. + # The visibility of `MClass` and `MProperty` is defined by the keyword used. + # `MClassDef` and `MPropDef` return the visibility of `MClass` and `MProperty`. + fun visibility: MVisibility do return public_visibility +end + redef class Model # All known classes var mclasses = new Array[MClass] @@ -41,6 +50,13 @@ redef class Model # # Each classdef is associated with its super-classdefs in regard to # its module of definition. + # + # ~~~ + # var m = new ModelDiamond + # assert m.mclassdef_hierarchy.has_edge(m.mclassdef_b, m.mclassdef_a) + # assert not m.mclassdef_hierarchy.has_edge(m.mclassdef_a, m.mclassdef_b) + # assert not m.mclassdef_hierarchy.has_edge(m.mclassdef_b, m.mclassdef_c) + # ~~~ var mclassdef_hierarchy = new POSet[MClassDef] # Class-type hierarchy restricted to the introduction. @@ -66,12 +82,18 @@ redef class Model # Collections of classes grouped by their short name private var mclasses_by_name = new MultiHashMap[String, MClass] - # Return all class named `name`. + # Return all classes named `name`. # # If such a class does not exist, null is returned # (instead of an empty array) # # Visibility or modules are not considered + # + # ~~~ + # var m = new ModelStandalone + # assert m.get_mclasses_by_name("Object") == [m.mclass_o] + # assert m.get_mclasses_by_name("Fail") == null + # ~~~ fun get_mclasses_by_name(name: String): nullable Array[MClass] do return mclasses_by_name.get_or_null(name) @@ -94,6 +116,9 @@ redef class Model # 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] @@ -134,6 +159,14 @@ class ConcernsTree 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] @@ -142,6 +175,14 @@ redef class MModule # (introduction and refinement) var mclassdefs = new Array[MClassDef] + private var mclassdef_sorter: MClassDefSorter is lazy do + return new MClassDefSorter(self) + end + + private var mpropdef_sorter: MPropDefSorter is lazy do + return new MPropDefSorter(self) + end + # Does the current module has a given class `mclass`? # Return true if the mmodule introduces, refines or imports a class. # Visibility is not considered. @@ -150,14 +191,14 @@ redef class MModule return self.in_importation <= mclass.intro_mmodule end - # Full hierarchy of introduced ans imported classes. + # Full hierarchy of introduced and imported classes. # # Create a new hierarchy got by flattening the classes for the module # and its imported modules. # Visibility is not considered. # # Note: this function is expensive and is usually used for the main - # module of a program only. Do not use it to do you own subtype + # module of a program only. Do not use it to do your own subtype # functions. fun flatten_mclass_hierarchy: POSet[MClass] do @@ -189,8 +230,7 @@ redef class MModule # The most general is first, the most specific is last fun linearize_mclassdefs(mclassdefs: Array[MClassDef]) do - var sorter = new MClassDefSorter(self) - sorter.sort(mclassdefs) + mclassdef_sorter.sort(mclassdefs) end # Sort a given array of property definitions using the linearization order of the module @@ -198,8 +238,7 @@ redef class MModule # The most general is first, the most specific is last fun linearize_mpropdefs(mpropdefs: Array[MPropDef]) do - var sorter = new MPropDefSorter(self) - sorter.sort(mpropdefs) + mpropdef_sorter.sort(mpropdefs) end private var flatten_mclass_hierarchy_cache: nullable POSet[MClass] = null @@ -243,8 +282,8 @@ redef class MModule # The primitive type `String` var string_type: MClassType = self.get_primitive_class("String").mclass_type is lazy - # The primitive type `NativeString` - var native_string_type: MClassType = self.get_primitive_class("NativeString").mclass_type is lazy + # The primitive type `CString` + var c_string_type: MClassType = self.get_primitive_class("CString").mclass_type is lazy # A primitive type of `Array` fun array_type(elt_type: MType): MClassType do return array_class.get_mtype([elt_type]) @@ -285,20 +324,21 @@ redef class MModule if name == "Bool" and self.model.get_mclasses_by_name("Object") != null then # Bool is injected because it is needed by engine to code the result # of the implicit casts. - var c = new MClass(self, name, null, enum_kind, public_visibility) - var cladef = new MClassDef(self, c.mclass_type, new Location(null, 0,0,0,0)) + var loc = model.no_location + var c = new MClass(self, name, loc, null, enum_kind, public_visibility) + var cladef = new MClassDef(self, c.mclass_type, loc) cladef.set_supertypes([object_type]) cladef.add_in_hierarchy return c end - print("Fatal Error: no primitive class {name} in {self}") + print_error("Fatal Error: no primitive class {name} in {self}") exit(1) abort end if cla.length != 1 then var msg = "Fatal Error: more than one primitive class {name} in {self}:" for c in cla do msg += " {c.full_name}" - print msg + print_error msg #exit(1) end return cla.first @@ -317,7 +357,7 @@ redef class MModule if res == null then res = mprop else if res != mprop then - print("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}") + print_error("Fatal Error: ambigous property name '{name}'; conflict between {mprop.full_name} and {res.full_name}") abort end end @@ -342,21 +382,19 @@ private class MPropDefSorter super Comparator redef type COMPARED: MPropDef var mmodule: MModule + redef fun compare(pa, pb) do var a = pa.mclassdef var b = pb.mclassdef - var ca = a.mclass - var cb = b.mclass - if ca != cb then return mmodule.flatten_mclass_hierarchy.compare(ca, cb) - return mmodule.model.mclassdef_hierarchy.compare(a, b) + return mmodule.mclassdef_sorter.compare(a, b) end end # A named class # -# `MClass` are global to the model; it means that a `MClass` is not bound to a -# specific `MModule`. +# `MClass`es are global to the model; it means that a `MClass` is not bound +# to a specific `MModule`. # # This characteristic helps the reasoning about classes in a program since a # single `MClass` object always denote the same class. @@ -378,14 +416,17 @@ class MClass super MEntity # The module that introduce the class + # # While classes are not bound to a specific module, - # the introducing module is used for naming an visibility + # the introducing module is used for naming and visibility. var intro_mmodule: MModule # The short name of the class # In Nit, the name of a class cannot evolve in refinements redef var name + redef var location + # The canonical name of the class # # It is the name of the class prefixed by the full_name of the `intro_mmodule` @@ -457,12 +498,14 @@ class MClass end # The kind of the class (interface, abstract class, etc.) - # In Nit, the kind of a class cannot evolve in refinements + # + # In Nit, the kind of a class cannot evolve in refinements. var kind: MClassKind # The visibility of the class - # In Nit, the visibility of a class cannot evolve in refinements - var visibility: MVisibility + # + # In Nit, the visibility of a class cannot evolve in refinements. + redef var visibility init do @@ -485,12 +528,12 @@ class MClass # Warning: such a definition may not exist in the early life of the object. # In this case, the method will abort. # - # Use `try_intro` instead + # Use `try_intro` instead. var intro: MClassDef is noinit - # The definition that introduces the class or null if not yet known. + # The definition that introduces the class or `null` if not yet known. # - # See `intro` + # SEE: `intro` fun try_intro: nullable MClassDef do if isset _intro then return _intro else return null end @@ -506,12 +549,12 @@ class MClass # The principal static type of the class. # - # For non-generic class, mclass_type is the only `MClassType` based + # For non-generic class, `mclass_type` is the only `MClassType` based # on self. # # For a generic class, the arguments are the formal parameters. - # i.e.: for the class Array[E:Object], the `mclass_type` is Array[E]. - # If you want Array[Object] the see `MClassDef::bound_mtype` + # i.e.: for the class `Array[E:Object]`, the `mclass_type` is `Array[E]`. + # If you want `Array[Object]`, see `MClassDef::bound_mtype`. # # For generic classes, the mclass_type is also the way to get a formal # generic parameter type. @@ -552,6 +595,15 @@ class MClass # Is `self` and abstract class? var is_abstract: Bool is lazy do return kind == abstract_kind + + redef var is_test is lazy do return intro.is_test + + 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 @@ -588,8 +640,9 @@ class MClassDef # ENSURE: `bound_mtype.mclass == self.mclass` var bound_mtype: MClassType - # The origin of the definition - var location: Location + redef var location + + redef fun visibility do return mclass.visibility # Internal name combining the module and the class # Example: "mymodule$MyClass" @@ -704,8 +757,13 @@ class MClassDef # All properties introduced by the classdef var intro_mproperties = new Array[MProperty] - # All property definitions in the class (introductions and redefinitions) + # All property introductions and redefinitions in `self` (not inheritance). var mpropdefs = new Array[MPropDef] + + # 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 @@ -816,19 +874,19 @@ abstract class MType end #print "4.is {sub} a {sup}? <- no more resolution" - if sub isa MBottomType then + if sub isa MBottomType or sub isa MErrorType then return true end - assert sub isa MClassType else print "{sub} 3 # # Formal types have a depth of 1. + # Only `MClassType` and `MFormalType` nodes are counted. fun depth: Int do return 1 @@ -1115,6 +1190,7 @@ abstract class MType # * 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 @@ -1165,6 +1241,8 @@ class MClassType redef fun model do return self.mclass.intro_mmodule.model + redef fun location do return mclass.location + # TODO: private init because strongly bounded to its mclass. see `mclass.mclass_type` # The formal arguments of the type @@ -1179,7 +1257,7 @@ class MClassType 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 @@ -1259,6 +1337,7 @@ class MClassType 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. @@ -1331,6 +1410,24 @@ class MGenericType return true end + redef fun is_ok + do + for t in arguments do if not t.is_ok then return false + return super + end + + redef fun is_legal_in(mmodule, anchor) + do + var mtype + if need_anchor then + assert anchor != null + mtype = anchor_to(mmodule, anchor) + else + mtype = self + end + if not mtype.is_ok then return false + return mtype.is_subtype(mmodule, null, mtype.mclass.intro.bound_mtype) + end redef fun depth do @@ -1370,11 +1467,15 @@ class MVirtualType # Its the definitions of this property that determine the bound or the virtual type. var mproperty: MVirtualTypeProp + redef fun location do return mproperty.location + redef fun model do return self.mproperty.intro_mclassdef.mmodule.model - redef fun lookup_bound(mmodule: MModule, resolved_receiver: MType): MType + redef fun lookup_bound(mmodule, resolved_receiver) do - return lookup_single_definition(mmodule, resolved_receiver).bound or else new MBottomType(model) + # There is two possible invalid cases: the vt does not exists in resolved_receiver or the bound is broken + if not resolved_receiver.has_mproperty(mmodule, mproperty) then return new MErrorType(model) + return lookup_single_definition(mmodule, resolved_receiver).bound or else new MErrorType(model) end private fun lookup_single_definition(mmodule: MModule, resolved_receiver: MType): MVirtualTypeDef @@ -1400,8 +1501,8 @@ class MVirtualType # A VT is fixed when: # * the VT is (re-)defined with the annotation `is fixed` - # * the VT is (indirectly) bound to an enum class (see `enum_kind`) since there is no subtype possible - # * the receiver is an enum class since there is no subtype possible + # * the receiver is an enum class since there is no subtype that can + # redefine this virtual type redef fun lookup_fixed(mmodule: MModule, resolved_receiver: MType): MType do assert not resolved_receiver.need_anchor @@ -1410,18 +1511,15 @@ class MVirtualType var prop = lookup_single_definition(mmodule, resolved_receiver) var res = prop.bound - if res == null then return new MBottomType(model) + if res == null then return new MErrorType(model) # Recursively lookup the fixed result res = res.lookup_fixed(mmodule, resolved_receiver) - # 1. For a fixed VT, return the resolved bound + # For a fixed VT, return the resolved bound if prop.is_fixed then return res - # 2. For a enum boud, return the bound - if res isa MClassType and res.mclass.kind == enum_kind then return res - - # 3. for a enum receiver return the bound + # For a enum receiver return the bound if resolved_receiver.mclass.kind == enum_kind then return res return self @@ -1431,6 +1529,9 @@ class MVirtualType do if not cleanup_virtual then return self assert can_resolve_for(mtype, anchor, mmodule) + + if mproperty.is_selftype then return mtype + # self is a virtual type declared (or inherited) in mtype # The point of the function it to get the bound of the virtual type that make sense for mtype # But because mtype is maybe a virtual/formal type, we need to get a real receiver first @@ -1464,6 +1565,8 @@ class MVirtualType 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 @@ -1500,6 +1603,8 @@ class MParameterType redef fun model do return self.mclass.intro_mmodule.model + redef fun location do return mclass.location + # The position of the parameter (0 for the first parameter) # FIXME: is `position` a better name? var rank: Int @@ -1530,13 +1635,12 @@ class MParameterType return res end end - abort + # Cannot found `self` in `resolved_receiver` + return new MErrorType(model) end # A PT is fixed when: - # * Its bound is a enum class (see `enum_kind`). - # The PT is just useless, but it is still a case. - # * More usually, the `resolved_receiver` is a subclass of `self.mclass`, + # * The `resolved_receiver` is a subclass of `self.mclass`, # so it is necessarily fixed in a `super` clause, either with a normal type # or with another PT. # See `resolve_for` for examples about related issues. @@ -1555,13 +1659,7 @@ class MParameterType #print "{class_name}: {self}/{mtype}/{anchor}?" if mtype isa MGenericType and mtype.mclass == self.mclass then - var res = mtype.arguments[self.rank] - if anchor != null and res.need_anchor then - # Maybe the result can be resolved more if are bound to a final class - var r2 = res.anchor_to(mmodule, anchor) - if r2 isa MClassType and r2.mclass.kind == enum_kind then return r2 - end - return res + return mtype.arguments[self.rank] end # self is a parameter type of mtype (or of a super-class of mtype) @@ -1625,6 +1723,8 @@ abstract class MProxyType # The base type var mtype: MType + redef fun location do return mtype.location + redef fun model do return self.mtype.model redef fun need_anchor do return mtype.need_anchor redef fun as_nullable do return mtype.as_nullable @@ -1641,6 +1741,10 @@ abstract class MProxyType return self.mtype.can_resolve_for(mtype, anchor, mmodule) end + redef fun is_ok do return mtype.is_ok + + redef fun is_legal_in(mmodule, anchor) do return mtype.is_legal_in(mmodule, anchor) + redef fun lookup_fixed(mmodule, resolved_receiver) do var t = mtype.lookup_fixed(mmodule, resolved_receiver) @@ -1739,7 +1843,7 @@ class MNullType 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 @@ -1754,9 +1858,10 @@ end # The special universal most specific type. # # This type is intended to be only used internally for type computation or analysis and should not be exposed to the user. -# The bottom type can de used to denote things that are absurd, dead, or the absence of knowledge. +# The bottom type can de used to denote things that are dead (no instance). # # Semantically it is the singleton `null.as_notnull`. +# Is also means that `self.as_nullable == null`. class MBottomType super MType redef var model @@ -1776,6 +1881,31 @@ class MBottomType redef fun collect_mtypes(mmodule) do return new HashSet[MClassType] end +# A special type used as a silent error marker when building types. +# +# This type is intended to be only used internally for type operation and should not be exposed to the user. +# The error type can de used to denote things that are conflicting or inconsistent. +# +# Some methods on types can return a `MErrorType` to denote a broken or a conflicting result. +# Use `is_ok` to check if a type is (or contains) a `MErrorType` . +class MErrorType + super MType + redef var model + redef fun to_s do return "error" + redef fun full_name do return "error" + redef fun c_name do return "error" + 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 fun is_ok do return false + + redef fun collect_mclassdefs(mmodule) do return new HashSet[MClassDef] + + redef fun collect_mclasses(mmodule) do return new HashSet[MClass] + + redef fun collect_mtypes(mmodule) do return new HashSet[MClassType] +end + # A signature of a method class MSignature super MType @@ -1855,16 +1985,34 @@ class MSignature var b = new FlatBuffer if not mparameters.is_empty then b.append("(") + var last_mtype = null for i in [0..mparameters.length[ do var mparameter = mparameters[i] + + # Group types that are common to contiguous parameters + if mparameter.mtype != last_mtype and last_mtype != null then + b.append(": ") + b.append(last_mtype.to_s) + end + if i > 0 then b.append(", ") b.append(mparameter.name) - b.append(": ") - b.append(mparameter.mtype.to_s) + if mparameter.is_vararg then + b.append(": ") + b.append(mparameter.mtype.to_s) b.append("...") + last_mtype = null + else + last_mtype = mparameter.mtype end end + + if last_mtype != null then + b.append(": ") + b.append(last_mtype.to_s) + end + b.append(")") end var ret = self.return_mtype @@ -1951,12 +2099,32 @@ abstract class MProperty # The (short) name of the property redef var name + redef var location + + 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. # - # It is the short-`name` prefixed by the short-name of the class and the full-name of the module. + # It is currently the short-`name` prefixed by the short-name of the class and the full-name of the module. # Example: "my_package::my_module::MyClass::my_method" + # + # The full-name of the module is needed because two distinct modules of the same package can + # still refine the same class and introduce homonym properties. + # + # For public properties not introduced by refinement, the module name is not used. + # + # Example: `my_package::MyClass::My_method` redef var full_name is lazy do - return "{intro_mclassdef.mmodule.namespace_for(visibility)}::{intro_mclassdef.mclass.name}::{name}" + if intro_mclassdef.is_intro then + return "{intro_mclassdef.mmodule.namespace_for(visibility)}::{intro_mclassdef.mclass.name}::{name}" + else + return "{intro_mclassdef.mmodule.full_name}::{intro_mclassdef.mclass.name}::{name}" + end end redef var c_name is lazy do @@ -1965,7 +2133,7 @@ abstract class MProperty end # The visibility of the property - var visibility: MVisibility + redef var visibility # Is the property usable as an initializer? var is_autoinit = false is writable @@ -2014,14 +2182,27 @@ abstract class MProperty #print "select prop {mproperty} for {mtype} in {self}" # First, select all candidates var candidates = new Array[MPROPDEF] - for mpropdef in self.mpropdefs do - # If the definition is not imported by the module, then skip - if not mmodule.in_importation <= mpropdef.mclassdef.mmodule then continue - # If the definition is not inherited by the type, then skip - if not mtype.is_subtype(mmodule, null, mpropdef.mclassdef.bound_mtype) then continue - # Else, we keep it - candidates.add(mpropdef) + + # Here we have two strategies: iterate propdefs or iterate classdefs. + var mpropdefs = self.mpropdefs + if mpropdefs.length <= 1 or mpropdefs.length < mtype.collect_mclassdefs(mmodule).length then + # Iterate on all definitions of `self`, keep only those inherited by `mtype` in `mmodule` + for mpropdef in mpropdefs do + # If the definition is not imported by the module, then skip + if not mmodule.in_importation <= mpropdef.mclassdef.mmodule then continue + # If the definition is not inherited by the type, then skip + if not mtype.is_subtype(mmodule, null, mpropdef.mclassdef.bound_mtype) then continue + # Else, we keep it + candidates.add(mpropdef) + end + else + # Iterate on all super-classdefs of `mtype`, keep only the definitions of `self`, if any. + for mclassdef in mtype.collect_mclassdefs(mmodule) do + var p = mclassdef.mpropdefs_by_property.get_or_null(self) + if p != null then candidates.add p + end end + # Fast track for only one candidate if candidates.length <= 1 then self.lookup_definitions_cache[mmodule, mtype] = candidates @@ -2097,7 +2278,7 @@ abstract class MProperty end end if res.is_empty then - print "All lost! {candidates.join(", ")}" + print_error "All lost! {candidates.join(", ")}" # FIXME: should be abort! end return res @@ -2156,6 +2337,20 @@ abstract class MProperty end private var lookup_all_definitions_cache = new HashMap2[MModule, MType, Array[MPROPDEF]] + + redef var is_test is lazy do return intro.is_test + + # Does self have the `before` annotation? + var is_before: Bool is lazy do return intro.is_before + + # Does self have the `before_all` annotation? + var is_before_all: Bool is lazy do return intro.is_before_all + + # Does self have the `after` annotation? + var is_after: Bool is lazy do return intro.is_after + + # Does self have the `after_all` annotation? + var is_after_all: Bool is lazy do return intro.is_after_all end # A global method @@ -2190,6 +2385,29 @@ class MMethod # 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 @@ -2198,6 +2416,21 @@ class MAttribute 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 @@ -2208,6 +2441,9 @@ class MVirtualTypeProp # The formal type associated to the virtual type property var mvirtualtype = new MVirtualType(self) + + # Is `self` the special virtual type `SELF`? + var is_selftype: Bool is lazy do return name == "SELF" end # A definition of a property (local property) @@ -2230,13 +2466,15 @@ abstract class MPropDef # The associated global property var mproperty: MPROPERTY - # The origin of the definition - var location: Location + redef var location + + redef fun visibility do return mproperty.visibility init do mclassdef.mpropdefs.add(self) mproperty.mpropdefs.add(self) + mclassdef.mpropdefs_by_property[mproperty] = self if mproperty.intro_mclassdef == mclassdef then assert not isset mproperty._intro mproperty.intro = self @@ -2274,7 +2512,7 @@ abstract class MPropDef # Just try to simplify each part if mclassdef.mmodule.mpackage != mproperty.intro_mclassdef.mmodule.mpackage then # precise "p::m" only if "p" != "r" - res.append mproperty.intro_mclassdef.mmodule.full_name + res.append mproperty.intro_mclassdef.mmodule.namespace_for(mproperty.visibility) res.append "::" else if mproperty.visibility <= private_visibility then # Same package ("p"=="q"), but private visibility, @@ -2285,11 +2523,9 @@ abstract class MPropDef res.append "::" end end - if mclassdef.mclass != mproperty.intro_mclassdef.mclass then - # precise "B" only if not the same class than "A" - res.append mproperty.intro_mclassdef.name - res.append "::" - end + # precise "B" because it is not the same class than "A" + res.append mproperty.intro_mclassdef.name + res.append "::" # Always use the property name "x" res.append mproperty.name end @@ -2307,10 +2543,8 @@ abstract class MPropDef res.append mproperty.intro_mclassdef.mmodule.c_name res.append "__" end - if mclassdef.mclass != mproperty.intro_mclassdef.mclass then - res.append mproperty.intro_mclassdef.name.to_cmangle - res.append "__" - end + res.append mproperty.intro_mclassdef.name.to_cmangle + res.append "__" res.append mproperty.name.to_cmangle end return res.to_s @@ -2342,6 +2576,20 @@ abstract class MPropDef 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 + + # Does self have the `before` annotation? + var is_before = false is writable + + # Does self have the `before_all` annotation? + var is_before_all = false is writable + + # Does self have the `after` annotation? + var is_after = false is writable + + # Does self have the `after_all` annotation? + var is_after_all = false is writable end # A local definition of a method @@ -2425,37 +2673,116 @@ end class MClassKind redef var to_s + # Can a class of kind `self` define a membership predicate? + var can_customize_isa: Bool + + # Can a class of kind `self` define a constructor? + var can_init: Bool + # Is a constructor required? var need_init: Bool # TODO: private init because enumeration. - # Can a class of kind `self` specializes a class of kine `other`? + # Can a class of kind `self` specializes a class of kind `other`? fun can_specialize(other: MClassKind): Bool do - if other == interface_kind then return true # everybody can specialize interfaces - if self == interface_kind or self == enum_kind then - # no other case for interfaces + if other == interface_kind then + # everybody can specialize interfaces + return true + else if self == interface_kind or self == enum_kind then + # no other case for interfaces and enums return false + else if self == subset_kind then + # A subset may specialize anything, except another subset. + # TODO: Allow sub-subsets once we can handle them. + return other != subset_kind else if self == extern_kind then # only compatible with themselves return self == other - else if other == enum_kind or other == extern_kind then - # abstract_kind and concrete_kind are incompatible - return false + else + # assert self == abstract_kind or self == concrete_kind + return other == abstract_kind or other == concrete_kind end - # remain only abstract_kind and concrete_kind - return true end end # The class kind `abstract` -fun abstract_kind: MClassKind do return once new MClassKind("abstract class", true) +fun abstract_kind: MClassKind do return once new MClassKind("abstract class", false, true, true) # The class kind `concrete` -fun concrete_kind: MClassKind do return once new MClassKind("class", true) +fun concrete_kind: MClassKind do return once new MClassKind("class", false, true, true) # The class kind `interface` -fun interface_kind: MClassKind do return once new MClassKind("interface", false) +fun interface_kind: MClassKind do return once new MClassKind("interface", false, true, false) # The class kind `enum` -fun enum_kind: MClassKind do return once new MClassKind("enum", false) +fun enum_kind: MClassKind do return once new MClassKind("enum", false, true, false) # The class kind `extern` -fun extern_kind: MClassKind do return once new MClassKind("extern class", false) +fun extern_kind: MClassKind do return once new MClassKind("extern class", false, true, false) +# The class kind `subset` +fun subset_kind: MClassKind do return once new MClassKind("subset", true, false, false) + +# A standalone pre-constructed model used to test various model-related methods. +# +# When instantiated, a standalone model is already filled with entities that are exposed as attributes. +class ModelStandalone + super Model + + redef var location = new Location.opaque_file("ModelStandalone") + + # The first module + var mmodule0 = new MModule(self, null, "module0", location) + + # The root Object class + var mclass_o = new MClass(mmodule0, "Object", location, null, interface_kind, public_visibility) + + # The introduction of `mclass_o` + var mclassdef_o = new MClassDef(mmodule0, mclass_o.mclass_type, location) +end + +# A standalone model with the common class diamond-hierarchy ABCD +class ModelDiamond + super ModelStandalone + + # A, a simple subclass of Object + var mclass_a = new MClass(mmodule0, "A", location, null, concrete_kind, public_visibility) + + # The introduction of `mclass_a` + var mclassdef_a: MClassDef do + var res = new MClassDef(mmodule0, mclass_a.mclass_type, location) + res.set_supertypes([mclass_o.mclass_type]) + res.add_in_hierarchy + return res + end + + # B, a subclass of A (`mclass_a`) + var mclass_b = new MClass(mmodule0, "B", location, null, concrete_kind, public_visibility) + + # The introduction of `mclass_b` + var mclassdef_b: MClassDef do + var res = new MClassDef(mmodule0, mclass_b.mclass_type, location) + res.set_supertypes([mclass_a.mclass_type]) + res.add_in_hierarchy + return res + end + + # C, another subclass of A (`mclass_a`) + var mclass_c = new MClass(mmodule0, "C", location, null, concrete_kind, public_visibility) + + # The introduction of `mclass_c` + var mclassdef_c: MClassDef do + var res = new MClassDef(mmodule0, mclass_c.mclass_type, location) + res.set_supertypes([mclass_a.mclass_type]) + res.add_in_hierarchy + return res + end + + # D, a multiple subclass of B (`mclass_b`) and C (`mclass_c`) + var mclass_d = new MClass(mmodule0, "D", location, null, concrete_kind, public_visibility) + + # The introduction of `mclass_d` + var mclassdef_d: MClassDef do + var res = new MClassDef(mmodule0, mclass_d.mclass_type, location) + res.set_supertypes([mclass_b.mclass_type, mclass_c.mclass_type]) + res.add_in_hierarchy + return res + end +end