Make metric traits public (#1046)

* parser: Use metric traits instead of CodeMetricsT trait

This removes a superfluous trait aggregator

* parser: Remove a useless crate

* parser: Reorder crates imports

* Remove CodeMetricsT trait

* metrics: Visualize metric traits documentation

* macros: Add a macro to implement empty metric traits for each language

* metrics: Use new macro

Author: Luni-4

src/macros.rs

@@ -13,6 +13,56 @@ macro_rules! get_language {
     };
 }
 
+macro_rules! implement_metric_trait {
+    (Abc, $($code:ident),+) => (
+        $(
+           impl Abc for $code {
+               fn compute(_node: &Node, _stats: &mut Stats) {}
+           }
+        )+
+    );
+    (Cognitive, $($code:ident),+) => (
+        $(
+           impl Cognitive for $code {
+               fn compute(_node: &Node, _stats: &mut Stats, _nesting_map: &mut FxHashMap<usize, (usize, usize, usize)>,) {}
+           }
+        )+
+    );
+    (Halstead, $($code:ident),+) => (
+        $(
+           impl Halstead for $code {
+               fn compute<'a>(_node: &Node<'a>, _code: &'a [u8], _halstead_maps: &mut HalsteadMaps<'a>) {}
+           }
+        )+
+    );
+    (Loc, $($code:ident),+) => (
+        $(
+           impl Loc for $code {
+               fn compute(_node: &Node, _stats: &mut Stats, _is_func_space: bool, _is_unit: bool) {}
+           }
+        )+
+    );
+    (Wmc, $($code:ident),+) => (
+        $(
+           impl Wmc for $code {
+               fn compute(_space_kind: SpaceKind, _cyclomatic: &cyclomatic::Stats, _stats: &mut Stats) {}
+           }
+        )+
+    );
+    ([$trait:ident], $($code:ident),+) => (
+        $(
+           impl $trait for $code {}
+        )+
+    );
+    ($trait:ident, $($code:ident),+) => (
+        $(
+           impl $trait for $code {
+               fn compute(_node: &Node, _stats: &mut Stats) {}
+           }
+        )+
+    )
+}
+
 macro_rules! mk_enum {
     ( $( $camel:ident, $description:expr ),* ) => {
         /// The list of supported languages.
@@ -222,7 +272,6 @@ macro_rules! mk_code {
     ( $( ($camel:ident, $code:ident, $parser:ident, $name:ident, $docname:expr) ),* ) => {
         $(
             pub struct $code { _guard: (), }
-            impl _private::CodeMetricsT for $code { }
 
             impl _private::TSLanguage for $code {
                 type BaseLang = $camel;

src/metrics/abc.rs

@@ -245,12 +245,11 @@ impl Stats {
     }
 }
 
-#[doc(hidden)]
 pub trait Abc
 where
     Self: Checker,
 {
-    fn compute(_node: &Node, _stats: &mut Stats) {}
+    fn compute(node: &Node, stats: &mut Stats);
 }
 
 // Inspects the content of Java parenthesized expressions
@@ -342,16 +341,19 @@ fn java_count_unary_conditions(list_node: &Node, conditions: &mut f64) {
     }
 }
 
-impl Abc for PythonCode {}
-impl Abc for MozjsCode {}
-impl Abc for JavascriptCode {}
-impl Abc for TypescriptCode {}
-impl Abc for TsxCode {}
-impl Abc for RustCode {}
-impl Abc for CppCode {}
-impl Abc for PreprocCode {}
-impl Abc for CcommentCode {}
-impl Abc for KotlinCode {}
+implement_metric_trait!(
+    Abc,
+    PythonCode,
+    MozjsCode,
+    JavascriptCode,
+    TypescriptCode,
+    TsxCode,
+    RustCode,
+    CppCode,
+    PreprocCode,
+    CcommentCode,
+    KotlinCode
+);
 
 // Fitzpatrick, Jerry (1997). "Applying the ABC metric to C, C++ and Java". C++ Report.
 // Source: https://www.softwarerenovation.com/Articles.aspx

src/metrics/cognitive.rs

@@ -119,17 +119,15 @@ impl Stats {
     }
 }
 
-#[doc(hidden)]
 pub trait Cognitive
 where
     Self: Checker,
 {
     fn compute(
-        _node: &Node,
-        _stats: &mut Stats,
-        _nesting_map: &mut FxHashMap<usize, (usize, usize, usize)>,
-    ) {
-    }
+        node: &Node,
+        stats: &mut Stats,
+        nesting_map: &mut FxHashMap<usize, (usize, usize, usize)>,
+    );
 }
 
 fn compute_booleans<T: std::cmp::PartialEq + std::convert::From<u16>>(
@@ -446,10 +444,7 @@ impl Cognitive for TsxCode {
     js_cognitive!(Tsx);
 }
 
-impl Cognitive for PreprocCode {}
-impl Cognitive for CcommentCode {}
-impl Cognitive for JavaCode {}
-impl Cognitive for KotlinCode {}
+implement_metric_trait!(Cognitive, PreprocCode, CcommentCode, JavaCode, KotlinCode);
 
 #[cfg(test)]
 mod tests {

src/metrics/cyclomatic.rs

@@ -101,12 +101,11 @@ impl Stats {
     }
 }
 
-#[doc(hidden)]
 pub trait Cyclomatic
 where
     Self: Checker,
 {
-    fn compute(_node: &Node, _stats: &mut Stats) {}
+    fn compute(node: &Node, stats: &mut Stats);
 }
 
 impl Cyclomatic for PythonCode {
@@ -205,9 +204,6 @@ impl Cyclomatic for CppCode {
     }
 }
 
-impl Cyclomatic for PreprocCode {}
-impl Cyclomatic for CcommentCode {}
-
 impl Cyclomatic for JavaCode {
     fn compute(node: &Node, stats: &mut Stats) {
         use Java::*;
@@ -221,7 +217,7 @@ impl Cyclomatic for JavaCode {
     }
 }
 
-impl Cyclomatic for KotlinCode {}
+implement_metric_trait!(Cyclomatic, KotlinCode, PreprocCode, CcommentCode);
 
 #[cfg(test)]
 mod tests {

src/metrics/exit.rs

@@ -106,12 +106,11 @@ impl Stats {
     }
 }
 
-#[doc(hidden)]
 pub trait Exit
 where
     Self: Checker,
 {
-    fn compute(_node: &Node, _stats: &mut Stats) {}
+    fn compute(node: &Node, stats: &mut Stats);
 }
 
 impl Exit for PythonCode {
@@ -180,10 +179,7 @@ impl Exit for JavaCode {
     }
 }
 
-impl Exit for KotlinCode {}
-
-impl Exit for PreprocCode {}
-impl Exit for CcommentCode {}
+implement_metric_trait!(Exit, KotlinCode, PreprocCode, CcommentCode);
 
 #[cfg(test)]
 mod tests {

src/metrics/halstead.rs

@@ -27,7 +27,6 @@ pub enum HalsteadType {
     Unknown,
 }
 
-#[doc(hidden)]
 #[derive(Debug, Default, Clone)]
 pub struct HalsteadMaps<'a> {
     pub(crate) operators: FxHashMap<u16, u64>,
@@ -247,12 +246,11 @@ impl Stats {
     }
 }
 
-#[doc(hidden)]
 pub trait Halstead
 where
     Self: Checker,
 {
-    fn compute<'a>(_node: &Node<'a>, _code: &'a [u8], _halstead_maps: &mut HalsteadMaps<'a>) {}
+    fn compute<'a>(node: &Node<'a>, code: &'a [u8], halstead_maps: &mut HalsteadMaps<'a>);
 }
 
 #[inline(always)]
@@ -331,10 +329,7 @@ impl Halstead for JavaCode {
     }
 }
 
-impl Halstead for KotlinCode {}
-
-impl Halstead for PreprocCode {}
-impl Halstead for CcommentCode {}
+implement_metric_trait!(Halstead, KotlinCode, PreprocCode, CcommentCode);
 
 #[cfg(test)]
 mod tests {

src/metrics/loc.rs

@@ -499,12 +499,11 @@ impl Stats {
     }
 }
 
-#[doc(hidden)]
 pub trait Loc
 where
     Self: Checker,
 {
-    fn compute(_node: &Node, _stats: &mut Stats, _is_func_space: bool, _is_unit: bool) {}
+    fn compute(node: &Node, stats: &mut Stats, is_func_space: bool, is_unit: bool);
 }
 
 #[inline(always)]
@@ -815,10 +814,7 @@ impl Loc for JavaCode {
     }
 }
 
