Clang: Rename defineName in macroName

Change-Id: Iaf8da991032e5ed4726384c051290a77887351fa
Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>

src/libs/clangsupport/projectpartcontainerv2.h

@@ -40,12 +40,12 @@ public:
     ProjectPartContainer() = default;
     ProjectPartContainer(Utils::SmallString &&projectPartId,
                          Utils::SmallStringVector &&arguments,
-                         Utils::SmallStringVector &&defineNames,
+                         Utils::SmallStringVector &&macroNames,
                          FilePathIds &&headerPathIds,
                          FilePathIds &&sourcePathIds)
         : m_projectPartId(std::move(projectPartId)),
           m_arguments(std::move(arguments)),
-          m_defineNames(std::move(defineNames)),
+          m_macroNames(std::move(macroNames)),
           m_headerPathIds(std::move(headerPathIds)),
           m_sourcePathIds(std::move(sourcePathIds))
     {
@@ -66,9 +66,9 @@ public:
         return std::move(m_arguments);
     }
 
-    const Utils::SmallStringVector &defineNames() const
+    const Utils::SmallStringVector &macroNames() const
     {
-        return m_defineNames;
+        return m_macroNames;
     }
 
     const FilePathIds &sourcePathIds() const
@@ -85,7 +85,7 @@ public:
     {
         out << container.m_projectPartId;
         out << container.m_arguments;
-        out << container.m_defineNames;
+        out << container.m_macroNames;
         out << container.m_headerPathIds;
         out << container.m_sourcePathIds;
 
@@ -96,7 +96,7 @@ public:
     {
         in >> container.m_projectPartId;
         in >> container.m_arguments;
-        in >> container.m_defineNames;
+        in >> container.m_macroNames;
         in >> container.m_headerPathIds;
         in >> container.m_sourcePathIds;
 
@@ -107,7 +107,7 @@ public:
     {
         return first.m_projectPartId == second.m_projectPartId
             && first.m_arguments == second.m_arguments
-            && first.m_defineNames == second.m_defineNames
+            && first.m_macroNames == second.m_macroNames
             && first.m_headerPathIds == second.m_headerPathIds
             && first.m_sourcePathIds == second.m_sourcePathIds;
     }
@@ -116,12 +116,12 @@ public:
     {
         return std::tie(first.m_projectPartId,
                         first.m_arguments,
-                        first.m_defineNames,
+                        first.m_macroNames,
                         first.m_headerPathIds,
                         first.m_sourcePathIds)
              < std::tie(second.m_projectPartId,
                         second.m_arguments,
-                        second.m_defineNames,
+                        second.m_macroNames,
                         second.m_headerPathIds,
                         second.m_sourcePathIds);
     }
@@ -134,7 +134,7 @@ public:
 private:
     Utils::SmallString m_projectPartId;
     Utils::SmallStringVector m_arguments;
-    Utils::SmallStringVector m_defineNames;
+    Utils::SmallStringVector m_macroNames;
     FilePathIds m_headerPathIds;
     FilePathIds m_sourcePathIds;
 };

src/libs/clangsupport/refactoringdatabaseinitializer.h

@@ -47,7 +47,7 @@ public:
         createDirectoriesTable();
         createProjectPartsTable();
         createProjectPartsSourcesTable();
-        createUsedDefinesTable();
+        createUsedMacrosTable();
 
         transaction.commit();
     }
@@ -131,16 +131,16 @@ public:
         table.initialize(database);
     }
 
