Clang: add globalFollowSymbol to RefactoringEngine

Allows to follow outside of current TU.

Change-Id: Ieea2fd72bfdf6d60a988b40efcf2f41c5a71d045
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>

src/libs/clangsupport/requestfollowsymbolmessage.cpp

@@ -36,7 +36,6 @@ QDebug operator<<(QDebug debug, const RequestFollowSymbolMessage &message)
     debug.nospace() << "RequestFollowSymbolMessage(";
 
     debug.nospace() << message.m_fileContainer << ", ";
-    debug.nospace() << message.m_dependentFiles << ", ";
     debug.nospace() << message.m_ticketNumber << ", ";
     debug.nospace() << message.m_line << ", ";
     debug.nospace() << message.m_column << ", ";

src/libs/clangsupport/requestfollowsymbolmessage.h

@@ -38,14 +38,12 @@ class RequestFollowSymbolMessage
 public:
     RequestFollowSymbolMessage() = default;
     RequestFollowSymbolMessage(const FileContainer &fileContainer,
-                               const QVector<Utf8String> &dependentFiles,
                                quint32 line,
                                quint32 column)
         : m_fileContainer(fileContainer)
         , m_ticketNumber(++ticketCounter)
         , m_line(line)
         , m_column(column)
-        , m_dependentFiles(dependentFiles)
     {
     }
 
@@ -54,11 +52,6 @@ public:
         return m_fileContainer;
     }
 
