print toolcontext.format_h1("\n# Inheritance metrics")
var hmetrics = new MetricSet
- hmetrics.register(new MDUI(mainmodule))
- hmetrics.register(new MDUIC(mainmodule))
- hmetrics.register(new MDUII(mainmodule))
- hmetrics.register(new MIF(mainmodule))
- hmetrics.register(new MIFC(mainmodule))
- hmetrics.register(new MIFI(mainmodule))
+ 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))
var cmetrics = new MetricSet
cmetrics.register(new CNOAC(mainmodule, model_view))
redef fun name do return "mdui"
redef fun desc do return "proportion of mclass defined using inheritance (has other parent than Object)"
- var mainmodule: MModule
- init(mainmodule: MModule) do self.mainmodule = mainmodule
-
redef fun collect(mmodules) do
for mmodule in mmodules do
var count = 0
redef fun name do return "mduic"
redef fun desc do return "proportion of class_kind defined using inheritance"
- var mainmodule: MModule
- init(mainmodule: MModule) do self.mainmodule = mainmodule
-
redef fun collect(mmodules) do
for mmodule in mmodules do
var count = 0
redef fun name do return "mduii"
redef fun desc do return "proportion of interface_kind defined using inheritance"
- var mainmodule: MModule
- init(mainmodule: MModule) do self.mainmodule = mainmodule
-
redef fun collect(mmodules) do
for mmodule in mmodules do
var count = 0
redef fun name do return "mif"
redef fun desc do return "proportion of mclass inherited from"
- var mainmodule: MModule
- init(mainmodule: MModule) do self.mainmodule = mainmodule
-
redef fun collect(mmodules) do
for mmodule in mmodules do
var count = 0
redef fun name do return "mifc"
redef fun desc do return "proportion of class_kind inherited from"
- var mainmodule: MModule
- init(mainmodule: MModule) do self.mainmodule = mainmodule
-
redef fun collect(mmodules) do
for mmodule in mmodules do
var count = 0
redef fun name do return "mifi"
redef fun desc do return "proportion of interface_kind inherited from"
- var mainmodule: MModule
- init(mainmodule: MModule) do self.mainmodule = mainmodule
-
redef fun collect(mmodules) do
for mmodule in mmodules do
var count = 0
return min
end
end
-
redef fun collect(mmodules) do
for mmodule in mmodules do
- var totc = mmodule.collect_intro_mclassdefs(mmodule.protected_view).length
- totc += mmodule.collect_redef_mclassdefs(mmodule.protected_view).length
+ var totc = mmodule.collect_intro_mclassdefs(model_view).length
+ totc += mmodule.collect_redef_mclassdefs(model_view).length
var ditc = mmodule.in_importation.depth
values[mmodule] = totc.to_f / (ditc + 1).to_f
end
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
+ var mbms = new MBMS(mainmodule, model_view)
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(mmodule.protected_view).length
- locc += mmodule.collect_redef_mclassdefs(mmodule.protected_view).length
+ var locc = mmodule.collect_intro_mclassdefs(model_view).length
+ locc += mmodule.collect_redef_mclassdefs(model_view).length
values[mmodule] = locc.to_f / mbms.avg
else
values[mmodule] = 0.0
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
+ var mnvi = new MNVI(mainmodule, model_view)
mnvi.collect(mmodules)
for mmodule in mmodules do
- var locc = mmodule.collect_intro_mclassdefs(mmodule.protected_view).length
- locc += mmodule.collect_redef_mclassdefs(mmodule.protected_view).length
+ var locc = mmodule.collect_intro_mclassdefs(model_view).length
+ locc += mmodule.collect_redef_mclassdefs(model_view).length
values[mmodule] = mnvi.values[mmodule] * locc.to_f
end
end
module mmodules_metrics
import metrics_base
+import model::model_collect
redef class ToolContext
+
+ # MModules related metrics phase
var mmodules_metrics_phase: Phase = new MModulesMetricsPhase(self, null)
end
var out = "{toolcontext.opt_dir.value or else "metrics"}/mmodules"
out.mkdir
+ var model = toolcontext.modelbuilder.model
+ var model_view = model.private_view
+
print toolcontext.format_h1("\n# MModules metrics")
var metrics = new MetricSet
- metrics.register(new MNOA, new MNOP, new MNOC, new MNOD, new MDIT)
- metrics.register(new MNBI, new MNBR, new MNBCC, new MNBAC, new MNBIC)
+ 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))
- var model = toolcontext.modelbuilder.model
var mmodules = new HashSet[MModule]
for mpackage in model.mpackages do
end
# A metric about MModule
-interface MModuleMetric
+abstract class MModuleMetric
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
# Module Metric: Number of Ancestors
end
end
end
-
-
import semantize
redef class ToolContext
+
+ # Nullable types related metrics
var nullables_metrics_phase: Phase = new NullablesMetricsPhase(self, null)
end
redef fun name do return "cnbna"
redef fun desc do return "number of accessible nullable attributes (inherited + local)"
- var mainmodule: MModule
- var model_view: ModelView
-
- init(mainmodule: MModule, model_view: ModelView) do
- self.mainmodule = mainmodule
- self.model_view = model_view
- end
-
redef fun collect(mclasses) do
for mclass in mclasses do
var all = mclass.collect_accessible_mattributes(model_view)
private class NullableSends
super Visitor
- var modelbuilder: ModelBuilder
var nclassdef: AClassdef
var total_sends: Int = 0
var nullable_eq_sends: Int = 0
var buggy_sends: Int = 0
- # Get a new visitor on a classef to add type count in `typecount`.
- init(modelbuilder: ModelBuilder, nclassdef: AClassdef)
- do
- self.modelbuilder = modelbuilder
- self.nclassdef = nclassdef
- end
-
redef fun visit(n)
do
n.visit_all(self)
# Visit all the source code to collect data
for nmodule in modelbuilder.nmodules do
for nclassdef in nmodule.n_classdefs do
- var visitor = new NullableSends(modelbuilder, nclassdef)
+ var visitor = new NullableSends(nclassdef)
visitor.enter_visit(nclassdef)
total_sends += visitor.total_sends
nullable_sends += visitor.nullable_sends
import mclasses_metrics
redef class ToolContext
+
+ # RTA related metrics phase
var rta_metrics_phase: Phase = new RTAMetricsPhase(self, null)
end
var out = "{toolcontext.opt_dir.value or else "metrics"}/rta"
out.mkdir
+ var model = toolcontext.modelbuilder.model
+ var model_view = model.protected_view
+
print toolcontext.format_h1("\n# RTA metrics")
print toolcontext.format_h2("\n ## Live instances by mainmodules")
var mmetrics = new MetricSet
- mmetrics.register(new MNLC(toolcontext.modelbuilder))
- mmetrics.register(new MNLT(toolcontext.modelbuilder))
- mmetrics.register(new MNCT(toolcontext.modelbuilder))
- mmetrics.register(new MNLI(toolcontext.modelbuilder))
- mmetrics.register(new MNLM(toolcontext.modelbuilder))
- mmetrics.register(new MNLMD(toolcontext.modelbuilder))
- mmetrics.register(new MNLDD(toolcontext.modelbuilder))
+ 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.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")
# Summary metrics
+# RTA related metric that needs a `modelbuilder`
+class RTAMetric
+ super MModuleMetric
+
+ # Modelbuilder used to access AST
+ var modelbuilder: ModelBuilder
+end
+
# MModule Metric: Number of Live Types
class MNLI
- super MModuleMetric
+ super RTAMetric
super IntMetric
redef fun name do return "mnli"
redef fun desc do return "number of live instances in a mmodule"
- var modelbuilder: ModelBuilder
- init(modelbuilder: ModelBuilder) do self.modelbuilder = modelbuilder
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
# MModule Metric: Number of Live Types
class MNLT
- super MModuleMetric
+ super RTAMetric
super IntMetric
redef fun name do return "mnlt"
redef fun desc do return "number of live mtypes in a mmodule"
- var modelbuilder: ModelBuilder
- init(modelbuilder: ModelBuilder) do self.modelbuilder = modelbuilder
-
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
var analysis = new RapidTypeAnalysis(modelbuilder, mainmodule)
# MModule Metric: Number of Live Cast Types
class MNCT
- super MModuleMetric
+ super RTAMetric
super IntMetric
redef fun name do return "mnct"
redef fun desc do return "number of live cast mtypes in a mmodule"
- var modelbuilder: ModelBuilder
- init(modelbuilder: ModelBuilder) do self.modelbuilder = modelbuilder
-
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
var analysis = new RapidTypeAnalysis(modelbuilder, mainmodule)
# MModule Metric: Number of Live Classes
class MNLC
- super MModuleMetric
+ super RTAMetric
super IntMetric
redef fun name do return "mnlc"
redef fun desc do return "number of live mclasses in a mmodule"
- var modelbuilder: ModelBuilder
- init(modelbuilder: ModelBuilder) do self.modelbuilder = modelbuilder
-
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
var live = new HashSet[MClass]
# MModule Metric: Number of Live Methods
class MNLM
- super MModuleMetric
+ super RTAMetric
super IntMetric
redef fun name do return "mnlm"
redef fun desc do return "number of live methods in a mmodule"
- var modelbuilder: ModelBuilder
- init(modelbuilder: ModelBuilder) do self.modelbuilder = modelbuilder
-
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
var analysis = new RapidTypeAnalysis(modelbuilder, mainmodule)
# MModule Metric: Number of Live MethodDefs
class MNLMD
- super MModuleMetric
+ super RTAMetric
super IntMetric
redef fun name do return "mnlmd"
redef fun desc do return "number of live method definitions in a mmodule"
- var modelbuilder: ModelBuilder
- init(modelbuilder: ModelBuilder) do self.modelbuilder = modelbuilder
-
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
var analysis = new RapidTypeAnalysis(modelbuilder, mainmodule)
# MModule Metric: Number of Dead MethodDefs
class MNLDD
- super MModuleMetric
+ super RTAMetric
super IntMetric
redef fun name do return "mnldd"
redef fun desc do return "number of dead method definitions in a mmodule"
- var modelbuilder: ModelBuilder
- init(modelbuilder: ModelBuilder) do self.modelbuilder = modelbuilder
-
redef fun collect(mainmodules) do
for mainmodule in mainmodules do
var dead = 0
nitlanguage / nit.git / commitdiff