-    void createUsedDefinesTable()
+    void createUsedMacrosTable()
     {
         Sqlite::Table table;
         table.setUseIfNotExists(true);
-        table.setName("usedDefines");
+        table.setName("usedMacros");
-        table.addColumn("usedDefineId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey);
+        table.addColumn("usedMacroId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey);
         const Sqlite::Column &sourceIdColumn = table.addColumn("sourceId", Sqlite::ColumnType::Integer);
-        const Sqlite::Column &defineNameColumn = table.addColumn("defineName", Sqlite::ColumnType::Text);
+        const Sqlite::Column &macroNameColumn = table.addColumn("macroName", Sqlite::ColumnType::Text);
-        table.addIndex({sourceIdColumn, defineNameColumn});
+        table.addIndex({sourceIdColumn, macroNameColumn});
-        table.addIndex({defineNameColumn});
+        table.addIndex({macroNameColumn});
 
         table.initialize(database);
     }

src/plugins/clangpchmanager/projectupdater.cpp

@@ -121,7 +121,7 @@ QStringList ProjectUpdater::compilerArguments(CppTools::ProjectPart *projectPart
     return builder.build(CppTools::ProjectFile::CXXHeader, CompilerOptionsBuilder::PchUsage::None);
 }
 
-Utils::SmallStringVector ProjectUpdater::createDefineNames(CppTools::ProjectPart *projectPart)
+Utils::SmallStringVector ProjectUpdater::createMacroNames(CppTools::ProjectPart *projectPart)
 {
     return Utils::transform<Utils::SmallStringVector>(projectPart->projectMacros,
                                                       [] (const ProjectExplorer::Macro &macro) {
@@ -139,7 +139,7 @@ ClangBackEnd::V2::ProjectPartContainer ProjectUpdater::toProjectPartContainer(
 
     return ClangBackEnd::V2::ProjectPartContainer(projectPart->displayName,
                                                   Utils::SmallStringVector(arguments),
-                                                  createDefineNames(projectPart),
+                                                  createMacroNames(projectPart),
                                                   std::move(headerAndSources.headers),
                                                   std::move(headerAndSources.sources));
 }

src/plugins/clangpchmanager/projectupdater.h

@@ -73,7 +73,7 @@ unittest_public:
     void addToHeaderAndSources(HeaderAndSources &headerAndSources,
                                const CppTools::ProjectFile &projectFile) const;
     static QStringList compilerArguments(CppTools::ProjectPart *projectPart);
-    static Utils::SmallStringVector createDefineNames(CppTools::ProjectPart *projectPart);
+    static Utils::SmallStringVector createMacroNames(CppTools::ProjectPart *projectPart);
     static Utils::PathStringVector createExcludedPaths(
             const ClangBackEnd::V2::FileContainers &generatedFiles);
 

src/tools/clangrefactoringbackend/source/clangrefactoringbackend-source.pri

@@ -14,8 +14,8 @@ HEADERS += \
     $$PWD/symbolindexinginterface.h \
     $$PWD/collectmacrospreprocessorcallbacks.h \
     $$PWD/projectpartentry.h \
-    $$PWD/useddefines.h \
+    $$PWD/symbolsvisitorbase.h \
-    $$PWD/symbolsvisitorbase.h
+    $$PWD/usedmacro.h
 
 !isEmpty(LIBTOOLING_LIBS) {
 SOURCES += \

src/tools/clangrefactoringbackend/source/collectmacrospreprocessorcallbacks.h

@@ -29,7 +29,7 @@
 #include "sourcelocationsutils.h"
 #include "sourcelocationentry.h"
 #include "symbolentry.h"
-#include "useddefines.h"
+#include "usedmacro.h"
 
 #include <filepath.h>
 #include <filepathid.h>
@@ -47,7 +47,7 @@ public:
     CollectMacrosPreprocessorCallbacks(SymbolEntries &symbolEntries,
                                        SourceLocationEntries &sourceLocationEntries,
                                        FilePathIds &sourceFiles,
-                                       UsedDefines &usedDefines,
+                                       UsedMacros &usedMacros,
                                        FilePathCachingInterface &filePathCache,
                                        const clang::SourceManager &sourceManager,
                                        std::shared_ptr<clang::Preprocessor> &&preprocessor)
@@ -56,7 +56,7 @@ public:
           m_symbolEntries(symbolEntries),
           m_sourceLocationEntries(sourceLocationEntries),
           m_sourceFiles(sourceFiles),
-          m_usedDefines(usedDefines)
+          m_usedMacros(usedMacros)
     {
     }
 
@@ -87,7 +87,7 @@ public:
                 const clang::Token &macroNameToken,
                 const clang::MacroDefinition &macroDefinition) override
     {
-        addUsedDefine(macroNameToken, macroDefinition);
+        addUsedMacro(macroNameToken, macroDefinition);
         addMacroAsSymbol(macroNameToken,
                          firstMacroInfo(macroDefinition.getLocalDirective()),
                          SymbolType::MacroUsage);
@@ -97,7 +97,7 @@ public:
                const clang::Token &macroNameToken,
                const clang::MacroDefinition &macroDefinition) override
     {
-        addUsedDefine( macroNameToken, macroDefinition);
+        addUsedMacro( macroNameToken, macroDefinition);
         addMacroAsSymbol(macroNameToken,
                          firstMacroInfo(macroDefinition.getLocalDirective()),
                          SymbolType::MacroUsage);
@@ -107,7 +107,7 @@ public:
                  const clang::MacroDefinition &macroDefinition,
                  clang::SourceRange) override
     {
-        addUsedDefine(macroNameToken, macroDefinition);
+        addUsedMacro(macroNameToken, macroDefinition);
         addMacroAsSymbol(macroNameToken,
                          firstMacroInfo(macroDefinition.getLocalDirective()),
                          SymbolType::MacroUsage);
@@ -133,7 +133,7 @@ public:
                       clang::SourceRange,
                       const clang::MacroArgs *) override
     {
-        addUsedDefine(macroNameToken, macroDefinition);
+        addUsedMacro(macroNameToken, macroDefinition);
         addMacroAsSymbol(macroNameToken,
                          firstMacroInfo(macroDefinition.getLocalDirective()),
                          SymbolType::MacroUsage);
@@ -142,63 +142,63 @@ public:
     void EndOfMainFile() override
     {
         filterOutHeaderGuards();
-        mergeUsedDefines();
+        mergeUsedMacros();
         filterOutExports();
     }
 
     void filterOutHeaderGuards()
     {
-        auto partitionPoint = std::stable_partition(m_maybeUsedDefines.begin(),
+        auto partitionPoint = std::stable_partition(m_maybeUsedMacros.begin(),
-                                                    m_maybeUsedDefines.end(),
+                                                    m_maybeUsedMacros.end(),
-                                                    [&] (const UsedDefine &usedDefine) {
+                                                    [&] (const UsedMacro &usedMacro) {
-            llvm::StringRef id{usedDefine.defineName.data(), usedDefine.defineName.size()};
+            llvm::StringRef id{usedMacro.macroName.data(), usedMacro.macroName.size()};
             clang::IdentifierInfo &identifierInfo = m_preprocessor->getIdentifierTable().get(id);
             clang::MacroInfo *macroInfo = m_preprocessor->getMacroInfo(&identifierInfo);
             return !macroInfo || !macroInfo->isUsedForHeaderGuard();
         });
 
-        m_maybeUsedDefines.erase(partitionPoint, m_maybeUsedDefines.end());
+        m_maybeUsedMacros.erase(partitionPoint, m_maybeUsedMacros.end());
     }
 
     void filterOutExports()
     {
-        auto partitionPoint = std::stable_partition(m_usedDefines.begin(),
+        auto partitionPoint = std::stable_partition(m_usedMacros.begin(),
-                                                    m_usedDefines.end(),
+                                                    m_usedMacros.end(),
-                                                    [&] (const UsedDefine &usedDefine) {
+                                                    [&] (const UsedMacro &usedMacro) {
-            return !usedDefine.defineName.contains("EXPORT");
+            return !usedMacro.macroName.contains("EXPORT");
         });
 
-        m_usedDefines.erase(partitionPoint, m_usedDefines.end());
+        m_usedMacros.erase(partitionPoint, m_usedMacros.end());
     }
 
-    void mergeUsedDefines()
+    void mergeUsedMacros()
     {
-        m_usedDefines.reserve(m_usedDefines.size() + m_maybeUsedDefines.size());
+        m_usedMacros.reserve(m_usedMacros.size() + m_maybeUsedMacros.size());
-        auto insertionPoint = m_usedDefines.insert(m_usedDefines.end(),
+        auto insertionPoint = m_usedMacros.insert(m_usedMacros.end(),
-                                                   m_maybeUsedDefines.begin(),
+                                                  m_maybeUsedMacros.begin(),
-                                                   m_maybeUsedDefines.end());
+                                                  m_maybeUsedMacros.end());
-        std::inplace_merge(m_usedDefines.begin(), insertionPoint, m_usedDefines.end());
+        std::inplace_merge(m_usedMacros.begin(), insertionPoint, m_usedMacros.end());
     }
 
-    static void addUsedDefine(UsedDefine &&usedDefine, UsedDefines &usedDefines)
+    static void addUsedMacro(UsedMacro &&usedMacro, UsedMacros &usedMacros)
     {
-        auto found = std::lower_bound(usedDefines.begin(),
+        auto found = std::lower_bound(usedMacros.begin(),
-                                      usedDefines.end(), usedDefine);
+                                      usedMacros.end(), usedMacro);
 
-        if (found == usedDefines.end() || *found != usedDefine)
+        if (found == usedMacros.end() || *found != usedMacro)
-            usedDefines.insert(found, std::move(usedDefine));
+            usedMacros.insert(found, std::move(usedMacro));
     }
 
-    void addUsedDefine(const clang::Token &macroNameToken,
+    void addUsedMacro(const clang::Token &macroNameToken,
                        const clang::MacroDefinition &macroDefinition)
     {
         clang::MacroInfo *macroInfo = macroDefinition.getMacroInfo();
-        UsedDefine usedDefine{macroNameToken.getIdentifierInfo()->getName(),
+        UsedMacro usedMacro{macroNameToken.getIdentifierInfo()->getName(),
                               filePathId(macroNameToken.getLocation())};
         if (macroInfo)
-            addUsedDefine(std::move(usedDefine), m_usedDefines);
+            addUsedMacro(std::move(usedMacro), m_usedMacros);
         else
-            addUsedDefine(std::move(usedDefine), m_maybeUsedDefines);
+            addUsedMacro(std::move(usedMacro), m_maybeUsedMacros);
     }
 
     static const clang::MacroInfo *firstMacroInfo(const clang::MacroDirective *macroDirective)
@@ -258,12 +258,12 @@ public:
     }
 
 private:
-    UsedDefines m_maybeUsedDefines;
+    UsedMacros m_maybeUsedMacros;
     std::shared_ptr<clang::Preprocessor> m_preprocessor;
     SymbolEntries &m_symbolEntries;
     SourceLocationEntries &m_sourceLocationEntries;
     FilePathIds &m_sourceFiles;
-    UsedDefines &m_usedDefines;
+    UsedMacros &m_usedMacros;
     bool m_skipInclude = false;
 };
 

src/tools/clangrefactoringbackend/source/collectmacrossourcefilecallbacks.cpp

@@ -37,7 +37,7 @@ bool CollectMacrosSourceFileCallbacks::handleBeginSource(clang::CompilerInstance
                 m_symbolEntries,
                 m_sourceLocationEntries,
                 m_sourceFiles,
-                m_usedDefines,
+                m_usedMacros,
                 m_filePathCache,
                 compilerInstance.getSourceManager(),
                 compilerInstance.getPreprocessorPtr());

src/tools/clangrefactoringbackend/source/collectmacrossourcefilecallbacks.h

@@ -27,7 +27,7 @@
 
 #include "sourcelocationentry.h"
 #include "symbolentry.h"
-#include "useddefines.h"
+#include "usedmacro.h"
 
 #include <filepathcachinginterface.h>
 
@@ -64,14 +64,14 @@ public:
         m_sourceFiles.clear();
     }
 
-    const UsedDefines &usedDefines() const
+    const UsedMacros &usedMacros() const
     {
-        return m_usedDefines;
+        return m_usedMacros;
     }
 
 private:
     FilePathIds m_sourceFiles;
-    UsedDefines m_usedDefines;
+    UsedMacros m_usedMacros;
     SymbolEntries &m_symbolEntries;
     SourceLocationEntries &m_sourceLocationEntries;
     FilePathCachingInterface &m_filePathCache;

src/tools/clangrefactoringbackend/source/storagesqlitestatementfactory.h

@@ -81,14 +81,14 @@ public:
         return table;
     }
 
-    Sqlite::Table createNewUsedDefinesTable() const
+    Sqlite::Table createNewUsedMacrosTable() const
     {
         Sqlite::Table table;
-        table.setName("newUsedDefines");
+        table.setName("newUsedMacros");
         table.setUseTemporaryTable(true);
         const Sqlite::Column &sourceIdColumn = table.addColumn("sourceId", Sqlite::ColumnType::Integer);
-        const Sqlite::Column &defineNameColumn = table.addColumn("defineName", Sqlite::ColumnType::Text);
+        const Sqlite::Column &macroNameColumn = table.addColumn("macroName", Sqlite::ColumnType::Text);
-        table.addIndex({sourceIdColumn, defineNameColumn});
+        table.addIndex({sourceIdColumn, macroNameColumn});
 
         table.initialize(database);
 
@@ -100,7 +100,7 @@ public:
     Database &database;
     Sqlite::Table newSymbolsTablet{createNewSymbolsTable()};
     Sqlite::Table newLocationsTable{createNewLocationsTable()};
-    Sqlite::Table newUsedDefineTable{createNewUsedDefinesTable()};
+    Sqlite::Table newUsedMacroTable{createNewUsedMacrosTable()};
     WriteStatement insertSymbolsToNewSymbolsStatement{
         "INSERT INTO newSymbols(temporarySymbolId, usr, symbolName) VALUES(?,?,?)",
         database};
@@ -166,20 +166,20 @@ public:
         "SELECT compilerArguments FROM projectParts WHERE projectPartId = (SELECT projectPartId FROM projectPartsSources WHERE sourceId = ?)",
         database
     };
-   WriteStatement insertIntoNewUsedDefinesStatement{
+   WriteStatement insertIntoNewUsedMacrosStatement{
-       "INSERT INTO newUsedDefines(sourceId, defineName) VALUES (?,?)",
+       "INSERT INTO newUsedMacros(sourceId, macroName) VALUES (?,?)",
        database
    };
-   WriteStatement syncNewUsedDefinesStatement{
+   WriteStatement syncNewUsedMacrosStatement{
-        "INSERT INTO usedDefines(sourceId, defineName) SELECT sourceId, defineName FROM newUsedDefines WHERE NOT EXISTS (SELECT sourceId FROM usedDefines WHERE usedDefines.sourceId == newUsedDefines.sourceId AND usedDefines.defineName == newUsedDefines.defineName)",
+        "INSERT INTO usedMacros(sourceId, macroName) SELECT sourceId, macroName FROM newUsedMacros WHERE NOT EXISTS (SELECT sourceId FROM usedMacros WHERE usedMacros.sourceId == newUsedMacros.sourceId AND usedMacros.macroName == newUsedMacros.macroName)",
         database
     };
-   WriteStatement deleteOutdatedUsedDefinesStatement{
+   WriteStatement deleteOutdatedUsedMacrosStatement{
-        "DELETE FROM usedDefines WHERE sourceId IN (SELECT sourceId FROM newUsedDefines) AND NOT EXISTS (SELECT sourceId FROM newUsedDefines WHERE newUsedDefines.sourceId == usedDefines.sourceId AND newUsedDefines.defineName == usedDefines.defineName)",
+        "DELETE FROM usedMacros WHERE sourceId IN (SELECT sourceId FROM newUsedMacros) AND NOT EXISTS (SELECT sourceId FROM newUsedMacros WHERE newUsedMacros.sourceId == usedMacros.sourceId AND newUsedMacros.macroName == usedMacros.macroName)",
         database
     };
-   WriteStatement deleteNewUsedDefinesTableStatement{
+   WriteStatement deleteNewUsedMacrosTableStatement{
-        "DELETE FROM newUsedDefines",
+        "DELETE FROM newUsedMacros",
         database
     };
 };

src/tools/clangrefactoringbackend/source/symbolindexer.cpp

@@ -68,7 +68,7 @@ void SymbolIndexer::updateProjectPart(V2::ProjectPartContainer &&projectPart,
     m_symbolStorage.updateProjectPartSources(projectPart.projectPartId(),
                                              m_symbolsCollector.sourceFiles());
 
-    m_symbolStorage.insertOrUpdateUsedDefines(m_symbolsCollector.usedDefines());
+    m_symbolStorage.insertOrUpdateUsedMacros(m_symbolsCollector.usedMacros());
 
     transaction.commit();
 

src/tools/clangrefactoringbackend/source/symbolscollector.cpp

@@ -77,9 +77,9 @@ const FilePathIds &SymbolsCollector::sourceFiles() const
     return m_collectMacrosSourceFileCallbacks.sourceFiles();
 }
 
-const UsedDefines &SymbolsCollector::usedDefines() const
+const UsedMacros &SymbolsCollector::usedMacros() const
 {
-    return m_collectMacrosSourceFileCallbacks.usedDefines();
+    return m_collectMacrosSourceFileCallbacks.usedMacros();
 }
 
 } // namespace ClangBackEnd

src/tools/clangrefactoringbackend/source/symbolscollector.h

@@ -51,7 +51,7 @@ public:
     const SymbolEntries &symbols() const override;
     const SourceLocationEntries &sourceLocations() const override;
     const FilePathIds &sourceFiles() const override;
-    const UsedDefines &usedDefines() const override;
+    const UsedMacros &usedMacros() const override;
 
 private:
     ClangTool m_clangTool;

src/tools/clangrefactoringbackend/source/symbolscollectorinterface.h

@@ -27,7 +27,7 @@
 
 #include "symbolentry.h"
 #include "sourcelocationentry.h"
-#include "useddefines.h"
+#include "usedmacro.h"
 
 #include <filecontainerv2.h>
 
@@ -53,7 +53,7 @@ public:
     virtual const SymbolEntries &symbols() const = 0;
     virtual const SourceLocationEntries &sourceLocations() const = 0;
     virtual const FilePathIds &sourceFiles() const = 0;
-    virtual const UsedDefines &usedDefines() const = 0;
+    virtual const UsedMacros &usedMacros() const = 0;
 };
 
 } // namespace ClangBackEnd

src/tools/clangrefactoringbackend/source/symbolstorage.h

@@ -81,15 +81,15 @@ public:
         }
     }
 
-    void insertOrUpdateUsedDefines(const UsedDefines &usedDefines) override
+    void insertOrUpdateUsedMacros(const UsedMacros &usedMacros) override
     {
-        WriteStatement &insertStatement = m_statementFactory.insertIntoNewUsedDefinesStatement;
+        WriteStatement &insertStatement = m_statementFactory.insertIntoNewUsedMacrosStatement;
-        for (const UsedDefine &usedDefine : usedDefines)
+        for (const UsedMacro &usedMacro : usedMacros)
-            insertStatement.write(usedDefine.filePathId.filePathId, usedDefine.defineName);
+            insertStatement.write(usedMacro.filePathId.filePathId, usedMacro.macroName);
 
-        m_statementFactory.syncNewUsedDefinesStatement.execute();
+        m_statementFactory.syncNewUsedMacrosStatement.execute();
-        m_statementFactory.deleteOutdatedUsedDefinesStatement.execute();
+        m_statementFactory.deleteOutdatedUsedMacrosStatement.execute();
-        m_statementFactory.deleteNewUsedDefinesTableStatement.execute();
+        m_statementFactory.deleteNewUsedMacrosTableStatement.execute();
     }
 
     void updateProjectPartSources(Utils::SmallStringView projectPartName,

src/tools/clangrefactoringbackend/source/symbolstorageinterface.h

@@ -28,7 +28,7 @@
 #include "projectpartentry.h"
 #include "sourcelocationentry.h"
 #include "symbolentry.h"
-#include "useddefines.h"
+#include "usedmacro.h"
 
 #include <sqlitetransaction.h>
 
@@ -48,7 +48,7 @@ public:
                                            const Utils::SmallStringVector &commandLineArguments) = 0;
     virtual void updateProjectPartSources(Utils::SmallStringView projectPartName,
                                           const FilePathIds &sourceFilePathIds) = 0;
-    virtual void insertOrUpdateUsedDefines(const UsedDefines &usedDefines) = 0;
+    virtual void insertOrUpdateUsedMacros(const UsedMacros &usedMacros) = 0;
 };
 
 } // namespace ClangBackEnd

src/tools/clangrefactoringbackend/source/usedmacro.h

@@ -33,35 +33,35 @@
 
 namespace ClangBackEnd {
 
-class UsedDefine
+class UsedMacro
 {
 public:
-    constexpr UsedDefine() = default;
+    constexpr UsedMacro() = default;
-    UsedDefine(Utils::SmallStringView defineName, FilePathId filePathId)
+    UsedMacro(Utils::SmallStringView macroName, FilePathId filePathId)
-        : defineName(defineName),
+        : macroName(macroName),
           filePathId(filePathId)
     {}
 
-    friend bool operator<(const UsedDefine &first, const UsedDefine &second)
+    friend bool operator<(const UsedMacro &first, const UsedMacro &second)
     {
-        return std::tie(first.filePathId, first.defineName)
+        return std::tie(first.filePathId, first.macroName)
-             < std::tie(second.filePathId, second.defineName);
+             < std::tie(second.filePathId, second.macroName);
     }
 
-    friend bool operator==(const UsedDefine &first, const UsedDefine &second)
+    friend bool operator==(const UsedMacro &first, const UsedMacro &second)
     {
-        return first.filePathId == second.filePathId && first.defineName == second.defineName;
+        return first.filePathId == second.filePathId && first.macroName == second.macroName;
     }
 
-    friend bool operator!=(const UsedDefine &first, const UsedDefine &second)
+    friend bool operator!=(const UsedMacro &first, const UsedMacro &second)
     {
         return !(first == second);
     }
 public:
-    Utils::SmallString defineName;
+    Utils::SmallString macroName;
     FilePathId filePathId;
 };
 
-using UsedDefines = std::vector<UsedDefine>;
+using UsedMacros = std::vector<UsedMacro>;
 
 } // ClangBackEnd

tests/unit/unittest/gtest-creator-printing.cpp

@@ -44,7 +44,7 @@
 #include <filepathview.h>
 #include <tooltipinfo.h>
 #include <projectpartentry.h>
-#include <useddefines.h>
+#include <usedmacro.h>
 
 #include <cpptools/usages.h>
 
@@ -817,12 +817,12 @@ std::ostream &operator<<(std::ostream &out, const ProjectPartEntry &projectPartE
                << ")";
 }
 
-std::ostream &operator<<(std::ostream &out, const UsedDefine &usedDefine)
+std::ostream &operator<<(std::ostream &out, const UsedMacro &usedMacro)
 {
     return out << "("
-               << usedDefine.filePathId
+               << usedMacro.filePathId
                << ", "
-               << usedDefine.defineName
+               << usedMacro.macroName
                << ")";
 }
 

tests/unit/unittest/gtest-creator-printing.h

@@ -132,7 +132,7 @@ using FilePathView = AbstractFilePathView<'/'>;
 using NativeFilePathView = AbstractFilePathView<'\\'>;
 class ToolTipInfo;
 class ProjectPartEntry;
-class UsedDefine;
+class UsedMacro;
 
 std::ostream &operator<<(std::ostream &out, const SourceLocationEntry &entry);
 std::ostream &operator<<(std::ostream &out, const IdPaths &idPaths);
@@ -195,7 +195,7 @@ std::ostream &operator<<(std::ostream &out, const TokenInfos &tokenInfos);
 std::ostream &operator<<(std::ostream &out, const FilePathView &filePathView);
 std::ostream &operator<<(std::ostream &out, const NativeFilePathView &nativeFilePathView);
 std::ostream &operator<<(std::ostream &out, const ProjectPartEntry &projectPartEntry);
-std::ostream &operator<<(std::ostream &out, const UsedDefine &usedDefine);
+std::ostream &operator<<(std::ostream &out, const UsedMacro &usedMacro);
 
 void PrintTo(const FilePath &filePath, ::std::ostream *os);
 void PrintTo(const FilePathView &filePathView, ::std::ostream *os);

tests/unit/unittest/mocksymbolscollector.h

@@ -54,6 +54,6 @@ public:
     MOCK_CONST_METHOD0(sourceFiles,
                        const ClangBackEnd::FilePathIds &());
 
-    MOCK_CONST_METHOD0(usedDefines,
+    MOCK_CONST_METHOD0(usedMacros,
-                       const ClangBackEnd::UsedDefines &());
+                       const ClangBackEnd::UsedMacros &());
 };

tests/unit/unittest/mocksymbolstorage.h

@@ -43,6 +43,6 @@ public:
    MOCK_METHOD2(updateProjectPartSources,
                 void(Utils::SmallStringView projectPartName,
                      const ClangBackEnd::FilePathIds &sourceFilePathIds));
-   MOCK_METHOD1(insertOrUpdateUsedDefines,
+   MOCK_METHOD1(insertOrUpdateUsedMacros,
-                void (const ClangBackEnd::UsedDefines &usedDefines));
+                void (const ClangBackEnd::UsedMacros &usedMacros));
 };

tests/unit/unittest/projectupdater-test.cpp

@@ -84,7 +84,7 @@ protected:
 
         expectedContainer = {projectPartId.clone(),
                              arguments.clone(),
-                             defineNames.clone(),
+                             macroNames.clone(),
                              {filePathId(headerPaths[1])},
                              {filePathIds(sourcePaths)}};
     }
@@ -101,7 +101,7 @@ protected:
     Utils::SmallString projectPartId2{"project2"};
     Utils::PathStringVector headerPaths = {"/path/to/header1.h", "/path/to/header2.h"};
     Utils::PathStringVector sourcePaths = {"/path/to/source1.cpp", "/path/to/source2.cpp"};
-    Utils::SmallStringVector defineNames = {"DEFINE"};
+    Utils::SmallStringVector macroNames = {"DEFINE"};
     CppTools::ProjectFile header1ProjectFile{QString(headerPaths[0]), CppTools::ProjectFile::CXXHeader};
     CppTools::ProjectFile header2ProjectFile{QString(headerPaths[1]), CppTools::ProjectFile::CXXHeader};
     CppTools::ProjectFile source1ProjectFile{QString(sourcePaths[0]), CppTools::ProjectFile::CXXSource};

tests/unit/unittest/refactoringdatabaseinitializer-test.cpp

@@ -103,15 +103,15 @@ TEST_F(RefactoringDatabaseInitializer, AddProjectPartsSourcesTable)
     initializer.createProjectPartsSourcesTable();
 }
 