-impl Loc for KotlinCode {}
-
-impl Loc for PreprocCode {}
-impl Loc for CcommentCode {}
+implement_metric_trait!(Loc, PreprocCode, CcommentCode, KotlinCode);
 
 #[cfg(test)]
 mod tests {

src/metrics/mi.rs

@@ -82,7 +82,6 @@ impl Stats {
     }
 }
 
-#[doc(hidden)]
 pub trait Mi
 where
     Self: Checker,
@@ -102,17 +101,20 @@ where
     }
 }
 
-impl Mi for RustCode {}
-impl Mi for CppCode {}
-impl Mi for PythonCode {}
-impl Mi for MozjsCode {}
-impl Mi for JavascriptCode {}
-impl Mi for TypescriptCode {}
-impl Mi for TsxCode {}
-impl Mi for PreprocCode {}
-impl Mi for CcommentCode {}
-impl Mi for JavaCode {}
-impl Mi for KotlinCode {}
+implement_metric_trait!(
+    [Mi],
+    PythonCode,
+    MozjsCode,
+    JavascriptCode,
+    TypescriptCode,
+    TsxCode,
+    RustCode,
+    CppCode,
+    PreprocCode,
+    CcommentCode,
+    JavaCode,
+    KotlinCode
+);
 
 #[cfg(test)]
 mod tests {

src/metrics/nargs.rs

@@ -192,7 +192,6 @@ fn compute_args<T: Checker>(node: &Node, nargs: &mut usize) {
     }
 }
 
