model_utils: All modules concerned in a class

[nit.git] / src / model_utils.nit

diff --git a/src/model_utils.nit b/src/model_utils.nit
index 6bdc558..4d8d615 100644 (file)
--- a/src/model_utils.nit
+++ b/src/model_utils.nit
@@ -34,10 +34,20 @@ redef class MModule
        fun imported_mclasses: Set[MClass] do
                var mclasses = new HashSet[MClass]
                for m in in_importation.greaters do
+                       if m == self then continue
                        for c in m.mclassdefs do mclasses.add(c.mclass)
                end
                return mclasses
        end
+
+       # Get all mclasses in 'self' with their state
+       fun mclasses: HashMap[MClass, Int] do
+               var mclasses = new HashMap[MClass, Int]
+               for c in intro_mclasses do mclasses[c] = c_is_intro
+               for r in redef_mclasses do mclasses[r] = c_is_refined
+               for i in imported_mclasses do mclasses[i] = c_is_imported
+               return mclasses
+       end
 end
 
 redef class MClass
@@ -65,6 +75,30 @@ redef class MClass
                return lst
        end
 
+       # Get direct children of 'self'.
+       fun children: Set[MClass] do
+               var lst = new HashSet[MClass]
+               for mclassdef in self.mclassdefs do
+                       for sub_mclassdef in mclassdef.in_hierarchy.direct_smallers do
+                               if sub_mclassdef == mclassdef then continue  # skip self
+                               lst.add(sub_mclassdef.mclass)
+                       end
+               end
+               return lst
+       end
+
+       # Get all children of 'self'.
+       fun descendants: Set[MClass] do
+               var lst = new HashSet[MClass]
+               for mclassdef in self.mclassdefs do
+                       for sub_mclassdef in mclassdef.in_hierarchy.smallers do
+                               if sub_mclassdef == mclassdef then continue  # skip self
+                               lst.add(sub_mclassdef.mclass)
+                       end
+               end
+               return lst
+       end
+
        # Get the list of constructors available for 'self'.
        fun constructors: Set[MMethod] do
                var res = new HashSet[MMethod]
@@ -115,6 +149,62 @@ redef class MClass
                return res
        end
 
+       # Get the list of all virtual types available in 'self'.
+       fun virtual_types: Set[MVirtualTypeProp] do
+               var res = new HashSet[MVirtualTypeProp]
+               for mclassdef in mclassdefs do
+                       for mpropdef in mclassdef.mpropdefs do
+                               if mpropdef isa MVirtualTypeDef then
+                                       res.add(mpropdef.mproperty)
+                               end
+                       end
+               end
+               for ancestor in ancestors do
+                       for mclassdef in ancestor.mclassdefs do
+                               for mpropdef in mclassdef.mpropdefs do
+                                       if mpropdef isa MVirtualTypeDef then
+                                               res.add(mpropdef.mproperty)
+                                       end
+                               end
+                       end
+               end
+               return res
+       end
+
+       # Get the list of all parameter types in 'self'.
+       fun parameter_types: Map[String, MType] do
+               var res = new HashMap[String, MType]
+               for i in [0..intro.parameter_names.length[ do
+                       res[intro.parameter_names[i]] = intro.bound_mtype.arguments[i]
+               end
+               return res
+       end
+
+       fun mmodules: Set[MModule] do
+               var mdls = new HashSet[MModule]
+               for mclassdef in mclassdefs do mdls.add(mclassdef.mmodule)
+               return mdls
+       end
+
+       # Get the list of MModule concern in 'self'
+       fun concerns: HashMap[MModule, nullable List[MModule]] do
+               var hm = new HashMap[MModule, nullable List[MModule]]
+               for mmodule in mmodules do
+                       var owner = mmodule.public_owner
+                       if owner == null then
+                               hm[mmodule] = null
+                       else
+                               if hm.has_key(owner) then
+                                       hm[owner].add(mmodule)
+                               else
+                                       hm[owner] = new List[MModule]
+                                       hm[owner].add(mmodule)
+                               end
+                       end
+               end
+               return hm
+       end
+
        fun is_class: Bool do
                return self.kind == concrete_kind or self.kind == abstract_kind
        end
@@ -131,3 +221,8 @@ redef class MClass
                return self.kind == abstract_kind
        end
 end
+
+# MClass State
+fun c_is_intro: Int do return 1
+fun c_is_refined: Int do return 2
+fun c_is_imported: Int do return 3