-TEST_F(RefactoringDatabaseInitializer, AddUsedDefinesTable)
+TEST_F(RefactoringDatabaseInitializer, AddUsedMacrosTable)
 {
     InSequence s;
 
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS usedDefines(usedDefineId INTEGER PRIMARY KEY, sourceId INTEGER, defineName TEXT)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS usedMacros(usedMacroId INTEGER PRIMARY KEY, sourceId INTEGER, macroName TEXT)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_usedDefines_sourceId_defineName ON usedDefines(sourceId, defineName)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_usedMacros_sourceId_macroName ON usedMacros(sourceId, macroName)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_usedDefines_defineName ON usedDefines(defineName)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_usedMacros_macroName ON usedMacros(macroName)")));
 
-    initializer.createUsedDefinesTable();
+    initializer.createUsedMacrosTable();
 }
 
 TEST_F(RefactoringDatabaseInitializer, CreateInTheContructor)
@@ -132,9 +132,9 @@ TEST_F(RefactoringDatabaseInitializer, CreateInTheContructor)
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectPartsSources(projectPartId INTEGER, sourceId INTEGER)")));
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_projectPartsSources_sourceId_projectPartId ON projectPartsSources(sourceId, projectPartId)")));
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_projectPartsSources_projectPartId ON projectPartsSources(projectPartId)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS usedDefines(usedDefineId INTEGER PRIMARY KEY, sourceId INTEGER, defineName TEXT)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS usedMacros(usedMacroId INTEGER PRIMARY KEY, sourceId INTEGER, macroName TEXT)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_usedDefines_sourceId_defineName ON usedDefines(sourceId, defineName)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_usedMacros_sourceId_macroName ON usedMacros(sourceId, macroName)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_usedDefines_defineName ON usedDefines(defineName)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_usedMacros_macroName ON usedMacros(macroName)")));
     EXPECT_CALL(mockDatabase, commit());
 
     Initializer initializer{mockDatabase};