-    const QVector<Utf8String> &dependentFiles() const
-    {
-        return m_dependentFiles;
-    }
-
     quint32 line() const
     {
         return m_line;
@@ -77,7 +70,6 @@ public:
     friend QDataStream &operator<<(QDataStream &out, const RequestFollowSymbolMessage &message)
     {
         out << message.m_fileContainer;
-        out << message.m_dependentFiles;
         out << message.m_ticketNumber;
         out << message.m_line;
         out << message.m_column;
@@ -88,7 +80,6 @@ public:
     friend QDataStream &operator>>(QDataStream &in, RequestFollowSymbolMessage &message)
     {
         in >> message.m_fileContainer;
-        in >> message.m_dependentFiles;
         in >> message.m_ticketNumber;
         in >> message.m_line;
         in >> message.m_column;
@@ -102,8 +93,7 @@ public:
         return first.m_ticketNumber == second.m_ticketNumber
             && first.m_line == second.m_line
             && first.m_column == second.m_column
-            && first.m_fileContainer == second.m_fileContainer
-            && first.m_dependentFiles == second.m_dependentFiles;
+            && first.m_fileContainer == second.m_fileContainer;
     }
 
     friend CLANGSUPPORT_EXPORT QDebug operator<<(QDebug debug, const RequestFollowSymbolMessage &message);
@@ -112,7 +102,6 @@ private:
     quint64 m_ticketNumber = 0;
     quint32 m_line = 0;
     quint32 m_column = 0;
-    QVector<Utf8String> m_dependentFiles;
     static CLANGSUPPORT_EXPORT quint64 ticketCounter;
 };
 

src/plugins/clangcodemodel/clangbackendcommunicator.cpp

@@ -394,12 +394,10 @@ QFuture<CppTools::CursorInfo> BackendCommunicator::requestLocalReferences(
 
 QFuture<CppTools::SymbolInfo> BackendCommunicator::requestFollowSymbol(
         const FileContainer &curFileContainer,
-        const QVector<Utf8String> &dependentFiles,
         quint32 line,
         quint32 column)
 {
     const RequestFollowSymbolMessage message(curFileContainer,
-                                             dependentFiles,
                                              line,
                                              column);
     m_sender->requestFollowSymbol(message);

src/plugins/clangcodemodel/clangbackendcommunicator.h

@@ -83,7 +83,6 @@ public:
             quint32 column,
             QTextDocument *textDocument);
     QFuture<CppTools::SymbolInfo> requestFollowSymbol(const FileContainer &curFileContainer,
-                                                      const QVector<Utf8String> &dependentFiles,
                                                       quint32 line,
                                                       quint32 column);
     void completeCode(ClangCompletionAssistProcessor *assistProcessor, const QString &filePath,

src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp

@@ -367,50 +367,10 @@ QFuture<CppTools::CursorInfo> ClangEditorDocumentProcessor::requestLocalReferenc
                                                  textDocument());
 }
 
-static QVector<Utf8String> prioritizeByBaseName(const QString &curPath,
-                                                const ::Utils::FileNameList &fileDeps)
-{
-    QList<Utf8String> dependentFiles;
-    dependentFiles.reserve(fileDeps.size());
-    for (const ::Utils::FileName &dep: fileDeps)
-        dependentFiles.push_back(dep.toString());
-
-    const QString curFilename = QFileInfo(curPath).fileName();
-    if (CppTools::ProjectFile::isHeader(CppTools::ProjectFile::classify(curFilename))) {
-        const QString withoutExt = QFileInfo(curFilename).baseName();
-        int posToMove = 0;
-        // Move exact match to the first place and partial matches after it
-        for (int i = 0; i < dependentFiles.size(); ++i) {
-            const QString baseName = QFileInfo(dependentFiles[i]).baseName();
-            if (withoutExt == baseName) {
-                dependentFiles.move(i, 0);
-                posToMove++;
-                continue;
-            }
-            if (baseName.contains(withoutExt))
-                dependentFiles.move(i, posToMove++);
-        }
-    }
-    // Limit the number of scans (don't search for overrides)
-    if (dependentFiles.size() > 5)
-        dependentFiles.erase(dependentFiles.begin() + 5, dependentFiles.end());
-    return QVector<Utf8String>::fromList(dependentFiles);
-}
-
 QFuture<CppTools::SymbolInfo>
 ClangEditorDocumentProcessor::requestFollowSymbol(int line, int column)
 {
-    QVector<Utf8String> dependentFiles;
-    CppTools::CppModelManager *modelManager = CppTools::CppModelManager::instance();
-    if (modelManager && !modelManager->projectPart(filePath()).isEmpty()) {
-        // This might be not so fast - index will change that
-        const ::Utils::FileNameList fileDeps
-                = modelManager->snapshot().filesDependingOn(filePath());
-        dependentFiles = prioritizeByBaseName(filePath(), fileDeps);
-    }
-
     return m_communicator.requestFollowSymbol(simpleFileContainer(),
-                                              dependentFiles,
                                               static_cast<quint32>(line),
                                               static_cast<quint32>(column));
 }

src/plugins/clangcodemodel/clangfollowsymbol.cpp

@@ -26,6 +26,7 @@
 #include "clangeditordocumentprocessor.h"
 #include "clangfollowsymbol.h"
 
+#include <cpptools/cppmodelmanager.h>
 #include <texteditor/texteditor.h>
 
 #include <clangsupport/tokeninfocontainer.h>
@@ -94,10 +95,10 @@ static Utils::Link linkAtCursor(QTextCursor cursor, const QString &filePath, uin
 
 Utils::Link ClangFollowSymbol::findLink(const CppTools::CursorInEditor &data,
                                         bool resolveTarget,
-                                        const CPlusPlus::Snapshot &,
-                                        const CPlusPlus::Document::Ptr &,
-                                        CppTools::SymbolFinder *,
-                                        bool)
+                                        const CPlusPlus::Snapshot &snapshot,
+                                        const CPlusPlus::Document::Ptr &documentFromSemanticInfo,
+                                        CppTools::SymbolFinder *symbolFinder,
+                                        bool inNextSplit)
 {
     int lineNumber = 0, positionInBlock = 0;
     QTextCursor cursor = Utils::Text::wordStartCursor(data.cursor());
@@ -130,8 +131,12 @@ Utils::Link ClangFollowSymbol::findLink(const CppTools::CursorInEditor &data,
     CppTools::SymbolInfo result = info.result();
 
     // We did not fail but the result is empty
-    if (result.fileName.isEmpty())
-        return Link();
+    if (result.fileName.isEmpty()) {
+        const CppTools::RefactoringEngineInterface &refactoringEngine
+                = *CppTools::CppModelManager::instance();
+        return refactoringEngine.globalFollowSymbol(data, snapshot, documentFromSemanticInfo,
+                                                    symbolFinder, inNextSplit);
+    }
 
     return Link(result.fileName, result.startLine, result.startColumn - 1);
 }

src/plugins/clangcodemodel/clangfollowsymbol.h

@@ -35,10 +35,10 @@ class ClangFollowSymbol : public CppTools::FollowSymbolInterface
 public:
     Link findLink(const CppTools::CursorInEditor &data,
                   bool resolveTarget,
-                  const CPlusPlus::Snapshot &,
-                  const CPlusPlus::Document::Ptr &,
-                  CppTools::SymbolFinder *,
-                  bool) override;
+                  const CPlusPlus::Snapshot &snapshot,
+                  const CPlusPlus::Document::Ptr &documentFromSemanticInfo,
+                  CppTools::SymbolFinder *symbolFinder,
+                  bool inNextSplit) override;
 };
 
 } // namespace Internal

