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 toolcontext
  21 import exprbuilder
  22
  23 redef class MModule
  24         # Get the list of mclasses refined in 'self'.
  25         fun redef_mclasses: Set[MClass] do
  26                 var mclasses = new HashSet[MClass]
  27                 for c in mclassdefs do
  28                         if not c.is_intro then mclasses.add(c.mclass)
  29                 end
  30                 return mclasses
  31         end
  32
  33         # Get the list of all mclasses imported by 'self'.
  34         fun imported_mclasses: Set[MClass] do
  35                 var mclasses = new HashSet[MClass]
  36                 for m in in_importation.greaters do
  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 direct parents of 'self'.
  46         fun parents: Set[MClass] do
  47                 var ret = new HashSet[MClass]
  48                 for mclassdef in mclassdefs do
  49                         for mclasstype in mclassdef.supertypes do
  50                                 ret.add(mclasstype.mclass)
  51                         end
  52                 end
  53                 return ret
  54         end
  55
  56         # Get all ancestors of 'self'.
  57         fun ancestors: Set[MClass] do
  58                 var lst = new HashSet[MClass]
  59                 for mclassdef in self.mclassdefs do
  60                         for super_mclassdef in mclassdef.in_hierarchy.greaters do
  61                                 if super_mclassdef == mclassdef then continue  # skip self
  62                                 lst.add(super_mclassdef.mclass)
  63                         end
  64                 end
  65                 return lst
  66         end
  67
  68         # Get the list of constructors available for 'self'.
  69         fun constructors: Set[MMethod] do
  70                 var res = new HashSet[MMethod]
  71                 for mclassdef in mclassdefs do
  72                         for mpropdef in mclassdef.mpropdefs do
  73                                 if mpropdef isa MMethodDef then
  74                                         if mpropdef.mproperty.is_init then res.add(mpropdef.mproperty)
  75                                 end
  76                         end
  77                 end
  78                 return res
  79         end
  80
  81         # Get the list of methods introduced in 'self'.
  82         fun intro_methods: Set[MMethod] do
  83                 var res = new HashSet[MMethod]
  84                 for mclassdef in mclassdefs do
  85                         for mpropdef in mclassdef.mpropdefs do
  86                                 if mpropdef isa MMethodDef then
  87                                         if mpropdef.is_intro and not mpropdef.mproperty.is_init then res.add(mpropdef.mproperty)
  88                                 end
  89                         end
  90                 end
  91                 return res
  92         end
  93
  94         # Get the list of locally refined methods in 'self'.
  95         fun redef_methods: Set[MMethod] do
  96                 var res = new HashSet[MMethod]
  97                 for mclassdef in mclassdefs do
  98                         for mpropdef in mclassdef.mpropdefs do
  99                                 if mpropdef isa MMethodDef then
 100                                         if not mpropdef.is_intro and not mpropdef.mproperty.is_init then res.add(mpropdef.mproperty)
 101                                 end
 102                         end
 103                 end
 104                 return res
 105         end
 106
 107         # Get the list of methods inherited by 'self'.
 108         fun inherited_methods: Set[MMethod] do
 109                 var res = new HashSet[MMethod]
 110                 for s in ancestors do
 111                         for m in s.intro_methods do
 112                                 if not self.intro_methods.has(m) and not self.redef_methods.has(m) then res.add(m)
 113                         end
 114                 end
 115                 return res
 116         end
 117
 118         # Get the list of all virtual types available in 'self'.
 119         fun virtual_types: Set[MVirtualTypeProp] do
 120                 var res = new HashSet[MVirtualTypeProp]
 121                 for mclassdef in mclassdefs do
 122                         for mpropdef in mclassdef.mpropdefs do
 123                                 if mpropdef isa MVirtualTypeDef then
 124                                         res.add(mpropdef.mproperty)
 125                                 end
 126                         end
 127                 end
 128                 for ancestor in ancestors do
 129                         for mclassdef in ancestor.mclassdefs do
 130                                 for mpropdef in mclassdef.mpropdefs do
 131                                         if mpropdef isa MVirtualTypeDef then
 132                                                 res.add(mpropdef.mproperty)
 133                                         end
 134                                 end
 135                         end
 136                 end
 137                 return res
 138         end
 139
 140         # Get the list of all parameter types in 'self'.
 141         fun parameter_types: Map[String, MType] do
 142                 var res = new HashMap[String, MType]
 143                 for i in [0..intro.parameter_names.length[ do
 144                         res[intro.parameter_names[i]] = intro.bound_mtype.arguments[i]
 145                 end
 146                 return res
 147         end
 148
 149         fun is_class: Bool do
 150                 return self.kind == concrete_kind or self.kind == abstract_kind
 151         end
 152
 153         fun is_interface: Bool do
 154                 return self.kind == interface_kind
 155         end
 156
 157         fun is_enum: Bool do
 158                 return self.kind == enum_kind
 159         end
 160
 161         fun is_abstract: Bool do
 162                 return self.kind == abstract_kind
 163         end
 164 end