When we match a type usage try to retrieve the declaration of the typ…

…e instead

of infering it

Signed-off-by: Kojo Adams <[email protected]>

.travis.yml

@@ -4,16 +4,6 @@ services:
 
 matrix:
     include:
-        - os: linux
-          compiler: gcc
-          language: cpp
-          sudo: true
-          script: docker build --build-arg TARGET_LLVM_VERSION=8 .
-        - os: linux
-          compiler: gcc
-          language: cpp
-          sudo: true
-          script: docker build --build-arg TARGET_LLVM_VERSION=9 .
         - os: linux
           compiler: gcc
           language: cpp

src/collectors/include_graph/find_type_match_callback.cpp

@@ -49,8 +49,8 @@ void FindTypeMatchCallback::run(
     const clang::ast_matchers::MatchFinder::MatchResult &r) {
 
   if (const clang::TypeLoc *tl = r.Nodes.getNodeAs<clang::TypeLoc>("type")) {
-
-    add_type_reference(ci, data, tl);
+    const clang::Decl* decl = r.Nodes.getNodeAs<clang::Decl>("decl");
+    add_type_reference(ci, data, tl, decl);
   }
 }
 } // namespace include_graph

src/collectors/include_graph/include_graph.cpp

@@ -48,6 +48,7 @@
 namespace clangmetatool {
 namespace collectors {
 
+using namespace clang::ast_matchers;
 class IncludeGraphImpl {
 private:
   clang::CompilerInstance *ci;
@@ -56,7 +57,7 @@ class IncludeGraphImpl {
   clang::ast_matchers::StatementMatcher sm1 =
       clang::ast_matchers::declRefExpr().bind("ref");
   clang::ast_matchers::TypeLocMatcher sm2 =
-      clang::ast_matchers::typeLoc().bind("type");
+      clang::ast_matchers::typeLoc(optionally(loc((const internal::Matcher<clang::QualType> &)hasDeclaration(decl().bind("decl"))))).bind("type");
   clang::ast_matchers::DeclarationMatcher sm3 =
       clang::ast_matchers::decl().bind("decl");
 

src/collectors/include_graph/include_graph_util.cpp

@@ -233,10 +233,9 @@ bool check_for_first_end(clang::CompilerInstance *ci, IncludeGraphData *data,
 }
 
 void add_type_reference(clang::CompilerInstance *ci, IncludeGraphData *data,
-                        const clang::TypeLoc *n) {
+                        const clang::TypeLoc *n, const clang::Decl* decl) {
 
   const clang::Type *t = n->getTypePtr();
-  const clang::Decl *decl = NULL;
   if (!decl)
     decl = extract_decl_for_type<clang::TypedefType>(t);
   if (!decl)

src/collectors/include_graph/include_graph_util.h

@@ -41,7 +41,7 @@ void add_decl_reference(clang::CompilerInstance *ci, IncludeGraphData *data,
                         const clang::DeclRefExpr *n);
 
 void add_type_reference(clang::CompilerInstance *ci, IncludeGraphData *data,
-                        const clang::TypeLoc *n);
+                        const clang::TypeLoc *n, const clang::Decl* decl);
 } // namespace include_graph
 } // namespace collectors
 } // namespace clangmetatool

t/042-generic-using-include-graph.t.cpp

@@ -0,0 +1,86 @@
+#include "clangmetatool-testconfig.h"
+
+
+#include <gtest/gtest.h>
+#include <map>
+#include <string>
+#include <iostream>
+
+#include <clangmetatool/collectors/include_graph.h>
+#include <clangmetatool/collectors/include_graph_data.h>
+#include <clangmetatool/include_graph_dependencies.h>
+#include <clangmetatool/meta_tool.h>
+#include <clangmetatool/meta_tool_factory.h>
+
+#include <clang/Frontend/FrontendAction.h>
+#include <clang/Tooling/CommonOptionsParser.h>
+#include <clang/Tooling/Core/Replacement.h>
+#include <clang/Tooling/Refactoring.h>
+#include <clang/Tooling/Tooling.h>
+#include <llvm/Support/CommandLine.h>
+
+class WeakDependenciesTool {
+private:
+  clang::CompilerInstance *ci;
+  clangmetatool::collectors::IncludeGraph includeGraph;
+
+public:
+  WeakDependenciesTool(clang::CompilerInstance *ci,
+                       clang::ast_matchers::MatchFinder *f)
+      : ci(ci), includeGraph(ci, f) {}
+  void postProcessing(
+      std::map<std::string, clang::tooling::Replacements> &replacementMap) {
+    clangmetatool::collectors::IncludeGraphData *data = includeGraph.getData();
+
+    std::map<std::string, clangmetatool::types::FileUID> fname2uid;
+    for (auto itr = data->fuid2name.begin(); itr != data->fuid2name.end();
+         ++itr) {
+      fname2uid[itr->second] = itr->first;
+    }
+
+    // Get main file UID
+    clang::SourceManager &sm = ci->getSourceManager();
+    const clang::FileEntry *mfe = sm.getFileEntryForID(sm.getMainFileID());
+    clangmetatool::types::FileUID mfid = mfe->getUID();
+    EXPECT_EQ(
+        clangmetatool::IncludeGraphDependencies::DirectDependenciesMap(
+            {std::make_pair(
+                 fname2uid["generic_using.h"],
+                 std::set<clangmetatool::types::FileUID>{fname2uid["generic_using.h"]})}),
+        clangmetatool::IncludeGraphDependencies::liveWeakDependencies(data,
+                                                                      mfid));
+
+    clangmetatool::IncludeGraphDependencies::decrementUsageRefCount(
+        data, {mfid, fname2uid["generic_using.h"]});
+
+    // generic_using.h no longer needed
+    EXPECT_EQ(
+        clangmetatool::IncludeGraphDependencies::DirectDependenciesMap({}),
+        clangmetatool::IncludeGraphDependencies::liveWeakDependencies(data,
+                                                                      mfid));
+
+  }
+};
+
+TEST(include_validate_test, liveWeakDependencies) {
+  llvm::cl::OptionCategory MyToolCategory("my-tool options");
+
+  int argc = 4;
+  const char *argv[] = {
+      "foo", CMAKE_SOURCE_DIR "/t/data/042-generic-using-include-graph/foo.cpp",
+      "--", "-xc++"};
+
+  auto result = clang::tooling::CommonOptionsParser::create(
+      argc, argv, MyToolCategory, llvm::cl::OneOrMore);
+  ASSERT_TRUE(!!result);
+  clang::tooling::CommonOptionsParser &optionsParser = result.get();
+
+  clang::tooling::RefactoringTool tool(optionsParser.getCompilations(),
+                                       optionsParser.getSourcePathList());
+
+  clangmetatool::MetaToolFactory<clangmetatool::MetaTool<WeakDependenciesTool>>
+      raf(tool.getReplacements());
+
+  int r = tool.runAndSave(&raf);
+  ASSERT_EQ(0, r);
+}

t/CMakeLists.txt

@@ -58,6 +58,7 @@ foreach(
   039-includegraph-nested-name-parameter
   040-includegraph-nested-using
   041-expand-range-if-valid
+  042-generic-using-include-graph
   )
 
   add_executable(${TEST}.t ${TEST}.t.cpp)

t/data/042-generic-using-include-graph/foo.cpp

@@ -0,0 +1,5 @@
+#include "generic_using.h"
+
+void func() {
+  generic_using<int> td;
+}

t/data/042-generic-using-include-graph/generic_type.h

@@ -0,0 +1,6 @@
+#pragma once
+
+template <typename T>
+struct generic_type {
+  T val;
+};

t/data/042-generic-using-include-graph/generic_using.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "generic_type.h"
+
+template <typename T>
+using generic_using = generic_type<T>;