src/plugins/clangcodemodel/clangrefactoringengine.h

@@ -43,6 +43,12 @@ public:
     void globalRename(const CppTools::CursorInEditor &, CppTools::UsagesCallback &&,
                       const QString &) override {}
     void findUsages(const CppTools::CursorInEditor &, CppTools::UsagesCallback &&) const override {}
+    Link globalFollowSymbol(const CppTools::CursorInEditor &, const CPlusPlus::Snapshot &,
+                            const CPlusPlus::Document::Ptr &, CppTools::SymbolFinder *,
+                            bool) const override
+    {
+        return Link();
+    }
 };
 
 } // namespace ClangRefactoring

src/plugins/clangrefactoring/refactoringengine.cpp

@@ -35,6 +35,7 @@
 
 #include <clangsupport/filepathcachinginterface.h>
 
+#include <utils/algorithm.h>
 #include <utils/textutils.h>
 
 #include <QTextCursor>
@@ -115,6 +116,24 @@ void RefactoringEngine::findUsages(const CppTools::CursorInEditor &data,
     showUsagesCallback(locationsAt(data));
 }
 
+RefactoringEngine::Link RefactoringEngine::globalFollowSymbol(const CppTools::CursorInEditor &data,
+                                                              const CPlusPlus::Snapshot &,
+                                                              const CPlusPlus::Document::Ptr &,
+                                                              CppTools::SymbolFinder *,
+                                                              bool) const
+{
+    // TODO: replace that with specific followSymbol query
+    const CppTools::Usages usages = locationsAt(data);
+    CppTools::Usage usage = Utils::findOrDefault(usages, [&data](const CppTools::Usage &usage) {
+        // We've already searched in the current file, skip it.
+        if (usage.path == data.filePath().toString())
+            return false;
+        return true;
+    });
+
+    return Link(usage.path, usage.line, usage.column);
+}
+
 bool RefactoringEngine::isRefactoringEngineAvailable() const
 {
     return m_server.isAvailable();

src/plugins/clangrefactoring/refactoringengine.h

@@ -36,6 +36,8 @@ class RefactoringClientInterface;
 class RefactoringServerInterface;
 }
 
+namespace CppTools { class SymbolFinder; }
+
 namespace ClangRefactoring {
 
 class RefactoringEngine : public CppTools::RefactoringEngineInterface
@@ -55,6 +57,11 @@ public:
                       const QString &) override;
     void findUsages(const CppTools::CursorInEditor &data,
                     CppTools::UsagesCallback &&showUsagesCallback) const override;
