src/model_utils.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2008 Jean Privat <jean@pryen.org>
   4 #
   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
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  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.
  16
  17 # Model exploration and traversing facilities
  18 module model_utils
  19
  20 import modelbuilder
  21
  22 redef class MModule
  23         # Get the list of mclasses refined in 'self'.
  24         fun redef_mclasses: Set[MClass] do
  25                 var mclasses = new HashSet[MClass]
  26                 for c in mclassdefs do
  27                         if not c.is_intro then mclasses.add(c.mclass)
  28                 end
  29                 return mclasses
  30         end
  31
  32         # Get the list of all mclasses imported by 'self'.
  33         fun imported_mclasses: Set[MClass] do
  34                 var mclasses = new HashSet[MClass]
  35                 for m in in_importation.greaters do
  36                         if m == self then continue
  37                         for c in m.mclassdefs do mclasses.add(c.mclass)
  38                 end
  39                 return mclasses
  40         end
  41 end
  42
  43 redef class MClass
  44
  45         # Get the public owner of 'self'.
  46         fun public_owner: MModule do
  47                 var public_owner = self.intro_mmodule.public_owner
  48                 if public_owner == null then
  49                         return self.intro_mmodule
  50                 else
  51                         return public_owner
  52                 end
  53         end
  54
  55         # Get direct parents of 'self'.
  56         fun parents: Set[MClass] do
  57                 var ret = new HashSet[MClass]
  58                 for mclassdef in mclassdefs do
  59                         for mclasstype in mclassdef.supertypes do
  60                                 ret.add(mclasstype.mclass)
  61                         end
  62                 end
  63                 return ret
  64         end
  65
  66         # Get all ancestors of 'self'.
  67         fun ancestors: Set[MClass] do
  68                 var lst = new HashSet[MClass]
  69                 for mclassdef in self.mclassdefs do
  70                         for super_mclassdef in mclassdef.in_hierarchy.greaters do
  71                                 if super_mclassdef == mclassdef then continue  # skip self
  72                                 lst.add(super_mclassdef.mclass)
  73                         end
  74                 end
  75                 return lst
  76         end
  77
  78         # Get direct children of 'self'.
  79         fun children: Set[MClass] do
  80                 var lst = new HashSet[MClass]
  81                 for mclassdef in self.mclassdefs do
  82                         for sub_mclassdef in mclassdef.in_hierarchy.direct_smallers do
  83                                 if sub_mclassdef == mclassdef then continue  # skip self
  84                                 lst.add(sub_mclassdef.mclass)
  85                         end
  86                 end
  87                 return lst
  88         end
  89
  90         # Get all children of 'self'.
  91         fun descendants: Set[MClass] do
  92                 var lst = new HashSet[MClass]
  93                 for mclassdef in self.mclassdefs do
  94                         for sub_mclassdef in mclassdef.in_hierarchy.smallers do
  95                                 if sub_mclassdef == mclassdef then continue  # skip self
  96                                 lst.add(sub_mclassdef.mclass)
  97                         end
  98                 end
  99                 return lst
 100         end
 101
 102         # Get the list of constructors available for 'self'.
 103         fun constructors: Set[MMethod] do
 104                 var res = new HashSet[MMethod]
 105                 for mclassdef in mclassdefs do
 106                         for mpropdef in mclassdef.mpropdefs do
 107                                 if mpropdef isa MMethodDef then
 108                                         if mpropdef.mproperty.is_init then res.add(mpropdef.mproperty)
 109                                 end
 110                         end
 111                 end
 112                 return res
 113         end
 114
 115         # Get the list of methods introduced in 'self'.
 116         fun intro_methods: Set[MMethod] do
 117                 var res = new HashSet[MMethod]
 118                 for mclassdef in mclassdefs do
 119                         for mpropdef in mclassdef.mpropdefs do
 120                                 if mpropdef isa MMethodDef then
 121                                         if mpropdef.is_intro and not mpropdef.mproperty.is_init then res.add(mpropdef.mproperty)
 122                                 end
 123                         end
 124                 end
 125                 return res
 126         end
 127
 128         # the set of properties introduced in 'self'.
 129         fun intro_mproperties(min_visibility: MVisibility): Set[MProperty] do
 130                 var set = new HashSet[MProperty]
 131                 for mclassdef in mclassdefs do
 132                         for mprop in mclassdef.intro_mproperties do
 133                                 if mprop.visibility < min_visibility then continue
 134                                 set.add(mprop)
 135                         end
 136                 end
 137                 return set
 138         end
 139
 140         # the set of locally refined properties in 'self'.
 141         fun redef_mproperties(min_visibility: MVisibility): Set[MProperty] do
 142                 var set = new HashSet[MProperty]
 143                 for mclassdef in mclassdefs do
 144                         for mpropdef in mclassdef.mpropdefs do
 145                                 if mpropdef.mproperty.visibility < min_visibility then continue
 146                                 if mpropdef.mproperty.intro_mclassdef.mclass != self then set.add(mpropdef.mproperty)
 147                         end
 148                 end
 149                 return set
 150         end
 151
 152         # the set of methods inherited by 'self'.
 153         fun inherited_mproperties(mainmodule: MModule, min_visibility: MVisibility): Set[MProperty] do
 154                 var set = new HashSet[MProperty]
 155                 for parent in in_hierarchy(mainmodule).direct_greaters do
 156                         set.add_all(parent.intro_mproperties(min_visibility))
 157                         set.add_all(parent.inherited_mproperties(mainmodule, min_visibility))
 158                 end
 159                 return set
 160         end
 161
 162         # the set of introduced and redefined mproperties
 163         fun local_mproperties(min_visibility: MVisibility): Set[MProperty] do
 164                 var set = new HashSet[MProperty]
 165                 set.add_all(intro_mproperties(min_visibility))
 166                 set.add_all(redef_mproperties(min_visibility))
 167                 return set
 168         end
 169
 170         # the set of all accessible mproperties for this class
 171         fun all_mproperties(mainmodule: MModule, min_visibility: MVisibility): Set[MProperty] do
 172                 var set = new HashSet[MProperty]
 173                 set.add_all(local_mproperties(min_visibility))
 174                 set.add_all(inherited_mproperties(mainmodule, min_visibility))
 175                 return set
 176         end
 177
 178
 179         # Get the list of locally refined methods in 'self'.
 180         fun redef_methods: Set[MMethod] do
 181                 var res = new HashSet[MMethod]
 182                 for mclassdef in mclassdefs do
 183                         for mpropdef in mclassdef.mpropdefs do
 184                                 if mpropdef isa MMethodDef then
 185                                         if not mpropdef.is_intro and not mpropdef.mproperty.is_init then res.add(mpropdef.mproperty)
 186                                 end
 187                         end
 188                 end
 189                 return res
 190         end
 191
 192         fun inherited_methods: Set[MMethod] do
 193                 var res = new HashSet[MMethod]
 194                 for s in ancestors do
 195                         for m in s.intro_methods do
 196                                 if not self.intro_methods.has(m) and not self.redef_methods.has(m) then res.add(m)
 197                         end
 198                 end
 199                 return res
 200         end
 201
 202         # Get the list of all virtual types available in 'self'.
 203         fun virtual_types: Set[MVirtualTypeProp] do
 204                 var res = new HashSet[MVirtualTypeProp]
 205                 for mclassdef in mclassdefs do
 206                         for mpropdef in mclassdef.mpropdefs do
 207                                 if mpropdef isa MVirtualTypeDef then
 208                                         res.add(mpropdef.mproperty)
 209                                 end
 210                         end
 211                 end
 212                 for ancestor in ancestors do
 213                         for mclassdef in ancestor.mclassdefs do
 214                                 for mpropdef in mclassdef.mpropdefs do
 215                                         if mpropdef isa MVirtualTypeDef then
 216                                                 res.add(mpropdef.mproperty)
 217                                         end
 218                                 end
 219                         end
 220                 end
 221                 return res
 222         end
 223
 224         # Get the list of all parameter types in 'self'.
 225         fun parameter_types: Map[String, MType] do
 226                 var res = new HashMap[String, MType]
 227                 for i in [0..intro.parameter_names.length[ do
 228                         res[intro.parameter_names[i]] = intro.bound_mtype.arguments[i]
 229                 end
 230                 return res
 231         end
 232
 233         fun is_class: Bool do
 234                 return self.kind == concrete_kind or self.kind == abstract_kind
 235         end
 236
 237         fun is_interface: Bool do
 238                 return self.kind == interface_kind
 239         end
 240
 241         fun is_enum: Bool do
 242                 return self.kind == enum_kind
 243         end
 244
 245         fun is_abstract: Bool do
 246                 return self.kind == abstract_kind
 247         end
 248 end
 249
 250 # Sorters
 251
 252 # Sort mmodules by their name
 253 class MModuleNameSorter
 254         super AbstractSorter[MModule]
 255         redef fun compare(a, b) do return a.name <=> b.name
 256         init do end
 257 end
 258
 259 # Sort mclasses by their name
 260 class MClassNameSorter
 261         super AbstractSorter[MClass]
 262         redef fun compare(a, b) do return a.name <=> b.name
 263         init do end
 264 end
 265
 266 # Sort mclassdefs by their name
 267 class MClassDefNameSorter
 268         super AbstractSorter[MClassDef]
 269         redef fun compare(a, b) do return a.mclass.name <=> b.mclass.name
 270         init do end
 271 end
 272
 273 # Sort mproperties by their name
 274 class MPropertyNameSorter
 275         super AbstractSorter[MProperty]
 276         redef fun compare(a, b) do return a.name <=> b.name
 277         init do end
 278 end
 279
 280 # Sort mpropdefs by their name
 281 class MPropDefNameSorter
 282         super AbstractSorter[MPropDef]
 283         redef fun compare(a, b) do return a.mproperty.name <=> b.mproperty.name
 284         init do end
 285 end