redef fun process_mainmodule(mainmodule, given_mmodules) do
print toolcontext.format_h1("--- Code Smells Metrics ---")
+ var model = toolcontext.modelbuilder.model
var filter = new ModelFilter(private_visibility)
- var view = new ModelView(toolcontext.modelbuilder.model, mainmodule, filter)
- self.set_all_average_metrics(view)
- var mclass_codesmell = new BadConceptonController(view)
+ self.set_all_average_metrics(model)
+ var mclass_codesmell = new BadConceptonController(model, filter)
var collect = new Counter[MClassDef]
var mclassdefs = new Array[MClassDef]
end
end
- fun set_all_average_metrics(view: ModelView) do
+ fun set_all_average_metrics(model: Model) do
var model_builder = toolcontext.modelbuilder
- self.average_number_of_lines = view.get_avg_linenumber(model_builder)
- self.average_number_of_parameter = view.get_avg_parameter
- self.average_number_of_method = view.get_avg_method
- self.average_number_of_attribute = view.get_avg_attribut
+ self.average_number_of_lines = model.get_avg_linenumber(model_builder)
+ self.average_number_of_parameter = model.get_avg_parameter
+ self.average_number_of_method = model.get_avg_method
+ self.average_number_of_attribute = model.get_avg_attribut
end
end
class BadConceptonController
- var view: ModelView
+ var model: Model
+
+ var filter: ModelFilter
# Code smell list
var bad_conception_elements = new Array[BadConceptionFinder]
# Collect method take Array of mclassdef to find the code smells for every class
fun collect(mclassdefs: Array[MClassDef],phase: CodeSmellsMetricsPhase) do
for mclassdef in mclassdefs do
- var bad_conception_class = new BadConceptionFinder(mclassdef, phase, view)
+ var bad_conception_class = new BadConceptionFinder(mclassdef, phase, model, filter)
bad_conception_class.collect
bad_conception_elements.add(bad_conception_class)
end
var mclassdef: MClassDef
var array_badconception = new Array[BadConception]
var phase: CodeSmellsMetricsPhase
- var view: ModelView
+ var model: Model
+ var filter: ModelFilter
var score = 0.0
# Collect code smell with selected toolcontext option
fun collect do
var bad_conception_elements = new Array[BadConception]
# Check toolcontext option
- if phase.toolcontext.opt_feature_envy.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new FeatureEnvy(phase, view))
- if phase.toolcontext.opt_long_method.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LongMethod(phase, view))
- if phase.toolcontext.opt_long_params.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LongParameterList(phase, view))
- if phase.toolcontext.opt_no_abstract_implementation.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new NoAbstractImplementation(phase, view))
- if phase.toolcontext.opt_large_class.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LargeClass(phase, view))
+ if phase.toolcontext.opt_feature_envy.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new FeatureEnvy(phase, model, filter))
+ if phase.toolcontext.opt_long_method.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LongMethod(phase, model, filter))
+ if phase.toolcontext.opt_long_params.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LongParameterList(phase, model, filter))
+ if phase.toolcontext.opt_no_abstract_implementation.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new NoAbstractImplementation(phase, model, filter))
+ if phase.toolcontext.opt_large_class.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LargeClass(phase, model, filter))
# Collected all code smell if their state is true
for bad_conception_element in bad_conception_elements do
if bad_conception_element.collect(self.mclassdef,phase.toolcontext.modelbuilder) then array_badconception.add(bad_conception_element)
abstract class BadConception
var phase: CodeSmellsMetricsPhase
- var view: ModelView
+ var model: Model
+
+ var filter: ModelFilter
var score = 0.0
redef fun desc do return "Large class"
redef fun collect(mclassdef, model_builder): Bool do
- self.number_attribut = mclassdef.collect_intro_and_redef_mattributes(view).length
+ self.number_attribut = mclassdef.collect_intro_and_redef_mattributes(filter).length
# Get the number of methods (Accessor include) (subtract the get and set of attibutes with (numberAtribut*2))
- self.number_method = mclassdef.collect_intro_and_redef_methods(view).length
+ self.number_method = mclassdef.collect_intro_and_redef_methods(filter).length
self.score_rate
return self.number_method.to_f > phase.average_number_of_method and self.number_attribut.to_f > phase.average_number_of_attribute
end
redef fun desc do return "Long parameter list"
redef fun collect(mclassdef, model_builder): Bool do
- for meth in mclassdef.collect_intro_and_redef_mpropdefs(view) do
+ for meth in mclassdef.collect_intro_and_redef_mpropdefs(filter) do
var threshold_value = 4
# Get the threshold value from the toolcontext command
if phase.toolcontext.opt_long_params_threshold.value != 0 then threshold_value = phase.toolcontext.opt_long_params_threshold.value
redef fun desc do return "Feature envy"
redef fun collect(mclassdef, model_builder): Bool do
- var mmethoddefs = call_analyze_methods(mclassdef,model_builder, view)
+ var mmethoddefs = call_analyze_methods(mclassdef,model_builder, filter)
for mmethoddef in mmethoddefs do
var max_class_call = mmethoddef.class_call.max
# Check if the class with the maximum call is >= auto-call and the maximum call class is != of this class
redef fun desc do return "Long method"
redef fun collect(mclassdef, model_builder): Bool do
- var mmethoddefs = call_analyze_methods(mclassdef,model_builder, view)
+ var mmethoddefs = call_analyze_methods(mclassdef,model_builder, filter)
var threshold_value = phase.average_number_of_lines.to_i
# Get the threshold value from the toolcontext command
if phase.toolcontext.opt_long_method_threshold.value != 0 then threshold_value = phase.toolcontext.opt_long_method_threshold.value
redef fun collect(mclassdef, model_builder): Bool do
if not mclassdef.mclass.is_abstract and not mclassdef.mclass.is_interface then
- if mclassdef.collect_abstract_methods(view).not_empty then
- bad_methods.add_all(mclassdef.collect_not_define_properties(view))
+ if mclassdef.collect_abstract_methods(filter).not_empty then
+ bad_methods.add_all(mclassdef.collect_not_define_properties(filter))
end
end
self.score_rate
end
end
-redef class ModelView
+redef class Model
fun get_avg_parameter: Float do
var counter = new Counter[MMethodDef]
- for mclassdef in mclassdefs do
- for method in mclassdef.collect_intro_and_redef_mpropdefs(self) do
+ var filter = new ModelFilter
+ for mclassdef in collect_mclassdefs(filter) do
+ for method in mclassdef.collect_intro_and_redef_mpropdefs(filter) do
# check if the property is a method definition
if not method isa MMethodDef then continue
#Check if method has a signature
fun get_avg_attribut: Float do
var counter = new Counter[MClassDef]
- for mclassdef in mclassdefs do
- var number_attributs = mclassdef.collect_intro_and_redef_mattributes(self).length
+ var filter = new ModelFilter
+ for mclassdef in collect_mclassdefs(filter) do
+ var number_attributs = mclassdef.collect_intro_and_redef_mattributes(filter).length
if number_attributs != 0 then counter[mclassdef] = number_attributs
end
return counter.avg + counter.std_dev
fun get_avg_method: Float do
var counter = new Counter[MClassDef]
- for mclassdef in mclassdefs do
- var number_methodes = mclassdef.collect_intro_and_redef_methods(self).length
+ var filter = new ModelFilter
+ for mclassdef in collect_mclassdefs(filter) do
+ var number_methodes = mclassdef.collect_intro_and_redef_methods(filter).length
if number_methodes != 0 then counter[mclassdef] = number_methodes
end
return counter.avg + counter.std_dev
fun get_avg_linenumber(model_builder: ModelBuilder): Float do
var methods_analyse_metrics = new Counter[MClassDef]
- for mclassdef in mclassdefs do
+ var filter = new ModelFilter
+ for mclassdef in collect_mclassdefs(filter) do
var result = 0
var count = 0
- for mmethoddef in call_analyze_methods(mclassdef,model_builder, self) do
+ for mmethoddef in call_analyze_methods(mclassdef,model_builder, filter) do
result += mmethoddef.line_number
if mmethoddef.line_number == 0 then continue
count += 1
end
- if not mclassdef.collect_local_mproperties(self).length != 0 then continue
+ if not mclassdef.collect_local_mproperties(filter).length != 0 then continue
if count == 0 then continue
methods_analyse_metrics[mclassdef] = (result/count).to_i
end
out.mkdir
var model = toolcontext.modelbuilder.model
- var model_view = new ModelView(model, mainmodule)
+ var filter = new ModelFilter(min_visibility = private_visibility)
print toolcontext.format_h1("\n# Inheritance metrics")
var hmetrics = new MetricSet
- hmetrics.register(new MDUI(model_view))
- hmetrics.register(new MDUIC(model_view))
- hmetrics.register(new MDUII(model_view))
- hmetrics.register(new MIF(model_view))
- hmetrics.register(new MIFC(model_view))
- hmetrics.register(new MIFI(model_view))
+ hmetrics.register(new MDUI(model, mainmodule))
+ hmetrics.register(new MDUIC(model, mainmodule))
+ hmetrics.register(new MDUII(model, mainmodule))
+ hmetrics.register(new MIF(model, mainmodule))
+ hmetrics.register(new MIFC(model, mainmodule))
+ hmetrics.register(new MIFI(model, mainmodule))
var cmetrics = new MetricSet
- cmetrics.register(new CNOAC(model_view))
- cmetrics.register(new CNOPC(model_view))
- cmetrics.register(new CNOCC(model_view))
- cmetrics.register(new CNODC(model_view))
- cmetrics.register(new CNOPI(model_view))
- cmetrics.register(new CNOCI(model_view))
- cmetrics.register(new CNODI(model_view))
- cmetrics.register(new CDITC(model_view))
- cmetrics.register(new CDITI(model_view))
+ cmetrics.register(new CNOAC(model, mainmodule, filter))
+ cmetrics.register(new CNOPC(model, mainmodule, filter))
+ cmetrics.register(new CNOCC(model, mainmodule, filter))
+ cmetrics.register(new CNODC(model, mainmodule, filter))
+ cmetrics.register(new CNOPI(model, mainmodule, filter))
+ cmetrics.register(new CNOCI(model, mainmodule, filter))
+ cmetrics.register(new CNODI(model, mainmodule, filter))
+ cmetrics.register(new CDITC(model, mainmodule, filter))
+ cmetrics.register(new CDITI(model, mainmodule, filter))
var mmodules = new HashSet[MModule]
var mclasses = new HashSet[MClass]
for mmodule in mmodules do
var count = 0
for mclass in mmodule.intro_mclasses do
- if mclass.in_hierarchy(model_view.mainmodule).greaters.length > 2 then count += 1
+ if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
end
if mmodule.intro_mclasses.is_empty then
values[mmodule] = 0.0
var nb = 0
for mclass in mmodule.intro_mclasses do
if mclass.kind == abstract_kind or mclass.kind == concrete_kind or mclass.kind == extern_kind then
- if mclass.in_hierarchy(model_view.mainmodule).greaters.length > 2 then count += 1
+ if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
end
nb += 1
end
var nb = 0
for mclass in mmodule.intro_mclasses do
if mclass.kind == interface_kind then
- if mclass.in_hierarchy(model_view.mainmodule).greaters.length > 2 then count += 1
+ if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
end
nb += 1
end
for mmodule in mmodules do
var count = 0
for mclass in mmodule.intro_mclasses do
- if mclass.in_hierarchy(model_view.mainmodule).direct_smallers.length > 0 then count += 1
+ if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
end
if mmodule.intro_mclasses.is_empty then
values[mmodule] = 0.0
var nb = 0
for mclass in mmodule.intro_mclasses do
if mclass.kind == abstract_kind or mclass.kind == concrete_kind or mclass.kind == extern_kind then
- if mclass.in_hierarchy(model_view.mainmodule).direct_smallers.length > 0 then count += 1
+ if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
end
nb += 1
end
var nb = 0
for mclass in mmodule.intro_mclasses do
if mclass.kind == interface_kind then
- if mclass.in_hierarchy(model_view.mainmodule).direct_smallers.length > 0 then count += 1
+ if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
end
nb += 1
end
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).greaters do
+ for parent in mclass.in_hierarchy(mainmodule).greaters do
if parent == mclass then continue
if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).direct_greaters do
+ for parent in mclass.in_hierarchy(mainmodule).direct_greaters do
if parent == mclass then continue
if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).direct_smallers do
+ for parent in mclass.in_hierarchy(mainmodule).direct_smallers do
if parent == mclass then continue
if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).smallers do
+ for parent in mclass.in_hierarchy(mainmodule).smallers do
if parent == mclass then continue
if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).greaters do
+ for parent in mclass.in_hierarchy(mainmodule).greaters do
if parent == mclass then continue
if parent.kind == abstract_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).greaters do
+ for parent in mclass.in_hierarchy(mainmodule).greaters do
if parent == mclass then continue
if parent.kind == interface_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).direct_greaters do
+ for parent in mclass.in_hierarchy(mainmodule).direct_greaters do
if parent == mclass then continue
if parent.kind == interface_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).direct_smallers do
+ for parent in mclass.in_hierarchy(mainmodule).direct_smallers do
if parent == mclass then continue
if parent.kind == interface_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
var count = 0
- for parent in mclass.in_hierarchy(model_view.mainmodule).smallers do
+ for parent in mclass.in_hierarchy(mainmodule).smallers do
if parent == mclass then continue
if parent.kind == interface_kind then
count += 1
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.ditc(model_view.mainmodule)
+ values[mclass] = mclass.ditc(mainmodule)
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.diti(model_view.mainmodule)
+ values[mclass] = mclass.diti(mainmodule)
end
end
end
# We usualy need specific phases
# NOTE: `frontend` is sufficent in most case (it is often too much)
import frontend
-import model_views
import model_collect
redef class MClassDef
# Collect all mproperties introduced in 'self' with `visibility >= min_visibility`.
- fun collect_intro_mproperties(view: ModelView): Set[MProperty] do
+ fun collect_intro_mproperties(filter: ModelFilter): Set[MProperty] do
var set = new HashSet[MProperty]
for mprop in self.intro_mproperties do
- if not view.accept_mentity(mprop) then continue
+ if not filter.accept_mentity(mprop) then continue
set.add(mprop)
end
return set
end
# Collect mmethods introduced in 'self' with `visibility >= min_visibility`.
- fun collect_intro_mmethods(view: ModelView): Set[MMethod] do
+ fun collect_intro_mmethods(filter: ModelFilter): Set[MMethod] do
var res = new HashSet[MMethod]
- for mproperty in collect_intro_mproperties(view) do
- if not view.accept_mentity(mproperty) then continue
+ for mproperty in collect_intro_mproperties(filter) do
+ if not filter.accept_mentity(mproperty) then continue
if mproperty isa MMethod then res.add(mproperty)
end
return res
end
# Collect mmethods redefined in 'self' with `visibility >= min_visibility`.
- fun collect_redef_mmethods(view: ModelView): Set[MMethod] do
+ fun collect_redef_mmethods(filter: ModelFilter): Set[MMethod] do
var res = new HashSet[MMethod]
- for mproperty in collect_redef_mproperties(view) do
- if not view.accept_mentity(mproperty) then continue
+ for mproperty in collect_redef_mproperties(filter) do
+ if not filter.accept_mentity(mproperty) then continue
if mproperty isa MMethod then res.add(mproperty)
end
return res
end
# Collect mattributes redefined in 'self' with `visibility >= min_visibility`.
- fun collect_redef_mattributes(view: ModelView): Set[MAttribute] do
+ fun collect_redef_mattributes(filter: ModelFilter): Set[MAttribute] do
var res = new HashSet[MAttribute]
- for mproperty in collect_redef_mproperties(view) do
- if not view.accept_mentity(mproperty) then continue
+ for mproperty in collect_redef_mproperties(filter) do
+ if not filter.accept_mentity(mproperty) then continue
if mproperty isa MAttribute then res.add(mproperty)
end
return res
end
# Collect mattributes introduced in 'self' with `visibility >= min_visibility`.
- fun collect_intro_mattributes(view: ModelView): Set[MAttribute] do
+ fun collect_intro_mattributes(filter: ModelFilter): Set[MAttribute] do
var res = new HashSet[MAttribute]
- for mproperty in collect_intro_mproperties(view) do
- if not view.accept_mentity(mproperty) then continue
+ for mproperty in collect_intro_mproperties(filter) do
+ if not filter.accept_mentity(mproperty) then continue
if mproperty isa MAttribute then res.add(mproperty)
end
return res
end
# Collect all mproperties redefined in 'self' with `visibility >= min_visibility`.
- fun collect_redef_mproperties(view: ModelView): Set[MProperty] do
+ fun collect_redef_mproperties(filter: ModelFilter): Set[MProperty] do
var set = new HashSet[MProperty]
for mpropdef in self.mpropdefs do
- if not view.accept_mentity(mpropdef) then continue
+ if not filter.accept_mentity(mpropdef) then continue
if mpropdef.mproperty.intro_mclassdef.mclass == self then continue
set.add(mpropdef.mproperty)
end
return set
end
- # Collect mmethods inherited by 'self' if accepted by `view`.
- fun collect_inherited_mmethods(view: ModelView): Set[MMethod] do
+ # Collect mmethods inherited by 'self' if accepted by `filter`.
+ fun collect_inherited_mmethods(mainmodule: MModule, filter: ModelFilter): Set[MMethod] do
var res = new HashSet[MMethod]
- for mproperty in collect_inherited_mproperties(view) do
- if not view.accept_mentity(mproperty) then continue
+ for mproperty in collect_inherited_mproperties(mainmodule, filter) do
+ if not filter.accept_mentity(mproperty) then continue
if mproperty isa MMethod then res.add(mproperty)
end
return res
end
# Collect mproperties introduced and redefined in 'self' with `visibility >= min_visibility`.
- fun collect_local_mproperties(view: ModelView): Set[MProperty] do
+ fun collect_local_mproperties(filter: ModelFilter): Set[MProperty] do
var set = new HashSet[MProperty]
- set.add_all collect_intro_mproperties(view)
- set.add_all collect_redef_mproperties(view)
+ set.add_all collect_intro_mproperties(filter)
+ set.add_all collect_redef_mproperties(filter)
return set
end
# Collect all mproperties inehrited by 'self' with `visibility >= min_visibility`.
- fun collect_inherited_mproperties(view: ModelView): Set[MProperty] do
+ fun collect_inherited_mproperties(mainmodule: MModule, filter: ModelFilter): Set[MProperty] do
var set = new HashSet[MProperty]
- for parent in collect_parents(view) do
- set.add_all(parent.collect_intro_mproperties(view))
- set.add_all(parent.collect_inherited_mproperties(view))
+ for parent in collect_parents(mainmodule, filter) do
+ set.add_all(parent.collect_intro_mproperties(filter))
+ set.add_all(parent.collect_inherited_mproperties(mainmodule, filter))
end
return set
end
# Collect mattributes inherited by 'self' with `visibility >= min_visibility`.
- fun collect_inherited_mattributes(view: ModelView): Set[MAttribute] do
+ fun collect_inherited_mattributes(mainmodule: MModule, filter: ModelFilter): Set[MAttribute] do
var res = new HashSet[MAttribute]
- for mproperty in collect_inherited_mproperties(view) do
- if not view.accept_mentity(mproperty) then continue
+ for mproperty in collect_inherited_mproperties(mainmodule, filter) do
+ if not filter.accept_mentity(mproperty) then continue
if mproperty isa MAttribute then res.add(mproperty)
end
return res
end
# Collect all mmethod inehrited,intro and redef
- fun collect_all_methods(view: ModelView): Set[MMethod] do
+ fun collect_all_methods(mainmodule: MModule, filter: ModelFilter): Set[MMethod] do
var set = new HashSet[MMethod]
- set.add_all collect_intro_mmethods(view)
- set.add_all collect_redef_mmethods(view)
- set.add_all collect_inherited_mmethods(view)
+ set.add_all collect_intro_mmethods(filter)
+ set.add_all collect_redef_mmethods(filter)
+ set.add_all collect_inherited_mmethods(mainmodule, filter)
return set
end
# Collect all mattributs inehrited,intro and redef
- fun collect_all_mattributes(view: ModelView): Set[MAttribute] do
+ fun collect_all_mattributes(mainmodule: MModule, filter: ModelFilter): Set[MAttribute] do
var set = new HashSet[MAttribute]
- set.add_all collect_redef_mattributes(view)
- set.add_all collect_intro_mattributes(view)
- set.add_all collect_inherited_mattributes(view)
+ set.add_all collect_redef_mattributes(filter)
+ set.add_all collect_intro_mattributes(filter)
+ set.add_all collect_inherited_mattributes(mainmodule, filter)
return set
end
# Collect intro and redef mmethods
- fun collect_intro_and_redef_methods(view: ModelView): Set[MMethod] do
+ fun collect_intro_and_redef_methods(filter: ModelFilter): Set[MMethod] do
var set = new HashSet[MMethod]
- set.add_all collect_intro_mmethods(view)
- set.add_all collect_redef_mmethods(view)
+ set.add_all collect_intro_mmethods(filter)
+ set.add_all collect_redef_mmethods(filter)
return set
end
# Collect intro and redef mattributs
- fun collect_intro_and_redef_mattributes(view: ModelView): Set[MAttribute] do
+ fun collect_intro_and_redef_mattributes(filter: ModelFilter): Set[MAttribute] do
var set = new HashSet[MAttribute]
- set.add_all collect_redef_mattributes(view)
- set.add_all collect_intro_mattributes(view)
+ set.add_all collect_redef_mattributes(filter)
+ set.add_all collect_intro_mattributes(filter)
return set
end
# Collect intro and redef mpropdefs
- fun collect_intro_and_redef_mpropdefs(view: ModelView): Set[MPropDef] do
+ fun collect_intro_and_redef_mpropdefs(filter: ModelFilter): Set[MPropDef] do
var set = new HashSet[MPropDef]
- set.add_all collect_intro_mpropdefs(view)
- set.add_all collect_redef_mpropdefs(view)
+ set.add_all collect_intro_mpropdefs(filter)
+ set.add_all collect_redef_mpropdefs(filter)
return set
end
# Collect intro abstract mmethodDef
- fun collect_abstract_methods(view: ModelView): Set[MMethodDef] do
+ fun collect_abstract_methods(filter: ModelFilter): Set[MMethodDef] do
var set = new HashSet[MMethodDef]
- var mpropdefs = collect_intro_mpropdefs(view)
+ var mpropdefs = collect_intro_mpropdefs(filter)
for mpropdef in mpropdefs do
if mpropdef isa MMethodDef then
if mpropdef.is_abstract then set.add(mpropdef)
end
# Collect not defined properties
- fun collect_not_define_properties(view: ModelView):Set[MMethodDef] do
+ fun collect_not_define_properties(filter: ModelFilter):Set[MMethodDef] do
var set = new HashSet[MMethodDef]
- for mpropdef in collect_abstract_methods(view) do
+ for mpropdef in collect_abstract_methods(filter) do
var redef_count = 0
for mprop in mpropdef.mproperty.mpropdefs do
if mprop.is_abstract then continue
var model = toolcontext.modelbuilder.model
var filter = new ModelFilter(private_visibility)
- var model_view = new ModelView(model, mainmodule, filter)
print toolcontext.format_h1("\n# MClasses metrics")
var metrics = new MetricSet
- metrics.register(new CNOA(model_view))
- metrics.register(new CNOP(model_view))
- metrics.register(new CNOC(model_view))
- metrics.register(new CNOD(model_view))
- metrics.register(new CDIT(model_view))
- metrics.register(new CNBP(model_view))
- metrics.register(new CNBA(model_view))
- metrics.register(new CNBI(model_view))
- metrics.register(new CNBM(model_view))
- metrics.register(new CNBV(model_view))
- metrics.register(new CNBIP(model_view))
- metrics.register(new CNBRP(model_view))
- metrics.register(new CNBHP(model_view))
+ metrics.register(new CNOA(model, mainmodule, filter))
+ metrics.register(new CNOP(model, mainmodule, filter))
+ metrics.register(new CNOC(model, mainmodule, filter))
+ metrics.register(new CNOD(model, mainmodule, filter))
+ metrics.register(new CDIT(model, mainmodule, filter))
+ metrics.register(new CNBP(model, mainmodule, filter))
+ metrics.register(new CNBA(model, mainmodule, filter))
+ metrics.register(new CNBI(model, mainmodule, filter))
+ metrics.register(new CNBM(model, mainmodule, filter))
+ metrics.register(new CNBV(model, mainmodule, filter))
+ metrics.register(new CNBIP(model, mainmodule, filter))
+ metrics.register(new CNBRP(model, mainmodule, filter))
+ metrics.register(new CNBHP(model, mainmodule, filter))
var mclasses = new HashSet[MClass]
for mpackage in model.mpackages do
super Metric
redef type ELM: MClass
- # Model view used to collect and filter entities
- var model_view: ModelView
+ # Model used to collect and filter entities
+ var model: Model
+
+ # Mainmodule for class linearization
+ var mainmodule: MModule
+
+ # Filter to apply
+ var filter: nullable ModelFilter
end
# Class Metric: Number of Ancestors
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(model_view.mainmodule).greaters.length - 1
+ values[mclass] = mclass.in_hierarchy(mainmodule).greaters.length - 1
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(model_view.mainmodule).direct_greaters.length
+ values[mclass] = mclass.in_hierarchy(mainmodule).direct_greaters.length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(model_view.mainmodule).direct_smallers.length
+ values[mclass] = mclass.in_hierarchy(mainmodule).direct_smallers.length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(model_view.mainmodule).smallers.length - 1
+ values[mclass] = mclass.in_hierarchy(mainmodule).smallers.length - 1
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(model_view.mainmodule).depth
+ values[mclass] = mclass.in_hierarchy(mainmodule).depth
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_accessible_mproperties(model_view).length
+ values[mclass] = mclass.collect_accessible_mproperties(mainmodule, filter).length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_accessible_mattributes(model_view).length
+ values[mclass] = mclass.collect_accessible_mattributes(mainmodule, filter).length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_accessible_mmethods(model_view).length
+ values[mclass] = mclass.collect_accessible_mmethods(mainmodule, filter).length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_accessible_inits(model_view).length
+ values[mclass] = mclass.collect_accessible_inits(mainmodule, filter).length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_accessible_vts(model_view).length
+ values[mclass] = mclass.collect_accessible_vts(mainmodule, filter).length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_intro_mproperties(model_view).length
+ values[mclass] = mclass.collect_intro_mproperties(filter).length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_redef_mproperties(model_view).length
+ values[mclass] = mclass.collect_redef_mproperties(filter).length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_inherited_mproperties(model_view).length
+ values[mclass] = mclass.collect_inherited_mproperties(mainmodule, filter).length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.collect_local_mproperties(model_view).length
+ values[mclass] = mclass.collect_local_mproperties(filter).length
end
end
end
var model = toolcontext.modelbuilder.model
var filter = new ModelFilter(min_visibility = protected_visibility)
- var model_view = new ModelView(model, mainmodule, filter)
var mclasses = new HashSet[MClass]
- for mclass in model_view.mclasses do
+ for mclass in model.collect_mclasses(filter) do
if mclass.is_interface then continue
mclasses.add(mclass)
end
- var cnblp = new CNBLP(model_view)
- var cnvi = new CNVI(model_view)
- var cnvs = new CNVS(model_view)
+ var cnblp = new CNBLP(model, mainmodule, filter)
+ var cnvi = new CNVI(model, mainmodule, filter)
+ var cnvs = new CNVS(model, mainmodule, filter)
var metrics = new MetricSet
metrics.register(cnblp, cnvi, cnvs)
csvh.separator = ';'
csvh.header = ["povr", "ovr", "pext", "ext", "pspe", "spe", "prep", "rep", "eq"]
for mclass in mclasses do
- var povr = mclass.is_pure_overrider(model_view).object_id
- var ovr = mclass.is_overrider(model_view).object_id
- var pext = mclass.is_pure_extender(model_view).object_id
- var ext = mclass.is_extender(model_view).object_id
- var pspe = mclass.is_pure_specializer(model_view).object_id
- var spe = mclass.is_pure_specializer(model_view).object_id
- var prep = mclass.is_pure_replacer(model_view).object_id
- var rep = mclass.is_replacer(model_view).object_id
- var eq = mclass.is_equal(model_view).object_id
+ var povr = mclass.is_pure_overrider(filter).object_id
+ var ovr = mclass.is_overrider(filter).object_id
+ var pext = mclass.is_pure_extender(filter).object_id
+ var ext = mclass.is_extender(filter).object_id
+ var pspe = mclass.is_pure_specializer(filter).object_id
+ var spe = mclass.is_pure_specializer(filter).object_id
+ var prep = mclass.is_pure_replacer(filter).object_id
+ var rep = mclass.is_replacer(filter).object_id
+ var eq = mclass.is_equal(filter).object_id
csvh.add_record(povr, ovr, pext, ext, pspe, spe, prep, rep, eq)
end
csvh.write_to_file("{out}/inheritance_behaviour.csv")
redef fun collect(mclasses) do
for mclass in mclasses do
- var totc = mclass.collect_accessible_mproperties(model_view).length
- var ditc = mclass.in_hierarchy(model_view.mainmodule).depth
+ var totc = mclass.collect_accessible_mproperties(mainmodule, filter).length
+ var ditc = mclass.in_hierarchy(mainmodule).depth
values[mclass] = totc.to_f / (ditc + 1).to_f
end
end
redef fun collect(mmodules) do
for mmodule in mmodules do
- var totc = mmodule.collect_intro_mclassdefs(model_view).length
- totc += mmodule.collect_redef_mclassdefs(model_view).length
+ var totc = mmodule.collect_intro_mclassdefs(filter).length
+ totc += mmodule.collect_redef_mclassdefs(filter).length
var ditc = mmodule.in_importation.depth
values[mmodule] = totc.to_f / (ditc + 1).to_f
end
redef fun desc do return "class novelty index, contribution of the class to its branch in term of introductions"
redef fun collect(mclasses) do
- var cbms = new CBMS(model_view)
+ var cbms = new CBMS(model, mainmodule, filter)
for mclass in mclasses do
# compute branch mean size
- var parents = mclass.in_hierarchy(model_view.mainmodule).direct_greaters
+ var parents = mclass.in_hierarchy(mainmodule).direct_greaters
if parents.length > 0 then
cbms.clear
cbms.collect(new HashSet[MClass].from(parents))
# compute class novelty index
- var locc = mclass.collect_accessible_mproperties(model_view).length
+ var locc = mclass.collect_accessible_mproperties(mainmodule, filter).length
values[mclass] = locc.to_f / cbms.avg
else
values[mclass] = 0.0
redef fun desc do return "module novelty index, contribution of the module to its branch in term of introductions"
redef fun collect(mmodules) do
- var mbms = new MBMS(model_view)
+ var mbms = new MBMS(model, mainmodule, filter)
for mmodule in mmodules do
# compute branch mean size
var parents = mmodule.in_importation.direct_greaters
mbms.clear
mbms.collect(new HashSet[MModule].from(parents))
# compute module novelty index
- var locc = mmodule.collect_intro_mclassdefs(model_view).length
- locc += mmodule.collect_redef_mclassdefs(model_view).length
+ var locc = mmodule.collect_intro_mclassdefs(filter).length
+ locc += mmodule.collect_redef_mclassdefs(filter).length
values[mmodule] = locc.to_f / mbms.avg
else
values[mmodule] = 0.0
redef fun desc do return "class novelty score, importance of the contribution of the class to its branch"
redef fun collect(mclasses) do
- var cnvi = new CNVI(model_view)
+ var cnvi = new CNVI(model, mainmodule, filter)
cnvi.collect(mclasses)
for mclass in mclasses do
- var locc = mclass.collect_local_mproperties(model_view).length
+ var locc = mclass.collect_local_mproperties(filter).length
values[mclass] = cnvi.values[mclass] * locc.to_f
end
end
redef fun desc do return "module novelty score, importance of the contribution of the module to its branch"
redef fun collect(mmodules) do
- var mnvi = new MNVI(model_view)
+ var mnvi = new MNVI(model, mainmodule, filter)
mnvi.collect(mmodules)
for mmodule in mmodules do
- var locc = mmodule.collect_intro_mclassdefs(model_view).length
- locc += mmodule.collect_redef_mclassdefs(model_view).length
+ var locc = mmodule.collect_intro_mclassdefs(filter).length
+ locc += mmodule.collect_redef_mclassdefs(filter).length
values[mmodule] = mnvi.values[mmodule] * locc.to_f
end
end
redef class MClass
# the set of redefition that call to super
- fun extended_mproperties(view: ModelView): Set[MProperty] do
+ fun extended_mproperties(filter: ModelFilter): Set[MProperty] do
var set = new HashSet[MProperty]
for mclassdef in mclassdefs do
for mpropdef in mclassdef.mpropdefs do
- if not view.accept_mentity(mpropdef) then continue
+ if not filter.accept_mentity(mpropdef) then continue
if not mpropdef.has_supercall then continue
if mpropdef.mproperty.intro_mclassdef.mclass != self then set.add(mpropdef.mproperty)
end
end
# the set of redefition that do not call to super
- fun overriden_mproperties(view: ModelView): Set[MProperty] do
+ fun overriden_mproperties(filter: ModelFilter): Set[MProperty] do
var set = new HashSet[MProperty]
for mclassdef in mclassdefs do
for mpropdef in mclassdef.mpropdefs do
- if not view.accept_mentity(mpropdef) then continue
+ if not filter.accept_mentity(mpropdef) then continue
if mpropdef.has_supercall then continue
if mpropdef.mproperty.intro_mclassdef.mclass != self then set.add(mpropdef.mproperty)
end
end
# pure overriders contain only redefinitions
- private fun is_pure_overrider(view: ModelView): Bool do
- var news = collect_intro_mproperties(view).length
- var locs = collect_local_mproperties(view).length
+ private fun is_pure_overrider(filter: ModelFilter): Bool do
+ var news = collect_intro_mproperties(filter).length
+ var locs = collect_local_mproperties(filter).length
if news == 0 and locs > 0 then return true
return false
end
# overriders contain more definitions than introductions
- private fun is_overrider(view: ModelView): Bool do
- var rdfs = collect_redef_mproperties(view).length
- var news = collect_intro_mproperties(view).length
- var locs = collect_local_mproperties(view).length
+ private fun is_overrider(filter: ModelFilter): Bool do
+ var rdfs = collect_redef_mproperties(filter).length
+ var news = collect_intro_mproperties(filter).length
+ var locs = collect_local_mproperties(filter).length
if rdfs >= news and locs > 0 then return true
return false
end
# pure extenders contain only introductions
- private fun is_pure_extender(view: ModelView): Bool do
- var rdfs = collect_redef_mproperties(view).length
- var locs = collect_local_mproperties(view).length
+ private fun is_pure_extender(filter: ModelFilter): Bool do
+ var rdfs = collect_redef_mproperties(filter).length
+ var locs = collect_local_mproperties(filter).length
if rdfs == 0 and locs > 0 then return true
return false
end
# extenders contain more introduction than redefinitions
- private fun is_extender(view: ModelView): Bool do
- var rdfs = collect_redef_mproperties(view).length
- var news = collect_intro_mproperties(view).length
- var locs = collect_local_mproperties(view).length
+ private fun is_extender(filter: ModelFilter): Bool do
+ var rdfs = collect_redef_mproperties(filter).length
+ var news = collect_intro_mproperties(filter).length
+ var locs = collect_local_mproperties(filter).length
if news > rdfs and locs > 0 then return true
return false
end
# pure specializers always call to super in its redefinitions
- private fun is_pure_specializer(view: ModelView): Bool do
- var ovrs = overriden_mproperties(view).length
- var rdfs = collect_redef_mproperties(view).length
+ private fun is_pure_specializer(filter: ModelFilter): Bool do
+ var ovrs = overriden_mproperties(filter).length
+ var rdfs = collect_redef_mproperties(filter).length
if ovrs == 0 and rdfs > 0 then return true
return false
end
# specializers have more redefinitions that call super than not calling it
- private fun is_specializer(view: ModelView): Bool do
- var spcs = extended_mproperties(view).length
- var ovrs = overriden_mproperties(view).length
- var rdfs = collect_redef_mproperties(view).length
+ private fun is_specializer(filter: ModelFilter): Bool do
+ var spcs = extended_mproperties(filter).length
+ var ovrs = overriden_mproperties(filter).length
+ var rdfs = collect_redef_mproperties(filter).length
if spcs > ovrs and rdfs > 0 then return true
return false
end
# pure replacers never call to super in its redefinitions
- private fun is_pure_replacer(view: ModelView): Bool do
- var spcs = extended_mproperties(view).length
- var rdfs = collect_redef_mproperties(view).length
+ private fun is_pure_replacer(filter: ModelFilter): Bool do
+ var spcs = extended_mproperties(filter).length
+ var rdfs = collect_redef_mproperties(filter).length
if spcs == 0 and rdfs > 0 then return true
return false
end
# replacers have less redefinitions that call super than not calling it
- private fun is_replacer(view: ModelView): Bool do
- var spcs = extended_mproperties(view).length
- var ovrs = overriden_mproperties(view).length
- var rdfs = collect_redef_mproperties(view).length
+ private fun is_replacer(filter: ModelFilter): Bool do
+ var spcs = extended_mproperties(filter).length
+ var ovrs = overriden_mproperties(filter).length
+ var rdfs = collect_redef_mproperties(filter).length
if ovrs > spcs and rdfs > 0 then return true
return false
end
# equals contain as redifinition than introduction
- private fun is_equal(view: ModelView): Bool do
- var spcs = extended_mproperties(view).length
- var ovrs = overriden_mproperties(view).length
- var rdfs = collect_redef_mproperties(view).length
+ private fun is_equal(filter: ModelFilter): Bool do
+ var spcs = extended_mproperties(filter).length
+ var ovrs = overriden_mproperties(filter).length
+ var rdfs = collect_redef_mproperties(filter).length
if spcs == ovrs and rdfs > 0 then return true
return false
end
import mclassdef_collect
-fun call_analyze_methods(mclassdef: MClassDef, model_builder: ModelBuilder, view: ModelView): Array[MMethodDef] do
+fun call_analyze_methods(mclassdef: MClassDef, model_builder: ModelBuilder, filter: ModelFilter): Array[MMethodDef] do
var mmethoddefs = new Array[MMethodDef]
- for m_prop in mclassdef.collect_intro_and_redef_mpropdefs(view) do
+ for m_prop in mclassdef.collect_intro_and_redef_mpropdefs(filter) do
var n_prop = model_builder.mpropdef2node(m_prop)
#Check if the property is a method definition
if n_prop isa AMethPropdef and m_prop isa MMethodDef then
out.mkdir
var model = toolcontext.modelbuilder.model
- var model_view = new ModelView(model, mainmodule)
print toolcontext.format_h1("\n# MModules metrics")
var metrics = new MetricSet
- metrics.register(new MNOA(model_view))
- metrics.register(new MNOP(model_view))
- metrics.register(new MNOC(model_view))
- metrics.register(new MNOD(model_view))
- metrics.register(new MDIT(model_view))
- metrics.register(new MNBI(model_view))
- metrics.register(new MNBR(model_view))
- metrics.register(new MNBCC(model_view))
- metrics.register(new MNBAC(model_view))
- metrics.register(new MNBIC(model_view))
+ metrics.register(new MNOA(model, mainmodule))
+ metrics.register(new MNOP(model, mainmodule))
+ metrics.register(new MNOC(model, mainmodule))
+ metrics.register(new MNOD(model, mainmodule))
+ metrics.register(new MDIT(model, mainmodule))
+ metrics.register(new MNBI(model, mainmodule))
+ metrics.register(new MNBR(model, mainmodule))
+ metrics.register(new MNBCC(model, mainmodule))
+ metrics.register(new MNBAC(model, mainmodule))
+ metrics.register(new MNBIC(model, mainmodule))
var mmodules = new HashSet[MModule]
for mpackage in model.mpackages do
redef type ELM: MModule
# Model view used to collect and filter entities
- var model_view: ModelView
+ var model: Model
+
+ # Mainmodule used for linearization
+ var mainmodule: MModule
+
+ # Filter to apply on model if any
+ var filter: nullable ModelFilter
end
# Module Metric: Number of Ancestors
redef fun collect(mmodules) do
for mmodule in mmodules do
values[mmodule] = 0
- for a in mmodule.collect_ancestors(model_view) do
+ for a in mmodule.collect_ancestors(mainmodule, filter) do
values[mmodule] += a.intro_mclasses.length
end
end
var model = toolcontext.modelbuilder.model
var filter = new ModelFilter(private_visibility)
- var model_view = new ModelView(model, mainmodule, filter)
var metrics = new MetricSet
- metrics.register(new CNBA(model_view))
- metrics.register(new CNBNA(model_view))
+ metrics.register(new CNBA(model, mainmodule, filter))
+ metrics.register(new CNBNA(model, mainmodule, filter))
var mclasses = new HashSet[MClass]
for mpackage in model.mpackages do
redef fun collect(mclasses) do
for mclass in mclasses do
- var all = mclass.collect_accessible_mattributes(model_view)
+ var all = mclass.collect_accessible_mattributes(mainmodule, filter)
for mattr in all do
if mattr.is_nullable then values.inc(mclass)
end
var model = toolcontext.modelbuilder.model
var filter = new ModelFilter(min_visibility = protected_visibility)
- var model_view = new ModelView(model, mainmodule, filter)
print toolcontext.format_h1("\n# RTA metrics")
print toolcontext.format_h2("\n ## Live instances by mainmodules")
var mmetrics = new MetricSet
- mmetrics.register(new MNLC(model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLT(model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNCT(model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLI(model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLM(model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLMD(model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLDD(model_view, toolcontext.modelbuilder))
+ mmetrics.register(new MNLC(model, mainmodule, filter, toolcontext.modelbuilder))
+ mmetrics.register(new MNLT(model, mainmodule, filter, toolcontext.modelbuilder))
+ mmetrics.register(new MNCT(model, mainmodule, filter, toolcontext.modelbuilder))
+ mmetrics.register(new MNLI(model, mainmodule, filter, toolcontext.modelbuilder))
+ mmetrics.register(new MNLM(model, mainmodule, filter, toolcontext.modelbuilder))
+ mmetrics.register(new MNLMD(model, mainmodule, filter, toolcontext.modelbuilder))
+ mmetrics.register(new MNLDD(model, mainmodule, filter, toolcontext.modelbuilder))
mmetrics.collect(new HashSet[MModule].from([mainmodule]))
mmetrics.to_console(1, not toolcontext.opt_nocolors.value)
if csv then mmetrics.to_csv.write_to_file("{out}/{mainmodule}.csv")
var mtypes = new HashSet[MType]
- var analysis = new MetricsRapidTypeAnalysis(toolcontext.modelbuilder, mainmodule, model_view)
+ var analysis = new MetricsRapidTypeAnalysis(toolcontext.modelbuilder, mainmodule)
analysis.run_analysis
mtypes.add_all(analysis.live_types)
mtypes.add_all(analysis.live_cast_types)
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
- var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
analysis.run_analysis
values[mainmodule] = analysis.tnli.sum
end
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
- var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
analysis.run_analysis
values[mainmodule] = analysis.live_types.length
end
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
- var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
analysis.run_analysis
values[mainmodule] = analysis.live_cast_types.length
end
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
var live = new HashSet[MClass]
- var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
analysis.run_analysis
for mtype in analysis.live_types do
live.add(mtype.mclass)
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
- var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
analysis.run_analysis
values[mainmodule] = analysis.live_methods.length
end
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
- var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
analysis.run_analysis
values[mainmodule] = analysis.live_methoddefs.length
end
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
var dead = 0
- var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
analysis.run_analysis
for mmethod in analysis.live_methods do
for mdef in mmethod.mpropdefs do
class MetricsRapidTypeAnalysis
super RapidTypeAnalysis
- # Model view used to linearize classes
- var view: ModelView
-
# Class Live Instances
- var cnli: CNLI is lazy do return new CNLI(view)
+ var cnli: CNLI is lazy do return new CNLI(modelbuilder.model, mainmodule)
# Class Live Casts
- var cnlc: CNLC is lazy do return new CNLC(view)
+ var cnlc: CNLC is lazy do return new CNLC(modelbuilder.model, mainmodule)
# Type Live Instances
var tnli = new TNLI
nitlanguage / nit.git / commitdiff