+    Link globalFollowSymbol(const CppTools::CursorInEditor &data,
+                            const CPlusPlus::Snapshot &,
+                            const CPlusPlus::Document::Ptr &,
+                            CppTools::SymbolFinder *,
+                            bool) const override;
 
     bool isRefactoringEngineAvailable() const override;
     void setRefactoringEngineAvailable(bool isAvailable);

src/plugins/cpptools/cppmodelmanager.cpp

@@ -289,7 +289,7 @@ void CppModelManager::startLocalRenaming(const CursorInEditor &data,
                                          CppTools::ProjectPart *projectPart,
                                          RenameCallback &&renameSymbolsCallback)
 {
-    RefactoringEngineInterface *engine = getRefactoringEngine(instance()->d->m_refactoringEngines,
+    RefactoringEngineInterface *engine = getRefactoringEngine(d->m_refactoringEngines,
                                                               false);
     QTC_ASSERT(engine, return;);
     engine->startLocalRenaming(data, projectPart, std::move(renameSymbolsCallback));
@@ -298,7 +298,7 @@ void CppModelManager::startLocalRenaming(const CursorInEditor &data,
 void CppModelManager::globalRename(const CursorInEditor &data, UsagesCallback &&renameCallback,
                                    const QString &replacement)
 {
-    RefactoringEngineInterface *engine = getRefactoringEngine(instance()->d->m_refactoringEngines);
+    RefactoringEngineInterface *engine = getRefactoringEngine(d->m_refactoringEngines);
     QTC_ASSERT(engine, return;);
     engine->globalRename(data, std::move(renameCallback), replacement);
 }
@@ -306,11 +306,24 @@ void CppModelManager::globalRename(const CursorInEditor &data, UsagesCallback &&
 void CppModelManager::findUsages(const CppTools::CursorInEditor &data,
                                  UsagesCallback &&showUsagesCallback) const
 {
-    RefactoringEngineInterface *engine = getRefactoringEngine(instance()->d->m_refactoringEngines);
+    RefactoringEngineInterface *engine = getRefactoringEngine(d->m_refactoringEngines);
     QTC_ASSERT(engine, return;);
     engine->findUsages(data, std::move(showUsagesCallback));
 }
 
+CppModelManager::Link CppModelManager::globalFollowSymbol(
+        const CursorInEditor &data,
+        const CPlusPlus::Snapshot &snapshot,
+        const CPlusPlus::Document::Ptr &documentFromSemanticInfo,
+        SymbolFinder *symbolFinder,
+        bool inNextSplit) const
+{
+    RefactoringEngineInterface *engine = getRefactoringEngine(d->m_refactoringEngines);
+    QTC_ASSERT(engine, return Link(););
+    return engine->globalFollowSymbol(data, snapshot, documentFromSemanticInfo,
+            symbolFinder, inNextSplit);
+}
+
 void CppModelManager::addRefactoringEngine(RefactoringEngineType type,
                                            RefactoringEngineInterface *refactoringEngine)
 {

src/plugins/cpptools/cppmodelmanager.h

@@ -155,6 +155,11 @@ public:
                       const QString &replacement) final;
     void findUsages(const CppTools::CursorInEditor &data,
                     UsagesCallback &&showUsagesCallback) const final;
+    Link globalFollowSymbol(const CursorInEditor &data,
+                            const CPlusPlus::Snapshot &snapshot,
+                            const CPlusPlus::Document::Ptr &documentFromSemanticInfo,
+                            SymbolFinder *symbolFinder,
+                            bool inNextSplit) const final;
 
     void renameUsages(CPlusPlus::Symbol *symbol, const CPlusPlus::LookupContext &context,
                       const QString &replacement = QString());

src/plugins/cpptools/cpprefactoringengine.cpp

@@ -28,6 +28,7 @@
 #include "cpprefactoringengine.h"
 #include "cppsemanticinfo.h"
 #include "cpptoolsreuse.h"
+#include "cppfollowsymbolundercursor.h"
 
 #include <texteditor/texteditor.h>
 
@@ -99,4 +100,16 @@ void CppRefactoringEngine::findUsages(const CursorInEditor &data,
     }
 }
 
+CppRefactoringEngine::Link CppRefactoringEngine::globalFollowSymbol(
+        const CursorInEditor &data,
+        const CPlusPlus::Snapshot &snapshot,
+        const CPlusPlus::Document::Ptr &documentFromSemanticInfo,
+        SymbolFinder *symbolFinder,
+        bool inNextSplit) const
+{
+    FollowSymbolUnderCursor followSymbol;
+    return followSymbol.findLink(data, true, snapshot, documentFromSemanticInfo,
+                                 symbolFinder, inNextSplit);
+}
+
 } // namespace CppEditor

src/plugins/cpptools/cpprefactoringengine.h

@@ -38,6 +38,11 @@ public:
     void globalRename(const CursorInEditor &data, UsagesCallback &&,
                       const QString &replacement) override;
     void findUsages(const CursorInEditor &data, UsagesCallback &&) const override;
+    Link globalFollowSymbol(const CursorInEditor &data,
+                            const CPlusPlus::Snapshot &snapshot,
+                            const CPlusPlus::Document::Ptr &documentFromSemanticInfo,
+                            SymbolFinder *symbolFinder,
+                            bool inNextSplit) const override;
 };
 
 } // namespace CppEditor

