import modelbuilder
+redef class MGroup
+ fun in_nesting_intro_mclasses(min_visibility: MVisibility): Set[MClass] do
+ var res = new HashSet[MClass]
+ var lst = in_nesting.direct_smallers
+ for mmodule in mmodules do res.add_all mmodule.filter_intro_mclasses(min_visibility)
+ for mgrp in lst do res.add_all mgrp.in_nesting_intro_mclasses(min_visibility)
+ return res
+ end
+
+ fun in_nesting_redef_mclasses(min_visibility: MVisibility): Set[MClass] do
+ var res = new HashSet[MClass]
+ var lst = in_nesting.direct_smallers
+ for mmodule in mmodules do res.add_all mmodule.filter_redef_mclasses(min_visibility)
+ for mgrp in lst do res.add_all mgrp.in_nesting_redef_mclasses(min_visibility)
+ return res
+ end
+
+ fun in_nesting_intro_mclassdefs(min_visibility: MVisibility): Set[MClassDef] do
+ var res = new HashSet[MClassDef]
+ var lst = in_nesting.direct_smallers
+ for mmodule in mmodules do res.add_all mmodule.intro_mclassdefs(min_visibility)
+ for mgrp in lst do res.add_all mgrp.in_nesting_intro_mclassdefs(min_visibility)
+ return res
+ end
+
+ fun in_nesting_redef_mclassdefs(min_visibility: MVisibility): Set[MClassDef] do
+ var res = new HashSet[MClassDef]
+ var lst = in_nesting.direct_smallers
+ for mmodule in mmodules do res.add_all mmodule.redef_mclassdefs(min_visibility)
+ for mgrp in lst do res.add_all mgrp.in_nesting_redef_mclassdefs(min_visibility)
+ return res
+ end
+
+ # Collect nested modules
+ fun collect_mmodules: Set[MModule] do
+ var res = new HashSet[MModule]
+ res.add_all mmodules
+ for mgroup in in_nesting.direct_smallers do
+ res.add_all mgroup.collect_mmodules
+ end
+ return res
+ end
+end
+
redef class MModule
+
+ # The list of intro mclassdef in the module.
+ # with visibility >= to min_visibility
+ fun intro_mclassdefs(min_visibility: MVisibility): Set[MClassDef] do
+ var res = new HashSet[MClassDef]
+ for mclassdef in mclassdefs do
+ if not mclassdef.is_intro then continue
+ if mclassdef.mclass.visibility < min_visibility then continue
+ res.add mclassdef
+ end
+ return res
+ end
+
+ # The list of redef mclassdef in the module.
+ # with visibility >= to min_visibility
+ fun redef_mclassdefs(min_visibility: MVisibility): Set[MClassDef] do
+ var res = new HashSet[MClassDef]
+ for mclassdef in mclassdefs do
+ if mclassdef.is_intro then continue
+ if mclassdef.mclass.visibility < min_visibility then continue
+ res.add mclassdef
+ end
+ return res
+ end
+
+ # The list of intro mclass in the module.
+ # with visibility >= to min_visibility
+ fun filter_intro_mclasses(min_visibility: MVisibility): Set[MClass] do
+ var res = new HashSet[MClass]
+ for mclass in intro_mclasses do
+ if mclass.visibility < min_visibility then continue
+ res.add mclass
+ end
+ return res
+ end
+
# Get the list of mclasses refined in 'self'.
fun redef_mclasses: Set[MClass] do
var mclasses = new HashSet[MClass]
return mclasses
end
+ # Get the list of mclasses refined in 'self'.
+ fun filter_redef_mclasses(min_visibility: MVisibility): Set[MClass] do
+ var mclasses = new HashSet[MClass]
+ for c in mclassdefs do
+ if c.mclass.visibility < min_visibility then continue
+ if not c.is_intro then mclasses.add(c.mclass)
+ end
+ return mclasses
+ end
+
# Get the list of all mclasses imported by 'self'.
fun imported_mclasses: Set[MClass] do
var mclasses = new HashSet[MClass]
end
return mclasses
end
+
+ fun in_nesting_intro_mclasses(min_visibility: MVisibility): Set[MClass] do
+ var res = new HashSet[MClass]
+ for mmodule in in_nesting.greaters do
+ for mclass in mmodule.filter_intro_mclasses(min_visibility) do
+ if mclass.visibility < min_visibility then continue
+ res.add mclass
+ end
+ end
+ return res
+ end
+
+ fun in_nesting_redef_mclasses(min_visibility: MVisibility): Set[MClass] do
+ var res = new HashSet[MClass]
+ for mmodule in self.in_nesting.greaters do
+ for mclass in mmodule.filter_redef_mclasses(min_visibility) do
+ if mclass.visibility < min_visibility then continue
+ res.add mclass
+ end
+ end
+ return res
+ end
+
+ fun in_nesting_intro_mclassdefs(min_visibility: MVisibility): Set[MClassDef] do
+ var res = new HashSet[MClassDef]
+ for mmodule in in_nesting.greaters do
+ res.add_all mmodule.intro_mclassdefs(min_visibility)
+ end
+ return res
+ end
+
+ fun in_nesting_redef_mclassdefs(min_visibility: MVisibility): Set[MClassDef] do
+ var res = new HashSet[MClassDef]
+ for mmodule in self.in_nesting.greaters do
+ res.add_all mmodule.redef_mclassdefs(min_visibility)
+ end
+ return res
+ end
end
redef class MClass
return set
end
+ fun intro_mpropdefs(min_visibility: MVisibility): Set[MPropDef] do
+ var set = new HashSet[MPropDef]
+ for mclassdef in mclassdefs do
+ for mpropdef in mclassdef.mpropdefs do
+ if not mpropdef.is_intro then continue
+ if mpropdef.mproperty.visibility < min_visibility then continue
+ set.add(mpropdef)
+ end
+ end
+ return set
+ end
+
# the set of locally refined properties in 'self'.
fun redef_mproperties(min_visibility: MVisibility): Set[MProperty] do
var set = new HashSet[MProperty]
return set
end
+ fun redef_mpropdefs(min_visibility: MVisibility): Set[MPropDef] do
+ var set = new HashSet[MPropDef]
+ for mclassdef in mclassdefs do
+ for mpropdef in mclassdef.mpropdefs do
+ if mpropdef.is_intro then continue
+ if mpropdef.mproperty.visibility < min_visibility then continue
+ set.add(mpropdef)
+ end
+ end
+ return set
+ end
+
# the set of methods inherited by 'self'.
fun inherited_mproperties(mainmodule: MModule, min_visibility: MVisibility): Set[MProperty] do
var set = new HashSet[MProperty]
fun is_nullable: Bool do return intro.static_mtype isa MNullableType
end
-# Sorters
-
-# Sort mmodules by their name
-class MModuleNameSorter
- super AbstractSorter[MModule]
- redef fun compare(a, b) do return a.name <=> b.name
- init do end
+redef class MClassDef
+ # modifiers are keywords like redef, private etc.
+ fun modifiers: Array[String] do
+ var res = new Array[String]
+ if not is_intro then
+ res.add "redef"
+ else
+ res.add mclass.visibility.to_s
+ end
+ res.add mclass.kind.to_s
+ return res
+ end
end
-# Sort mclasses by their name
-class MClassNameSorter
- super AbstractSorter[MClass]
- redef fun compare(a, b) do return a.name <=> b.name
- init do end
+redef class MPropDef
+ # modifiers are keywords like redef, private etc.
+ fun modifiers: Array[String] do
+ var res = new Array[String]
+ if not is_intro then
+ res.add "redef"
+ else
+ res.add mproperty.visibility.to_s
+ end
+ var mprop = self
+ if mprop isa MVirtualTypeDef then
+ res.add "type"
+ else if mprop isa MMethodDef then
+ if mprop.is_abstract then
+ res.add "abstract"
+ else if mprop.is_intern then
+ res.add "intern"
+ end
+ if mprop.mproperty.is_init then
+ res.add "init"
+ else
+ res.add "fun"
+ end
+ end
+ return res
+ end
end
-# Sort mclassdefs by their name
-class MClassDefNameSorter
- super AbstractSorter[MClassDef]
- redef fun compare(a, b) do return a.mclass.name <=> b.mclass.name
- init do end
-end
-# Sort mproperties by their name
-class MPropertyNameSorter
- super AbstractSorter[MProperty]
+# Sorters
+
+# Sort mentities by their name
+class MEntityNameSorter
+ super AbstractSorter[MEntity]
redef fun compare(a, b) do return a.name <=> b.name
init do end
end
-# Sort mpropdefs by their name
-class MPropDefNameSorter
- super AbstractSorter[MPropDef]
- redef fun compare(a, b) do return a.mproperty.name <=> b.mproperty.name
- init do end
-end