-#[doc(hidden)]
 pub trait NArgs
 where
     Self: Checker,
@@ -229,16 +228,19 @@ impl NArgs for CppCode {
     }
 }
 
-impl NArgs for MozjsCode {}
-impl NArgs for JavascriptCode {}
-impl NArgs for TypescriptCode {}
-impl NArgs for TsxCode {}
-impl NArgs for PreprocCode {}
-impl NArgs for CcommentCode {}
-impl NArgs for RustCode {}
-impl NArgs for PythonCode {}
-impl NArgs for JavaCode {}
-impl NArgs for KotlinCode {}
+implement_metric_trait!(
+    [NArgs],
+    PythonCode,
+    MozjsCode,
+    JavascriptCode,
+    TypescriptCode,
+    TsxCode,
+    RustCode,
+    PreprocCode,
+    CcommentCode,
+    JavaCode,
+    KotlinCode
+);
 
 #[cfg(test)]
 mod tests {

src/metrics/nom.rs

@@ -185,7 +185,6 @@ impl Stats {
     }
 }
 
-#[doc(hidden)]
 pub trait Nom
 where
     Self: Checker,
@@ -201,17 +200,20 @@ where
     }
 }
 
-impl Nom for PythonCode {}
-impl Nom for MozjsCode {}
-impl Nom for JavascriptCode {}
-impl Nom for TypescriptCode {}
-impl Nom for TsxCode {}
-impl Nom for RustCode {}
-impl Nom for CppCode {}
-impl Nom for PreprocCode {}
-impl Nom for CcommentCode {}
-impl Nom for JavaCode {}
-impl Nom for KotlinCode {}
+implement_metric_trait!(
+    [Nom],
+    PythonCode,
+    MozjsCode,
+    JavascriptCode,
+    TypescriptCode,
+    TsxCode,
+    CppCode,
+    RustCode,
+    PreprocCode,
+    CcommentCode,
+    JavaCode,
+    KotlinCode
+);
 
 #[cfg(test)]
 mod tests {