redef fun process_mainmodule(mainmodule, given_mmodules) do
print toolcontext.format_h1("--- Code Smells Metrics ---")
- self.set_all_average_metrics
- var mclass_codesmell = new BadConceptonController
+
+ var view = new ModelView(toolcontext.modelbuilder.model, mainmodule)
+ self.set_all_average_metrics(view)
+ var mclass_codesmell = new BadConceptonController(view)
var collect = new Counter[MClassDef]
var mclassdefs = new Array[MClassDef]
end
end
- fun set_all_average_metrics do
+ fun set_all_average_metrics(view: ModelView) do
var model_builder = toolcontext.modelbuilder
- var model_view = model_builder.model.private_view
- self.average_number_of_lines = model_view.get_avg_linenumber(model_builder)
- self.average_number_of_parameter = model_view.get_avg_parameter
- self.average_number_of_method = model_view.get_avg_method
- self.average_number_of_attribute = model_view.get_avg_attribut
+ 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
end
end
class BadConceptonController
+
+ var view: ModelView
+
# 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)
+ var bad_conception_class = new BadConceptionFinder(mclassdef, phase, view)
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 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))
- if phase.toolcontext.opt_long_method.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LongMethod(phase))
- if phase.toolcontext.opt_long_params.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LongParameterList(phase))
- if phase.toolcontext.opt_no_abstract_implementation.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new NoAbstractImplementation(phase))
- if phase.toolcontext.opt_large_class.value or phase.toolcontext.opt_all.value then bad_conception_elements.add(new LargeClass(phase))
+ 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))
# 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 score = 0.0
# Name
redef fun desc do return "Large class"
redef fun collect(mclassdef, model_builder): Bool do
- self.number_attribut = mclassdef.collect_intro_and_redef_mattributes(model_builder.model.private_view).length
+ self.number_attribut = mclassdef.collect_intro_and_redef_mattributes(view).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(model_builder.model.private_view).length
+ self.number_method = mclassdef.collect_intro_and_redef_methods(view).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(model_builder.model.private_view) do
+ for meth in mclassdef.collect_intro_and_redef_mpropdefs(view) 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)
+ var mmethoddefs = call_analyze_methods(mclassdef,model_builder, view)
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)
+ var mmethoddefs = call_analyze_methods(mclassdef,model_builder, view)
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(model_builder.model.private_view).not_empty then
- bad_methods.add_all(mclassdef.collect_not_define_properties(model_builder.model.private_view))
+ if mclassdef.collect_abstract_methods(view).not_empty then
+ bad_methods.add_all(mclassdef.collect_not_define_properties(view))
end
end
self.score_rate
for mclassdef in mclassdefs do
var result = 0
var count = 0
- for mmethoddef in call_analyze_methods(mclassdef,model_builder) do
+ for mmethoddef in call_analyze_methods(mclassdef,model_builder, self) do
result += mmethoddef.line_number
if mmethoddef.line_number == 0 then continue
count += 1
out.mkdir
var model = toolcontext.modelbuilder.model
- var model_view = model.private_view
+ var model_view = new ModelView(model, mainmodule)
print toolcontext.format_h1("\n# Inheritance metrics")
var hmetrics = new MetricSet
- hmetrics.register(new MDUI(mainmodule, model_view))
- hmetrics.register(new MDUIC(mainmodule, model_view))
- hmetrics.register(new MDUII(mainmodule, model_view))
- hmetrics.register(new MIF(mainmodule, model_view))
- hmetrics.register(new MIFC(mainmodule, model_view))
- hmetrics.register(new MIFI(mainmodule, model_view))
+ 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))
var cmetrics = new MetricSet
- cmetrics.register(new CNOAC(mainmodule, model_view))
- cmetrics.register(new CNOPC(mainmodule, model_view))
- cmetrics.register(new CNOCC(mainmodule, model_view))
- cmetrics.register(new CNODC(mainmodule, model_view))
- cmetrics.register(new CNOPI(mainmodule, model_view))
- cmetrics.register(new CNOCI(mainmodule, model_view))
- cmetrics.register(new CNODI(mainmodule, model_view))
- cmetrics.register(new CDITC(mainmodule, model_view))
- cmetrics.register(new CDITI(mainmodule, model_view))
+ 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))
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(mainmodule).greaters.length > 2 then count += 1
+ if mclass.in_hierarchy(model_view.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(mainmodule).greaters.length > 2 then count += 1
+ if mclass.in_hierarchy(model_view.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(mainmodule).greaters.length > 2 then count += 1
+ if mclass.in_hierarchy(model_view.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(mainmodule).direct_smallers.length > 0 then count += 1
+ if mclass.in_hierarchy(model_view.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(mainmodule).direct_smallers.length > 0 then count += 1
+ if mclass.in_hierarchy(model_view.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(mainmodule).direct_smallers.length > 0 then count += 1
+ if mclass.in_hierarchy(model_view.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(mainmodule).greaters do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule).direct_greaters do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule).direct_smallers do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule).smallers do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule).greaters do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule).greaters do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule).direct_greaters do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule).direct_smallers do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule).smallers do
+ for parent in mclass.in_hierarchy(model_view.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(mainmodule)
+ values[mclass] = mclass.ditc(model_view.mainmodule)
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.diti(mainmodule)
+ values[mclass] = mclass.diti(model_view.mainmodule)
end
end
end
out.mkdir
var model = toolcontext.modelbuilder.model
- var model_view = model.private_view
+ var model_view = new ModelView(model, mainmodule)
print toolcontext.format_h1("\n# MClasses metrics")
var metrics = new MetricSet
- metrics.register(new CNOA(mainmodule, model_view))
- metrics.register(new CNOP(mainmodule, model_view))
- metrics.register(new CNOC(mainmodule, model_view))
- metrics.register(new CNOD(mainmodule, model_view))
- metrics.register(new CDIT(mainmodule, model_view))
- metrics.register(new CNBP(mainmodule, model_view))
- metrics.register(new CNBA(mainmodule, model_view))
- metrics.register(new CNBI(mainmodule, model_view))
- metrics.register(new CNBM(mainmodule, model_view))
- metrics.register(new CNBV(mainmodule, model_view))
- metrics.register(new CNBIP(mainmodule, model_view))
- metrics.register(new CNBRP(mainmodule, model_view))
- metrics.register(new CNBHP(mainmodule, model_view))
+ 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))
var mclasses = new HashSet[MClass]
for mpackage in model.mpackages do
super Metric
redef type ELM: MClass
- # Main module used for class linearization
- var mainmodule: MModule
-
# Model view used to collect and filter entities
var model_view: ModelView
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(mainmodule).greaters.length - 1
+ values[mclass] = mclass.in_hierarchy(model_view.mainmodule).greaters.length - 1
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(mainmodule).direct_greaters.length
+ values[mclass] = mclass.in_hierarchy(model_view.mainmodule).direct_greaters.length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(mainmodule).direct_smallers.length
+ values[mclass] = mclass.in_hierarchy(model_view.mainmodule).direct_smallers.length
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(mainmodule).smallers.length - 1
+ values[mclass] = mclass.in_hierarchy(model_view.mainmodule).smallers.length - 1
end
end
end
redef fun collect(mclasses) do
for mclass in mclasses do
- values[mclass] = mclass.in_hierarchy(mainmodule).depth
+ values[mclass] = mclass.in_hierarchy(model_view.mainmodule).depth
end
end
end
print toolcontext.format_h1("\n# Mendel metrics")
var model = toolcontext.modelbuilder.model
- var model_view = model.protected_view
+ var model_view = new ModelView(model, mainmodule)
+ model_view.min_visibility = protected_visibility
var mclasses = new HashSet[MClass]
for mclass in model_view.mclasses do
mclasses.add(mclass)
end
- var cnblp = new CNBLP(mainmodule, model_view)
- var cnvi = new CNVI(mainmodule, model_view)
- var cnvs = new CNVS(mainmodule, model_view)
+ var cnblp = new CNBLP(model_view)
+ var cnvi = new CNVI(model_view)
+ var cnvs = new CNVS(model_view)
var metrics = new MetricSet
metrics.register(cnblp, cnvi, cnvs)
redef fun collect(mclasses) do
for mclass in mclasses do
var totc = mclass.collect_accessible_mproperties(model_view).length
- var ditc = mclass.in_hierarchy(mainmodule).depth
+ var ditc = mclass.in_hierarchy(model_view.mainmodule).depth
values[mclass] = totc.to_f / (ditc + 1).to_f
end
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(mainmodule, model_view)
+ var cbms = new CBMS(model_view)
for mclass in mclasses do
# compute branch mean size
- var parents = mclass.in_hierarchy(mainmodule).direct_greaters
+ var parents = mclass.in_hierarchy(model_view.mainmodule).direct_greaters
if parents.length > 0 then
cbms.clear
cbms.collect(new HashSet[MClass].from(parents))
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(mainmodule, model_view)
+ var mbms = new MBMS(model_view)
for mmodule in mmodules do
# compute branch mean size
var parents = mmodule.in_importation.direct_greaters
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(mainmodule, model_view)
+ var cnvi = new CNVI(model_view)
cnvi.collect(mclasses)
for mclass in mclasses do
var locc = mclass.collect_local_mproperties(model_view).length
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(mainmodule, model_view)
+ var mnvi = new MNVI(model_view)
mnvi.collect(mmodules)
for mmodule in mmodules do
var locc = mmodule.collect_intro_mclassdefs(model_view).length
import mclassdef_collect
-fun call_analyze_methods(mclassdef: MClassDef, model_builder: ModelBuilder): Array[MMethodDef] do
+fun call_analyze_methods(mclassdef: MClassDef, model_builder: ModelBuilder, view: ModelView): Array[MMethodDef] do
var mmethoddefs = new Array[MMethodDef]
- for m_prop in mclassdef.collect_intro_and_redef_mpropdefs(model_builder.model.private_view) do
+ for m_prop in mclassdef.collect_intro_and_redef_mpropdefs(view) 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 = model.private_view
+ var model_view = new ModelView(model, mainmodule)
print toolcontext.format_h1("\n# MModules metrics")
var metrics = new MetricSet
- metrics.register(new MNOA(mainmodule, model_view))
- metrics.register(new MNOP(mainmodule, model_view))
- metrics.register(new MNOC(mainmodule, model_view))
- metrics.register(new MNOD(mainmodule, model_view))
- metrics.register(new MDIT(mainmodule, model_view))
- metrics.register(new MNBI(mainmodule, model_view))
- metrics.register(new MNBR(mainmodule, model_view))
- metrics.register(new MNBCC(mainmodule, model_view))
- metrics.register(new MNBAC(mainmodule, model_view))
- metrics.register(new MNBIC(mainmodule, model_view))
+ 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))
var mmodules = new HashSet[MModule]
for mpackage in model.mpackages do
super Metric
redef type ELM: MModule
- # Main module used for linearization
- var mainmodule: MModule
-
# Model view used to collect and filter entities
var model_view: ModelView
end
print toolcontext.format_h1("\n# Nullable metrics")
var model = toolcontext.modelbuilder.model
- var model_view = model.private_view
+ var model_view = new ModelView(model, mainmodule)
var metrics = new MetricSet
- metrics.register(new CNBA(mainmodule, model_view))
- metrics.register(new CNBNA(mainmodule, model_view))
+ metrics.register(new CNBA(model_view))
+ metrics.register(new CNBNA(model_view))
var mclasses = new HashSet[MClass]
for mpackage in model.mpackages do
out.mkdir
var model = toolcontext.modelbuilder.model
- var model_view = model.protected_view
+ var model_view = new ModelView(model, mainmodule)
+ model_view.min_visibility = protected_visibility
print toolcontext.format_h1("\n# RTA metrics")
print toolcontext.format_h2("\n ## Live instances by mainmodules")
var mmetrics = new MetricSet
- mmetrics.register(new MNLC(mainmodule, model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLT(mainmodule, model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNCT(mainmodule, model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLI(mainmodule, model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLM(mainmodule, model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLMD(mainmodule, model_view, toolcontext.modelbuilder))
- mmetrics.register(new MNLDD(mainmodule, model_view, toolcontext.modelbuilder))
+ 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.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 RapidTypeAnalysis(toolcontext.modelbuilder, mainmodule)
+ var analysis = new MetricsRapidTypeAnalysis(toolcontext.modelbuilder, mainmodule, model_view)
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 RapidTypeAnalysis(modelbuilder, mainmodule)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
analysis.run_analysis
values[mainmodule] = analysis.tnli.sum
end
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
- var analysis = new RapidTypeAnalysis(modelbuilder, mainmodule)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
analysis.run_analysis
values[mainmodule] = analysis.live_types.length
end
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
- var analysis = new RapidTypeAnalysis(modelbuilder, mainmodule)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
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 RapidTypeAnalysis(modelbuilder, mainmodule)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
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 RapidTypeAnalysis(modelbuilder, mainmodule)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
analysis.run_analysis
values[mainmodule] = analysis.live_methods.length
end
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
- var analysis = new RapidTypeAnalysis(modelbuilder, mainmodule)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
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 RapidTypeAnalysis(modelbuilder, mainmodule)
+ var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule, model_view)
analysis.run_analysis
for mmethod in analysis.live_methods do
for mdef in mmethod.mpropdefs do
# rta redef
-redef class RapidTypeAnalysis
+# Custom RTA analyzer
+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(mainmodule, modelbuilder.model.protected_view)
+ var cnli: CNLI is lazy do return new CNLI(view)
# Class Live Casts
- var cnlc: CNLC is lazy do return new CNLC(mainmodule, modelbuilder.model.protected_view)
+ var cnlc: CNLC is lazy do return new CNLC(view)
# Type Live Instances
var tnli = new TNLI
nitlanguage / nit.git / commitdiff