tests/unit/unittest/storagesqlitestatementfactory-test.cpp

@@ -67,14 +67,14 @@ TEST_F(StorageSqliteStatementFactory, AddNewLocationsTable)
     factory.createNewLocationsTable();
 }
 
-TEST_F(StorageSqliteStatementFactory, AddNewUsedDefineTable)
+TEST_F(StorageSqliteStatementFactory, AddNewUsedMacroTable)
 {
     InSequence s;
 
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TEMPORARY TABLE newUsedDefines(sourceId INTEGER, defineName TEXT)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TEMPORARY TABLE newUsedMacros(sourceId INTEGER, macroName TEXT)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_newUsedDefines_sourceId_defineName ON newUsedDefines(sourceId, defineName)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_newUsedMacros_sourceId_macroName ON newUsedMacros(sourceId, macroName)")));
 
-    factory.createNewUsedDefinesTable();
+    factory.createNewUsedMacrosTable();
 }
 
 TEST_F(StorageSqliteStatementFactory, AddTablesInConstructor)
@@ -87,8 +87,8 @@ TEST_F(StorageSqliteStatementFactory, AddTablesInConstructor)
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_newSymbols_symbolId ON newSymbols(symbolId)")));
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE TEMPORARY TABLE newLocations(temporarySymbolId INTEGER, symbolId INTEGER, line INTEGER, column INTEGER, sourceId INTEGER)")));
     EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_newLocations_sourceId ON newLocations(sourceId)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TEMPORARY TABLE newUsedDefines(sourceId INTEGER, defineName TEXT)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE TEMPORARY TABLE newUsedMacros(sourceId INTEGER, macroName TEXT)")));
