Added afferent coupling for types.

Author: Barnabás Domozi

plugins/cpp/model/include/model/cpprecord.h

@@ -90,6 +90,15 @@ struct CppRecordCount
   std::size_t count;
 };
 
+#pragma db view \
+  object(CppMemberType) \
+  object(CppAstNode : CppMemberType::memberAstNode == CppAstNode::id)
+struct CppMemberTypeAstView
+{
+  #pragma db column(CppMemberType::typeHash)
+  std::uint64_t typeHash;
+};
+
 }
 }
 

plugins/cpp_metrics/model/include/model/cppastnodemetrics.h

@@ -22,7 +22,8 @@ struct CppAstNodeMetrics
     BUMPY_ROAD = 4,
     LACK_OF_COHESION = 5,
     LACK_OF_COHESION_HS = 6,
-    EFFERENT_TYPE = 7
+    EFFERENT_TYPE = 7,
+    AFFERENT_TYPE = 8
   };
 
   #pragma db id auto

plugins/cpp_metrics/parser/include/cppmetricsparser/cppmetricsparser.h

@@ -78,6 +78,8 @@ class CppMetricsParser : public AbstractParser
   void lackOfCohesion();
   // Calculate the efferent coupling of types.
   void efferentTypeLevel();
+  // Calculate the afferent coupling of types.
+  void afferentTypeLevel();
 
 
   /// @brief Constructs an ODB query that you can use to filter only
@@ -200,6 +202,7 @@ class CppMetricsParser : public AbstractParser
   static const int functionBumpyRoadPartitionMultiplier = 5;
   static const int lackOfCohesionPartitionMultiplier = 25;
   static const int efferentCouplingTypesPartitionMultiplier = 5;
+  static const int afferentCouplingTypesPartitionMultiplier = 5;
 };
 
 } // parser

plugins/cpp_metrics/parser/src/cppmetricsparser.cpp

@@ -8,6 +8,8 @@
 #include <model/cppfilemetrics-odb.hxx>
 #include <model/cppinheritance.h>
 #include <model/cppinheritance-odb.hxx>
+#include <model/cpprecord.h>
+#include <model/cpprecord-odb.hxx>
 
 #include <model/cppastnode.h>
 #include <model/cppastnode-odb.hxx>
@@ -428,6 +430,89 @@ void CppMetricsParser::efferentTypeLevel()
   });
 }
 