src/plugins/cpptools/refactoringengineinterface.h

@@ -29,12 +29,15 @@
 #include "cursorineditor.h"
 #include "usages.h"
 
+#include <utils/link.h>
 #include <utils/fileutils.h>
 #include <utils/smallstring.h>
 
 #include <clangsupport/sourcelocationscontainer.h>
 #include <clangsupport/refactoringclientinterface.h>
 
+#include <cplusplus/CppDocument.h>
+
 namespace TextEditor {
 class TextEditorWidget;
 } // namespace TextEditor
@@ -42,6 +45,7 @@ class TextEditorWidget;
 namespace CppTools {
 
 class ProjectPart;
+class SymbolFinder;
 
 enum class CallType
 {
@@ -54,6 +58,7 @@ class CPPTOOLS_EXPORT RefactoringEngineInterface
 {
 public:
     using RenameCallback = ClangBackEnd::RefactoringClientInterface::RenameCallback;
+    using Link = Utils::Link;
 
     virtual ~RefactoringEngineInterface() {}
 
@@ -65,6 +70,11 @@ public:
                               const QString &replacement) = 0;
     virtual void findUsages(const CppTools::CursorInEditor &data,
                             UsagesCallback &&showUsagesCallback) const = 0;
+    virtual Link globalFollowSymbol(const CursorInEditor &data,
+                                    const CPlusPlus::Snapshot &snapshot,
+                                    const CPlusPlus::Document::Ptr &documentFromSemanticInfo,
+                                    SymbolFinder *symbolFinder,
+                                    bool inNextSplit) const = 0;
     virtual bool isRefactoringEngineAvailable() const { return true; }
 };
 

src/plugins/cpptools/usages.h

@@ -37,6 +37,7 @@ namespace CppTools {
 class Usage
 {
 public:
+    Usage() {}
     Usage(Utils::SmallStringView path, int line, int column)
         : path(QString::fromUtf8(path.data(), int(path.size()))),
           line(line),
@@ -52,8 +53,8 @@ public:
 
 public:
     QString path;
-    int line;
-    int column;
+    int line = 0;
+    int column = 0;
 };
 
 using Usages = std::vector<Usage>;

src/tools/clangbackend/source/clangcodemodelserver.cpp

@@ -281,7 +281,6 @@ void ClangCodeModelServer::requestFollowSymbol(const RequestFollowSymbolMessage
 
         JobRequest jobRequest = processor.createJobRequest(JobRequest::Type::FollowSymbol);
         fillJobRequest(jobRequest, message);
-        jobRequest.dependentFiles = message.dependentFiles();
         processor.addJob(jobRequest);
         processor.process();
     }  catch (const std::exception &exception) {

src/tools/clangbackend/source/clangfollowsymbol.cpp

@@ -133,47 +133,6 @@ static SourceRangeContainer extractMatchingTokenRange(const Cursor &cursor,
     return SourceRangeContainer();
 }
 
-static void handleDeclaration(CXClientData client_data, const CXIdxDeclInfo *declInfo)
-{
-    if (!declInfo || !declInfo->isDefinition)
-        return;
-
-    const Cursor currentCursor(declInfo->cursor);
-    auto* data = reinterpret_cast<FollowSymbolData*>(client_data);
-    if (data->ready())
-        return;
-
-    if (data->usr() != currentCursor.canonical().unifiedSymbolResolution())
-        return;
-
-    QString str = Utf8String(currentCursor.displayName());
-    if (currentCursor.isFunctionLike() || currentCursor.isConstructorOrDestructor()) {
-        if (!data->isFunctionLike())
-            return;
-        str = str.mid(0, str.indexOf('('));
-    } else if (data->isFunctionLike()) {
-        return;
-    }
-    if (!str.endsWith(data->spelling()))
-        return;
-    const CXTranslationUnit tu = clang_Cursor_getTranslationUnit(declInfo->cursor);
-    Tokens tokens(currentCursor);
-
-    for (uint i = 0; i < tokens.tokenCount; ++i) {
-        Utf8String curSpelling = ClangString(clang_getTokenSpelling(tu, tokens.data[i]));
-        if (data->spelling() == curSpelling) {
-            if (data->isFunctionLike()
-                    && (i+1 >= tokens.tokenCount
-                        || !(ClangString(clang_getTokenSpelling(tu, tokens.data[i+1])) == "("))) {
-                continue;
-            }
-            data->setResult(SourceRange(clang_getTokenExtent(tu, tokens.data[i])));
-            data->setReady();
-            return;
-        }
-    }
-}
-
 static int getTokenIndex(CXTranslationUnit tu, const Tokens &tokens, uint line, uint column)
 {
     int tokenIndex = -1;
@@ -187,90 +146,10 @@ static int getTokenIndex(CXTranslationUnit tu, const Tokens &tokens, uint line,
     return tokenIndex;
 }
 
-static IndexerCallbacks createIndexerCallbacks()
-{
-    return {
-        [](CXClientData client_data, void *) {
-            auto* data = reinterpret_cast<FollowSymbolData*>(client_data);
-            return data->ready() ? 1 : 0;
-        },
-        [](CXClientData, CXDiagnosticSet, void *) {},
-        [](CXClientData, CXFile, void *) { return CXIdxClientFile(); },
-        [](CXClientData, const CXIdxIncludedFileInfo *) { return CXIdxClientFile(); },
-        [](CXClientData, const CXIdxImportedASTFileInfo *) { return CXIdxClientASTFile(); },
-        [](CXClientData, void *) { return CXIdxClientContainer(); },
-        handleDeclaration,
-        [](CXClientData, const CXIdxEntityRefInfo *) {}
-    };
-}
-
-static SourceRangeContainer followSymbolInDependentFiles(CXIndex index,
-                                                         const Cursor &cursor,
-                                                         const Utf8String &tokenSpelling,
-                                                         const QVector<Utf8String> &dependentFiles,
-                                                         const CommandLineArguments &currentArgs)
-{
-    int argsCount = 0;
-    if (currentArgs.data())
-        argsCount = currentArgs.count() - 1;
-
-    const Utf8String usr = cursor.canonical().unifiedSymbolResolution();
-
-    // ready is shared for all data in vector
-    std::atomic<bool> ready {false};
-    std::vector<FollowSymbolData> dataVector(
-                dependentFiles.size(),
-                FollowSymbolData(usr, tokenSpelling,
-                                 cursor.isFunctionLike() || cursor.isConstructorOrDestructor(),
-                                 ready));
-
-    std::vector<std::future<void>> indexFutures;
-
-    for (int i = 0; i < dependentFiles.size(); ++i) {
-        if (i > 0 && ready)
-            break;
-        indexFutures.emplace_back(std::async([&, i]() {
-            TIME_SCOPE_DURATION("Dependent file " + dependentFiles.at(i) + " indexer runner");
-
-            const CXIndexAction indexAction = clang_IndexAction_create(index);
-            IndexerCallbacks callbacks = createIndexerCallbacks();
-            clang_indexSourceFile(indexAction,
-                                  &dataVector[i],
-                                  &callbacks,
-                                  sizeof(callbacks),
-                                  CXIndexOpt_SkipParsedBodiesInSession
-                                      | CXIndexOpt_SuppressRedundantRefs
-                                      | CXIndexOpt_SuppressWarnings,
-                                  dependentFiles.at(i).constData(),
-                                  currentArgs.data(),
-                                  argsCount,
-                                  nullptr,
-                                  0,
-                                  nullptr,
-                                  CXTranslationUnit_SkipFunctionBodies
-                                      | CXTranslationUnit_KeepGoing);
-            clang_IndexAction_dispose(indexAction);
-        }));
-    }
-
-    for (const std::future<void> &future: indexFutures)
-        future.wait();
-
-    for (const FollowSymbolData &data: dataVector) {
-        if (!data.result().start().filePath().isEmpty()) {
-            return data.result();
-        }
-    }
-    return SourceRangeContainer();
-}
-
 SourceRangeContainer FollowSymbol::followSymbol(CXTranslationUnit tu,
-                                                CXIndex index,
                                                 const Cursor &fullCursor,
                                                 uint line,
-                                                uint column,
-                                                const QVector<Utf8String> &dependentFiles,
-                                                const CommandLineArguments &currentArgs)
+                                                uint column)
 {
     std::unique_ptr<Tokens> tokens(new Tokens(fullCursor));
 
@@ -303,35 +182,23 @@ SourceRangeContainer FollowSymbol::followSymbol(CXTranslationUnit tu,
     if (cursor.isDefinition())
         return extractMatchingTokenRange(cursor.canonical(), tokenSpelling);
 
-    SourceRangeContainer result;
     if (!cursor.isDeclaration()) {
         // This is the symbol usage
-        // We want to return definition or at least declaration of this symbol
-        const Cursor referencedCursor = cursor.referenced();
-        if (referencedCursor.isNull() || referencedCursor == cursor)
+        // We want to return definition
+        cursor = cursor.referenced();
+        if (cursor.isNull() || !cursor.isDefinition()) {
+            // We can't find definition in this TU
             return SourceRangeContainer();
-        result = extractMatchingTokenRange(referencedCursor, tokenSpelling);
-
-        // We've already found what we need
-        if (referencedCursor.isDefinition())
-            return result;
-        cursor = referencedCursor;
+        }
+        return extractMatchingTokenRange(cursor, tokenSpelling);
     }
 
-    const Cursor definitionCursor = cursor.definition();
-    if (!definitionCursor.isNull() && definitionCursor != cursor) {
-        // If we are able to find a definition in current TU
-        return extractMatchingTokenRange(definitionCursor, tokenSpelling);
-    }
+    cursor = cursor.definition();
+    // If we are able to find a definition in current TU
+    if (!cursor.isNull())
+        return extractMatchingTokenRange(cursor, tokenSpelling);
 
-    // Search for the definition in the dependent files
-    SourceRangeContainer dependentFilesResult = followSymbolInDependentFiles(index,
-                                                                             cursor,
-                                                                             tokenSpelling,
-                                                                             dependentFiles,
-                                                                             currentArgs);
-    return dependentFilesResult.start().filePath().isEmpty() ?