-    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_newUsedDefines_sourceId_defineName ON newUsedDefines(sourceId, defineName)")));
+    EXPECT_CALL(mockDatabase, execute(Eq("CREATE INDEX IF NOT EXISTS index_newUsedMacros_sourceId_macroName ON newUsedMacros(sourceId, macroName)")));
     EXPECT_CALL(mockDatabase, commit());
 
     StatementFactory factory{mockDatabase};
@@ -190,27 +190,27 @@ TEST_F(StorageSqliteStatementFactory, GetCompileArgumentsForFileId)
                 Eq("SELECT compilerArguments FROM projectParts WHERE projectPartId = (SELECT projectPartId FROM projectPartsSources WHERE sourceId = ?)"));
 }
 
-TEST_F(StorageSqliteStatementFactory, InsertIntoNewUsedDefines)
+TEST_F(StorageSqliteStatementFactory, InsertIntoNewUsedMacros)
 {
-    ASSERT_THAT(factory.insertIntoNewUsedDefinesStatement.sqlStatement,
+    ASSERT_THAT(factory.insertIntoNewUsedMacrosStatement.sqlStatement,
-                Eq("INSERT INTO newUsedDefines(sourceId, defineName) VALUES (?,?)"));
+                Eq("INSERT INTO newUsedMacros(sourceId, macroName) VALUES (?,?)"));
 }
 