+void CppMetricsParser::afferentTypeLevel()
+{
+  parallelCalcMetric<model::CohesionCppRecordView>(
+    "Afferent coupling of types",
+    _threadCount * afferentCouplingTypesPartitionMultiplier,// number of jobs; adjust for granularity
+    getFilterPathsQuery<model::CohesionCppRecordView>(),
+    [&, this](const MetricsTasks<model::CohesionCppRecordView>& tasks)
+    {
+      util::OdbTransaction{_ctx.db}([&, this]
+      {
+        typedef odb::query<cc::model::CppAstNode> AstQuery;
+        typedef odb::query<cc::model::CppInheritance> InheritanceQuery;
+        typedef odb::query<cc::model::CppMemberType> MemTypeQuery;
+        typedef odb::result<cc::model::CppAstNode> AstResult;
+        typedef odb::result<cc::model::CppMemberTypeAstView> MemTypeAstResult;
+
+        std::set<std::uint64_t> dependentTypes;
+        for (const model::CohesionCppRecordView& type : tasks)
+        {
+          dependentTypes.clear();
+
+          // Find derived types
+          for (const model::CppInheritance& inheritance : _ctx.db->query<model::CppInheritance>(
+            InheritanceQuery::base == type.entityHash))
+          {
+            dependentTypes.insert(inheritance.derived);
+          }
+
+          // Find usages of the type
+          for (const model::CppAstNode& usage : _ctx.db->query<model::CppAstNode>(
+              AstQuery::entityHash == type.entityHash &&
+              AstQuery::location.range.end.line != model::Position::npos))
+          {
+            // Check if usage is in class member function or attribute
+            MemTypeAstResult memberNode = _ctx.db->query<model::CppMemberTypeAstView>(
+                AstQuery::symbolType.in(model::CppAstNode::SymbolType::Function, model::CppAstNode::SymbolType::Variable) &&
+                AstQuery::astType.in(model::CppAstNode::AstType::Definition, model::CppAstNode::AstType::Declaration) &&
+                AstQuery::location.file == usage.location.file.object_id() &&
+                AstQuery::location.range.start.line <= usage.location.range.start.line &&
+                AstQuery::location.range.end.line >= usage.location.range.end.line &&
+                MemTypeQuery::typeHash != usage.entityHash);
+
+            if (!memberNode.empty())
+            {
+              dependentTypes.insert(memberNode.begin()->typeHash);
+            } else {
+              // The usage can be in a member function defined outside of the class definition
+              // E.g. void ClassName::foo() { A a; }
+              //                              ^ usage here
+
+              // Find parent function
+              AstResult parentFunction = _ctx.db->query<model::CppAstNode>(
+                AstQuery::symbolType == model::CppAstNode::SymbolType::Function &&
+                AstQuery::astType == model::CppAstNode::AstType::Definition &&
+                AstQuery::location.file == usage.location.file.object_id() &&
+                AstQuery::location.range.start.line <= usage.location.range.start.line &&
+                AstQuery::location.range.end.line >= usage.location.range.end.line);
+
+              if (!parentFunction.empty())
+              {
+                // Find if the function is a member function of a class
+                MemTypeAstResult memberFunction = _ctx.db->query<model::CppMemberTypeAstView>(
+                  AstQuery::entityHash == parentFunction.begin()->entityHash &&
+                  MemTypeQuery::typeHash != usage.entityHash);
+
+                if (!memberFunction.empty())
+                {
+                  dependentTypes.insert(memberFunction.begin()->typeHash);
+                }
+              }
+            }
+          }
+
+          model::CppAstNodeMetrics metric;
+          metric.astNodeId = type.astNodeId;
+          metric.type = model::CppAstNodeMetrics::Type::AFFERENT_TYPE;
+          metric.value = dependentTypes.size();
+          _ctx.db->persist(metric);
+        }
+      });
+  });
+}
+
 bool CppMetricsParser::parse()
 {
   LOG(info) << "[cppmetricsparser] Computing function parameter count metric.";
@@ -442,6 +527,8 @@ bool CppMetricsParser::parse()
   lackOfCohesion();
   LOG(info) << "[cppmetricsparser] Computing efferent coupling metric for types.";
   efferentTypeLevel();
+  LOG(info) << "[cppmetricsparser] Computing afferent coupling metric for types.";
+  afferentTypeLevel();
   return true;
 }
 

plugins/cpp_metrics/service/cxxmetrics.thrift

@@ -12,7 +12,8 @@ enum CppAstNodeMetricsType
   BumpyRoad = 4,
   LackOfCohesion = 5,
   LackOfCohesionHS = 6,
-  EfferentType = 7
+  EfferentType = 7,
+  AfferentType = 8
 }
 
 enum CppModuleMetricsType
@@ -124,4 +125,4 @@ service CppMetricsService
    * This function returns the names of module-level C++ metrics.
    */
   list<CppModuleMetricsTypeName> getCppModuleMetricsTypeNames()
-}
+}

plugins/cpp_metrics/service/src/cppmetricsservice.cpp

@@ -57,6 +57,10 @@ void CppMetricsServiceHandler::getCppAstNodeMetricsTypeNames(
   typeName.type = CppAstNodeMetricsType::EfferentType;
   typeName.name = "Efferent coupling of type";
   _return.push_back(typeName);
+
+  typeName.type = CppAstNodeMetricsType::AfferentType;
+  typeName.name = "Afferent coupling of type";
+  _return.push_back(typeName);
 }
 
 void CppMetricsServiceHandler::getCppModuleMetricsTypeNames(