-TEST_F(StorageSqliteStatementFactory, SyncNewUsedDefines)
+TEST_F(StorageSqliteStatementFactory, SyncNewUsedMacros)
 {
-    ASSERT_THAT(factory.syncNewUsedDefinesStatement.sqlStatement,
+    ASSERT_THAT(factory.syncNewUsedMacrosStatement.sqlStatement,
-                Eq("INSERT INTO usedDefines(sourceId, defineName) SELECT sourceId, defineName FROM newUsedDefines WHERE NOT EXISTS (SELECT sourceId FROM usedDefines WHERE usedDefines.sourceId == newUsedDefines.sourceId AND usedDefines.defineName == newUsedDefines.defineName)"));
+                Eq("INSERT INTO usedMacros(sourceId, macroName) SELECT sourceId, macroName FROM newUsedMacros WHERE NOT EXISTS (SELECT sourceId FROM usedMacros WHERE usedMacros.sourceId == newUsedMacros.sourceId AND usedMacros.macroName == newUsedMacros.macroName)"));
 }
 
-TEST_F(StorageSqliteStatementFactory, DeleteUnusedDefines)
+TEST_F(StorageSqliteStatementFactory, DeleteUnusedMacros)
 {
-    ASSERT_THAT(factory.deleteOutdatedUsedDefinesStatement.sqlStatement,
+    ASSERT_THAT(factory.deleteOutdatedUsedMacrosStatement.sqlStatement,
-                Eq("DELETE FROM usedDefines WHERE sourceId IN (SELECT sourceId FROM newUsedDefines) AND NOT EXISTS (SELECT sourceId FROM newUsedDefines WHERE newUsedDefines.sourceId == usedDefines.sourceId AND newUsedDefines.defineName == usedDefines.defineName)"));
+                Eq("DELETE FROM usedMacros WHERE sourceId IN (SELECT sourceId FROM newUsedMacros) AND NOT EXISTS (SELECT sourceId FROM newUsedMacros WHERE newUsedMacros.sourceId == usedMacros.sourceId AND newUsedMacros.macroName == usedMacros.macroName)"));
 }
 
-TEST_F(StorageSqliteStatementFactory, DeleteAllInNewUnusedDefines)
+TEST_F(StorageSqliteStatementFactory, DeleteAllInNewUnusedMacros)
 {
-    ASSERT_THAT(factory.deleteNewUsedDefinesTableStatement.sqlStatement,
+    ASSERT_THAT(factory.deleteNewUsedMacrosTableStatement.sqlStatement,
-                Eq("DELETE FROM newUsedDefines"));
+                Eq("DELETE FROM newUsedMacros"));
 }
 }

tests/unit/unittest/symbolindexer-test.cpp

@@ -47,7 +47,7 @@ using ClangBackEnd::SymbolEntry;
 using ClangBackEnd::SourceLocationEntries;
 using ClangBackEnd::SourceLocationEntry;
 using ClangBackEnd::SymbolType;
-using ClangBackEnd::UsedDefines;
+using ClangBackEnd::UsedMacros;
 
 MATCHER_P2(IsFileId, directoryId, fileNameId,
           std::string(negation ? "isn't " : "is ")
@@ -64,7 +64,7 @@ protected:
         ON_CALL(mockCollector, symbols()).WillByDefault(ReturnRef(symbolEntries));
         ON_CALL(mockCollector, sourceLocations()).WillByDefault(ReturnRef(sourceLocations));
         ON_CALL(mockCollector, sourceFiles()).WillByDefault(ReturnRef(sourceFileIds));
-        ON_CALL(mockCollector, usedDefines()).WillByDefault(ReturnRef(usedDefines));
+        ON_CALL(mockCollector, usedMacros()).WillByDefault(ReturnRef(usedMacros));
     }
 
 protected:
@@ -90,7 +90,7 @@ protected:
     SymbolEntries symbolEntries{{1, {"function", "function"}}};
     SourceLocationEntries sourceLocations{{1, {1, 1}, {42, 23}, SymbolType::Declaration}};
     FilePathIds sourceFileIds{{1, 1}, {42, 23}};
-    UsedDefines usedDefines{{"Foo", {1, 1}}};
+    UsedMacros usedMacros{{"Foo", {1, 1}}};
     NiceMock<MockSqliteTransactionBackend> mockSqliteTransactionBackend;
     NiceMock<MockSymbolsCollector> mockCollector;
     NiceMock<MockSymbolStorage> mockStorage;
@@ -181,9 +181,9 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSources)
     indexer.updateProjectParts({projectPart1, projectPart2}, Utils::clone(unsaved));
 }
 
-TEST_F(SymbolIndexer, UpdateProjectPartsCallsInsertOrUpdateUsedDefines)
+TEST_F(SymbolIndexer, UpdateProjectPartsCallsInsertOrUpdateUsedMacros)
 {
-    EXPECT_CALL(mockStorage, insertOrUpdateUsedDefines(Eq(usedDefines)))
+    EXPECT_CALL(mockStorage, insertOrUpdateUsedMacros(Eq(usedMacros)))
             .Times(2);
 
     indexer.updateProjectParts({projectPart1, projectPart2}, Utils::clone(unsaved));
@@ -201,7 +201,7 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsInOrder)
     EXPECT_CALL(mockStorage, addSymbolsAndSourceLocations(symbolEntries, sourceLocations));
     EXPECT_CALL(mockStorage, insertOrUpdateProjectPart(_, _));
     EXPECT_CALL(mockStorage, updateProjectPartSources(_, _));
-    EXPECT_CALL(mockStorage, insertOrUpdateUsedDefines(Eq(usedDefines)));
+    EXPECT_CALL(mockStorage, insertOrUpdateUsedMacros(Eq(usedMacros)));
     EXPECT_CALL(mockSqliteTransactionBackend, commit());
 
     indexer.updateProjectParts({projectPart1}, Utils::clone(unsaved));

tests/unit/unittest/symbolscollector-test.cpp

@@ -52,7 +52,7 @@ using ClangBackEnd::SourceLocationEntry;
 using ClangBackEnd::SymbolEntry;
 using ClangBackEnd::SymbolType;
 using ClangBackEnd::SymbolIndex;
-using ClangBackEnd::UsedDefine;
+using ClangBackEnd::UsedMacro;
 
 using Sqlite::Database;
 
@@ -306,36 +306,36 @@ TEST_F(SymbolsCollector, DontCollectSourceFilesAfterFilesAreCleared)
     ASSERT_THAT(collector.sourceFiles(), IsEmpty());
 }
 
-TEST_F(SymbolsCollector, CollectUsedDefinesWithExternalDefine)
+TEST_F(SymbolsCollector, CollectUsedMacrosWithExternalDefine)
 {
     auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
     collector.addFiles({fileId}, {"cc", "-DCOMPILER_ARGUMENT"});
 
     collector.collectSymbols();
 
-    ASSERT_THAT(collector.usedDefines(),
+    ASSERT_THAT(collector.usedMacros(),
-                ElementsAre(Eq(UsedDefine{"DEFINED", fileId}),
+                ElementsAre(Eq(UsedMacro{"DEFINED", fileId}),
-                            Eq(UsedDefine{"IF_DEFINE", fileId}),
+                            Eq(UsedMacro{"IF_DEFINE", fileId}),
-                            Eq(UsedDefine{"__clang__", fileId}),
+                            Eq(UsedMacro{"__clang__", fileId}),
-                            Eq(UsedDefine{"IF_NOT_DEFINE", fileId}),
+                            Eq(UsedMacro{"IF_NOT_DEFINE", fileId}),
-                            Eq(UsedDefine{"MACRO_EXPANSION", fileId}),
+                            Eq(UsedMacro{"MACRO_EXPANSION", fileId}),
-                            Eq(UsedDefine{"COMPILER_ARGUMENT", fileId})));
+                            Eq(UsedMacro{"COMPILER_ARGUMENT", fileId})));
 }
 
-TEST_F(SymbolsCollector, CollectUsedDefinesWithoutExternalDefine)
+TEST_F(SymbolsCollector, CollectUsedMacrosWithoutExternalDefine)
 {
     auto fileId = filePathId(TESTDATA_DIR "/symbolscollector_defines.h");
     collector.addFiles({fileId}, {"cc"});
 
     collector.collectSymbols();
 
-    ASSERT_THAT(collector.usedDefines(),
+    ASSERT_THAT(collector.usedMacros(),
-                ElementsAre(Eq(UsedDefine{"DEFINED", fileId}),
+                ElementsAre(Eq(UsedMacro{"DEFINED", fileId}),
-                            Eq(UsedDefine{"IF_DEFINE", fileId}),
+                            Eq(UsedMacro{"IF_DEFINE", fileId}),
-                            Eq(UsedDefine{"__clang__", fileId}),
+                            Eq(UsedMacro{"__clang__", fileId}),
-                            Eq(UsedDefine{"IF_NOT_DEFINE", fileId}),
+                            Eq(UsedMacro{"IF_NOT_DEFINE", fileId}),
-                            Eq(UsedDefine{"MACRO_EXPANSION", fileId}),
+                            Eq(UsedMacro{"MACRO_EXPANSION", fileId}),
-                            Eq(UsedDefine{"COMPILER_ARGUMENT", fileId})));
+                            Eq(UsedMacro{"COMPILER_ARGUMENT", fileId})));
 }
 
 TEST_F(SymbolsCollector, DontCollectHeaderGuards)
@@ -345,8 +345,8 @@ TEST_F(SymbolsCollector, DontCollectHeaderGuards)
 
     collector.collectSymbols();
 
-    ASSERT_THAT(collector.usedDefines(),
+    ASSERT_THAT(collector.usedMacros(),
-                Not(Contains(Eq(UsedDefine{"SYMBOLSCOLLECTOR_DEFINES_H", fileId}))));
+                Not(Contains(Eq(UsedMacro{"SYMBOLSCOLLECTOR_DEFINES_H", fileId}))));
 }
 
 TEST_F(SymbolsCollector, DontCollectDynamicLibraryExports)
@@ -356,8 +356,8 @@ TEST_F(SymbolsCollector, DontCollectDynamicLibraryExports)
 
     collector.collectSymbols();
 
-    ASSERT_THAT(collector.usedDefines(),
+    ASSERT_THAT(collector.usedMacros(),
-                Not(Contains(Eq(UsedDefine{"CLASS_EXPORT", fileId}))));
+                Not(Contains(Eq(UsedMacro{"CLASS_EXPORT", fileId}))));
 }
 
 TEST_F(SymbolsCollector, CollectMacroDefinitionSourceLocation)

tests/unit/unittest/symbolstorage-test.cpp

@@ -74,10 +74,10 @@ protected:
     MockSqliteReadStatement &getProjectPartIdStatement = statementFactory.getProjectPartIdStatement;
     MockSqliteWriteStatement &deleteAllProjectPartsSourcesWithProjectPartIdStatement = statementFactory.deleteAllProjectPartsSourcesWithProjectPartIdStatement;
     MockSqliteWriteStatement &insertProjectPartSourcesStatement = statementFactory.insertProjectPartSourcesStatement;
-    MockSqliteWriteStatement &insertIntoNewUsedDefinesStatement = statementFactory.insertIntoNewUsedDefinesStatement;
+    MockSqliteWriteStatement &insertIntoNewUsedMacrosStatement = statementFactory.insertIntoNewUsedMacrosStatement;
-    MockSqliteWriteStatement &syncNewUsedDefinesStatement = statementFactory.syncNewUsedDefinesStatement;
+    MockSqliteWriteStatement &syncNewUsedMacrosStatement = statementFactory.syncNewUsedMacrosStatement;
-    MockSqliteWriteStatement &deleteOutdatedUsedDefinesStatement = statementFactory.deleteOutdatedUsedDefinesStatement;
+    MockSqliteWriteStatement &deleteOutdatedUsedMacrosStatement = statementFactory.deleteOutdatedUsedMacrosStatement;
-    MockSqliteWriteStatement &deleteNewUsedDefinesTableStatement = statementFactory.deleteNewUsedDefinesTableStatement;
+    MockSqliteWriteStatement &deleteNewUsedMacrosTableStatement = statementFactory.deleteNewUsedMacrosTableStatement;
     SymbolEntries symbolEntries{{1, {"functionUSR", "function"}},
                                 {2, {"function2USR", "function2"}}};
     SourceLocationEntries sourceLocations{{1, {1, 3}, {42, 23}, SymbolType::Declaration},
@@ -208,17 +208,17 @@ TEST_F(SymbolStorage, UpdateProjectPartSources)
     storage.updateProjectPartSources("project", {{1, 1}, {1, 2}});
 }
 
-TEST_F(SymbolStorage, InsertOrUpdateUsedDefines)
+TEST_F(SymbolStorage, InsertOrUpdateUsedMacros)
 {
     InSequence sequence;
 
-    EXPECT_CALL(insertIntoNewUsedDefinesStatement, write(TypedEq<uint>(42), TypedEq<Utils::SmallStringView>("FOO")));
+    EXPECT_CALL(insertIntoNewUsedMacrosStatement, write(TypedEq<uint>(42), TypedEq<Utils::SmallStringView>("FOO")));
-    EXPECT_CALL(insertIntoNewUsedDefinesStatement, write(TypedEq<uint>(43), TypedEq<Utils::SmallStringView>("BAR")));
+    EXPECT_CALL(insertIntoNewUsedMacrosStatement, write(TypedEq<uint>(43), TypedEq<Utils::SmallStringView>("BAR")));
-    EXPECT_CALL(syncNewUsedDefinesStatement, execute());
+    EXPECT_CALL(syncNewUsedMacrosStatement, execute());
-    EXPECT_CALL(deleteOutdatedUsedDefinesStatement, execute());
+    EXPECT_CALL(deleteOutdatedUsedMacrosStatement, execute());
-    EXPECT_CALL(deleteNewUsedDefinesTableStatement, execute());
+    EXPECT_CALL(deleteNewUsedMacrosTableStatement, execute());
 
-    storage.insertOrUpdateUsedDefines({{"FOO", {1, 42}}, {"BAR", {1, 43}}});
+    storage.insertOrUpdateUsedMacros({{"FOO", {1, 42}}, {"BAR", {1, 43}}});
 }
 
 }