From ff421723a5c3f7b13ed4fbab0e477dcbfd3f00f9 Mon Sep 17 00:00:00 2001 From: Jacob Dufault Date: Thu, 11 May 2017 23:08:15 -0700 Subject: [PATCH] Renames and fix some operator < implementations --- src/cache.cc | 10 ++--- src/cache.h | 8 ++-- src/command_line.cc | 30 ++++++------- src/file_consumer.cc | 14 +++--- src/file_consumer.h | 12 ++--- src/indexer.cc | 98 ++++++++++++++++++++--------------------- src/indexer.h | 64 +++++++++++++-------------- src/query.cc | 101 +++++++++++++++++++++++++------------------ src/query.h | 4 +- src/serializer.cc | 46 ++++++++++---------- src/serializer.h | 6 +-- src/test.cc | 11 +++-- 12 files changed, 209 insertions(+), 195 deletions(-) diff --git a/src/cache.cc b/src/cache.cc index 06c90761..a98b4511 100644 --- a/src/cache.cc +++ b/src/cache.cc @@ -20,7 +20,7 @@ std::string GetCachedBaseFileName(const std::string& cache_directory, } // namespace -std::unique_ptr LoadCachedIndex(IndexerConfig* config, +std::unique_ptr LoadCachedIndex(IndexerConfig* config, const std::string& filename) { if (!config->enableCacheRead) return nullptr; @@ -30,9 +30,9 @@ std::unique_ptr LoadCachedIndex(IndexerConfig* config, if (!file_content) return nullptr; - optional indexed = Deserialize(filename, *file_content); - if (indexed && indexed->version == IndexedFile::kCurrentVersion) - return MakeUnique(indexed.value()); + optional indexed = Deserialize(filename, *file_content); + if (indexed && indexed->version == IndexFile::kCurrentVersion) + return MakeUnique(indexed.value()); return nullptr; } @@ -47,7 +47,7 @@ optional LoadCachedFileContents(IndexerConfig* config, void WriteToCache(IndexerConfig* config, const std::string& filename, - IndexedFile& file) { + IndexFile& file) { if (!config->enableCacheWrite) return; diff --git a/src/cache.h b/src/cache.h index f9227664..a385f0a0 100644 --- a/src/cache.h +++ b/src/cache.h @@ -8,14 +8,14 @@ using std::experimental::optional; using std::experimental::nullopt; struct IndexerConfig; -struct IndexedFile; +struct IndexFile; -std::unique_ptr LoadCachedIndex(IndexerConfig* config, - const std::string& filename); +std::unique_ptr LoadCachedIndex(IndexerConfig* config, + const std::string& filename); optional LoadCachedFileContents(IndexerConfig* config, const std::string& filename); void WriteToCache(IndexerConfig* config, const std::string& filename, - IndexedFile& file); \ No newline at end of file + IndexFile& file); \ No newline at end of file diff --git a/src/command_line.cc b/src/command_line.cc index 0952d271..e2560072 100644 --- a/src/command_line.cc +++ b/src/command_line.cc @@ -772,21 +772,21 @@ struct Index_DoIndex { }; struct Index_DoIdMap { - std::unique_ptr previous; - std::unique_ptr current; + std::unique_ptr previous; + std::unique_ptr current; - explicit Index_DoIdMap(std::unique_ptr current) + explicit Index_DoIdMap(std::unique_ptr current) : current(std::move(current)) {} - explicit Index_DoIdMap(std::unique_ptr previous, - std::unique_ptr current) + explicit Index_DoIdMap(std::unique_ptr previous, + std::unique_ptr current) : previous(std::move(previous)), current(std::move(current)) {} }; struct Index_OnIdMapped { - std::unique_ptr previous_index; - std::unique_ptr current_index; + std::unique_ptr previous_index; + std::unique_ptr current_index; std::unique_ptr previous_id_map; std::unique_ptr current_id_map; }; @@ -942,7 +942,7 @@ bool ImportCachedIndex(IndexerConfig* config, Timer time; - std::unique_ptr cache = LoadCachedIndex(config, tu_path); + std::unique_ptr cache = LoadCachedIndex(config, tu_path); time.ResetAndPrint("Reading cached index from disk " + tu_path); if (!cache) return true; @@ -952,7 +952,7 @@ bool ImportCachedIndex(IndexerConfig* config, // Import all dependencies. for (auto& dependency_path : cache->dependencies) { std::cerr << "- Got dependency " << dependency_path << std::endl; - std::unique_ptr cache = LoadCachedIndex(config, dependency_path); + std::unique_ptr cache = LoadCachedIndex(config, dependency_path); if (cache && GetLastModificationTime(cache->path) == cache->last_modification_time) file_consumer_shared->Mark(cache->path); else @@ -977,21 +977,21 @@ void ParseFile(IndexerConfig* config, const Project::Entry& entry) { Timer time; - std::unique_ptr cache_for_args = LoadCachedIndex(config, entry.filename); + std::unique_ptr cache_for_args = LoadCachedIndex(config, entry.filename); std::string tu_path = cache_for_args ? cache_for_args->import_file : entry.filename; const std::vector& tu_args = entry.args; - std::vector> indexes = Parse( + std::vector> indexes = Parse( config, file_consumer_shared, tu_path, tu_args); time.ResetAndPrint("Parsing/indexing " + tu_path); - for (std::unique_ptr& new_index : indexes) { + for (std::unique_ptr& new_index : indexes) { std::cerr << "Got index for " << new_index->path << std::endl; // Load the cached index. - std::unique_ptr cached_index; + std::unique_ptr cached_index; if (cache_for_args && new_index->path == cache_for_args->path) cached_index = std::move(cache_for_args); else @@ -1037,7 +1037,7 @@ bool ResetStaleFiles(IndexerConfig* config, const std::string& tu_path) { Timer time; - std::unique_ptr cache = LoadCachedIndex(config, tu_path); + std::unique_ptr cache = LoadCachedIndex(config, tu_path); time.ResetAndPrint("Reading cached index from disk " + tu_path); if (!cache) { std::cerr << "[indexer] Unable to load existing index from file when freshening (dependences will not be freshened)" << std::endl; @@ -1050,7 +1050,7 @@ bool ResetStaleFiles(IndexerConfig* config, // Check dependencies for (auto& dependency_path : cache->dependencies) { std::cerr << "- Got dependency " << dependency_path << std::endl; - std::unique_ptr cache = LoadCachedIndex(config, dependency_path); + std::unique_ptr cache = LoadCachedIndex(config, dependency_path); if (GetLastModificationTime(cache->path) != cache->last_modification_time) { needs_reparse = true; file_consumer_shared->Reset(cache->path); diff --git a/src/file_consumer.cc b/src/file_consumer.cc index a84038be..564e737a 100644 --- a/src/file_consumer.cc +++ b/src/file_consumer.cc @@ -32,7 +32,7 @@ void FileConsumer::SharedState::Reset(const std::string& file) { FileConsumer::FileConsumer(SharedState* shared_state) : shared_(shared_state) {} -IndexedFile* FileConsumer::TryConsumeFile(CXFile file, bool* is_first_ownership) { +IndexFile* FileConsumer::TryConsumeFile(CXFile file, bool* is_first_ownership) { assert(is_first_ownership); CXFileUniqueID file_id; @@ -53,16 +53,16 @@ IndexedFile* FileConsumer::TryConsumeFile(CXFile file, bool* is_first_ownership) // No result in local; we need to query global. bool did_insert = shared_->Mark(file_name); *is_first_ownership = did_insert; - local_[file_id] = did_insert ? MakeUnique(file_name) : nullptr; + local_[file_id] = did_insert ? MakeUnique(file_name) : nullptr; return local_[file_id].get(); } -IndexedFile* FileConsumer::ForceLocal(CXFile file) { +IndexFile* FileConsumer::ForceLocal(CXFile file) { // Try to fetch the file using the normal system, which will insert the file // usage into global storage. { bool is_first; - IndexedFile* cache = TryConsumeFile(file, &is_first); + IndexFile* cache = TryConsumeFile(file, &is_first); if (cache) return cache; } @@ -76,13 +76,13 @@ IndexedFile* FileConsumer::ForceLocal(CXFile file) { auto it = local_.find(file_id); if (it == local_.end() || !it->second) - local_[file_id] = MakeUnique(FileName(file)); + local_[file_id] = MakeUnique(FileName(file)); assert(local_.find(file_id) != local_.end()); return local_[file_id].get(); } -std::vector> FileConsumer::TakeLocalState() { - std::vector> result; +std::vector> FileConsumer::TakeLocalState() { + std::vector> result; for (auto& entry : local_) { if (entry.second) result.push_back(std::move(entry.second)); diff --git a/src/file_consumer.h b/src/file_consumer.h index 0aceb23f..9988d89c 100644 --- a/src/file_consumer.h +++ b/src/file_consumer.h @@ -9,7 +9,7 @@ #include #include -struct IndexedFile; +struct IndexFile; // Needed for unordered_map usage below. MAKE_HASHABLE(CXFileUniqueID, t.data[0], t.data[1], t.data[2]); @@ -38,18 +38,18 @@ struct FileConsumer { // Returns true if this instance owns given |file|. This will also attempt to // take ownership over |file|. // - // Returns IndexedFile for the file or nullptr. |is_first_ownership| is set + // Returns IndexFile for the file or nullptr. |is_first_ownership| is set // to true iff the function just took ownership over the file. Otherwise it // is set to false. - IndexedFile* TryConsumeFile(CXFile file, bool* is_first_ownership); + IndexFile* TryConsumeFile(CXFile file, bool* is_first_ownership); // Forcibly create a local file, even if it has already been parsed. - IndexedFile* ForceLocal(CXFile file); + IndexFile* ForceLocal(CXFile file); // Returns and passes ownership of all local state. - std::vector> TakeLocalState(); + std::vector> TakeLocalState(); private: - std::unordered_map> local_; + std::unordered_map> local_; SharedState* shared_; }; \ No newline at end of file diff --git a/src/indexer.cc b/src/indexer.cc index 14cadbfd..54e21ea0 100644 --- a/src/indexer.cc +++ b/src/indexer.cc @@ -48,79 +48,79 @@ Range ResolveExtent(const CXCursor& cx_cursor) { } // namespace -IndexedFile::IndexedFile(const std::string& path) : id_cache(path), path(path) { +IndexFile::IndexFile(const std::string& path) : id_cache(path), path(path) { // TODO: Reconsider if we should still be reusing the same id_cache. // Preallocate any existing resolved ids. for (const auto& entry : id_cache.usr_to_type_id) - types.push_back(IndexedTypeDef(entry.second, entry.first)); + types.push_back(IndexType(entry.second, entry.first)); for (const auto& entry : id_cache.usr_to_func_id) - funcs.push_back(IndexedFuncDef(entry.second, entry.first)); + funcs.push_back(IndexFunc(entry.second, entry.first)); for (const auto& entry : id_cache.usr_to_var_id) - vars.push_back(IndexedVarDef(entry.second, entry.first)); + vars.push_back(IndexVar(entry.second, entry.first)); } // TODO: Optimize for const char*? -IndexTypeId IndexedFile::ToTypeId(const std::string& usr) { +IndexTypeId IndexFile::ToTypeId(const std::string& usr) { auto it = id_cache.usr_to_type_id.find(usr); if (it != id_cache.usr_to_type_id.end()) return it->second; IndexTypeId id(types.size()); - types.push_back(IndexedTypeDef(id, usr)); + types.push_back(IndexType(id, usr)); id_cache.usr_to_type_id[usr] = id; id_cache.type_id_to_usr[id] = usr; return id; } -IndexFuncId IndexedFile::ToFuncId(const std::string& usr) { +IndexFuncId IndexFile::ToFuncId(const std::string& usr) { auto it = id_cache.usr_to_func_id.find(usr); if (it != id_cache.usr_to_func_id.end()) return it->second; IndexFuncId id(funcs.size()); - funcs.push_back(IndexedFuncDef(id, usr)); + funcs.push_back(IndexFunc(id, usr)); id_cache.usr_to_func_id[usr] = id; id_cache.func_id_to_usr[id] = usr; return id; } -IndexVarId IndexedFile::ToVarId(const std::string& usr) { +IndexVarId IndexFile::ToVarId(const std::string& usr) { auto it = id_cache.usr_to_var_id.find(usr); if (it != id_cache.usr_to_var_id.end()) return it->second; IndexVarId id(vars.size()); - vars.push_back(IndexedVarDef(id, usr)); + vars.push_back(IndexVar(id, usr)); id_cache.usr_to_var_id[usr] = id; id_cache.var_id_to_usr[id] = usr; return id; } -IndexTypeId IndexedFile::ToTypeId(const CXCursor& cursor) { +IndexTypeId IndexFile::ToTypeId(const CXCursor& cursor) { return ToTypeId(clang::Cursor(cursor).get_usr()); } -IndexFuncId IndexedFile::ToFuncId(const CXCursor& cursor) { +IndexFuncId IndexFile::ToFuncId(const CXCursor& cursor) { return ToFuncId(clang::Cursor(cursor).get_usr()); } -IndexVarId IndexedFile::ToVarId(const CXCursor& cursor) { +IndexVarId IndexFile::ToVarId(const CXCursor& cursor) { return ToVarId(clang::Cursor(cursor).get_usr()); } -IndexedTypeDef* IndexedFile::Resolve(IndexTypeId id) { +IndexType* IndexFile::Resolve(IndexTypeId id) { return &types[id.id]; } -IndexedFuncDef* IndexedFile::Resolve(IndexFuncId id) { +IndexFunc* IndexFile::Resolve(IndexFuncId id) { return &funcs[id.id]; } -IndexedVarDef* IndexedFile::Resolve(IndexVarId id) { +IndexVar* IndexFile::Resolve(IndexVarId id) { return &vars[id.id]; } -std::string IndexedFile::ToString() { +std::string IndexFile::ToString() { return Serialize(*this); } -IndexedTypeDef::IndexedTypeDef(IndexTypeId id, const std::string& usr) +IndexType::IndexType(IndexTypeId id, const std::string& usr) : def(usr), id(id) { assert(usr.size() > 0); // std::cerr << "Creating type with usr " << usr << std::endl; @@ -195,12 +195,12 @@ struct NamespaceHelper { struct IndexParam { // Only use this when strictly needed (ie, primary translation unit is - // needed). Most logic should get the IndexedFile instance via + // needed). Most logic should get the IndexFile instance via // |file_consumer|. // // This can be null if we're not generating an index for the primary // translation unit. - IndexedFile* primary_file; + IndexFile* primary_file; FileConsumer* file_consumer; NamespaceHelper ns; @@ -231,7 +231,7 @@ void diagnostic(CXClientData client_data, unsigned int line, column; clang_getSpellingLocation(diag_loc, &file, &line, &column, nullptr); bool is_first_time_visiting_file = false; - IndexedFile* db = param->file_consumer->TryConsumeFile(file, &is_first_time_visiting_file); + IndexFile* db = param->file_consumer->TryConsumeFile(file, &is_first_time_visiting_file); if (!db) continue; if (is_first_time_visiting_file && param->primary_file) @@ -380,18 +380,18 @@ bool IsTypeDefinition(const CXIdxContainerInfo* container) { } struct VisitDeclForTypeUsageParam { - IndexedFile* db; + IndexFile* db; int has_processed_any = false; optional previous_cursor; optional initial_type; - VisitDeclForTypeUsageParam(IndexedFile* db) : db(db) {} + VisitDeclForTypeUsageParam(IndexFile* db) : db(db) {} }; void VisitDeclForTypeUsageVisitorHandler(clang::Cursor cursor, VisitDeclForTypeUsageParam* param) { param->has_processed_any = true; - IndexedFile* db = param->db; + IndexFile* db = param->db; std::string referenced_usr = cursor.get_referenced() @@ -406,7 +406,7 @@ void VisitDeclForTypeUsageVisitorHandler(clang::Cursor cursor, if (!param->initial_type) param->initial_type = ref_type_id; - IndexedTypeDef* ref_type_def = db->Resolve(ref_type_id); + IndexType* ref_type_def = db->Resolve(ref_type_id); // TODO: Should we even be visiting this if the file is not from the main // def? Try adding assert on |loc| later. Range loc = ResolveSpelling(cursor.cx_cursor); @@ -451,8 +451,8 @@ clang::VisiterResult VisitDeclForTypeUsageVisitor( // strips // qualifies from |cursor| (ie, Foo* => Foo) and removes template arguments // (ie, Foo => Foo<*,*>). -optional ResolveToDeclarationType(IndexedFile* db, - clang::Cursor cursor) { +optional ResolveToDeclarationType(IndexFile* db, + clang::Cursor cursor) { clang::Cursor declaration = cursor.get_type().strip_qualifiers().get_declaration(); declaration = declaration.template_specialization_to_template_definition(); @@ -468,7 +468,7 @@ optional ResolveToDeclarationType(IndexedFile* db, // trying to generally resolve a cursor to a type, use // ResolveToDeclarationType, which works in more scenarios. optional AddDeclTypeUsages( - IndexedFile* db, + IndexFile* db, clang::Cursor decl_cursor, const CXIdxContainerInfo* semantic_container, const CXIdxContainerInfo* lexical_container) { @@ -604,7 +604,7 @@ optional AddDeclTypeUsages( // for template arguments. clang::VisiterResult AddDeclInitializerUsagesVisitor(clang::Cursor cursor, clang::Cursor parent, - IndexedFile* db) { + IndexFile* db) { /* We need to index the |DeclRefExpr| below (ie, |var| inside of Foo::var). @@ -650,7 +650,7 @@ clang::VisiterResult AddDeclInitializerUsagesVisitor(clang::Cursor cursor, // std::cerr << "Adding usage to id=" << ref_id.id << " usr=" << ref_usr // << " at " << loc.ToString() << std::endl; IndexVarId ref_id = db->ToVarId(ref_usr); - IndexedVarDef* ref_def = db->Resolve(ref_id); + IndexVar* ref_def = db->Resolve(ref_id); UniqueAdd(ref_def->uses, loc); break; } @@ -658,7 +658,7 @@ clang::VisiterResult AddDeclInitializerUsagesVisitor(clang::Cursor cursor, return clang::VisiterResult::Recurse; } -void AddDeclInitializerUsages(IndexedFile* db, clang::Cursor decl_cursor) { +void AddDeclInitializerUsages(IndexFile* db, clang::Cursor decl_cursor) { decl_cursor.VisitChildren(&AddDeclInitializerUsagesVisitor, db); } @@ -738,7 +738,7 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { clang_getSpellingLocation(clang_indexLoc_getCXSourceLocation(decl->loc), &file, nullptr, nullptr, nullptr); IndexParam* param = static_cast(client_data); bool is_first_time_visiting_file = false; - IndexedFile* db = param->file_consumer->TryConsumeFile(file, &is_first_time_visiting_file); + IndexFile* db = param->file_consumer->TryConsumeFile(file, &is_first_time_visiting_file); if (!db) return; @@ -773,7 +773,7 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { std::string decl_usr = decl_cursor.get_usr(); IndexVarId var_id = db->ToVarId(decl->entityInfo->USR); - IndexedVarDef* var_def = db->Resolve(var_id); + IndexVar* var_def = db->Resolve(var_id); // TODO: Eventually run with this if. Right now I want to iron out bugs // this may shadow. @@ -827,7 +827,7 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { if (decl->isDefinition && IsTypeDefinition(decl->semanticContainer)) { IndexTypeId declaring_type_id = db->ToTypeId(decl->semanticContainer->cursor); - IndexedTypeDef* declaring_type_def = db->Resolve(declaring_type_id); + IndexType* declaring_type_def = db->Resolve(declaring_type_id); var_def->def.declaring_type = declaring_type_id; declaring_type_def->def.vars.push_back(var_id); } @@ -848,7 +848,7 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { decl_cursor.template_specialization_to_template_definition(); IndexFuncId func_id = db->ToFuncId(resolved.cx_cursor); - IndexedFuncDef* func_def = db->Resolve(func_id); + IndexFunc* func_def = db->Resolve(func_id); // We don't actually need to know the return type, but we need to mark it // as an interesting usage. @@ -908,7 +908,7 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { if (IsTypeDefinition(decl->semanticContainer)) { IndexTypeId declaring_type_id = db->ToTypeId(decl->semanticContainer->cursor); - IndexedTypeDef* declaring_type_def = db->Resolve(declaring_type_id); + IndexType* declaring_type_def = db->Resolve(declaring_type_id); func_def->def.declaring_type = declaring_type_id; // Mark a type reference at the ctor/dtor location. @@ -972,7 +972,7 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { for (unsigned int i = 0; i < num_overridden; ++i) { clang::Cursor parent = overridden[i]; IndexFuncId parent_id = db->ToFuncId(parent.get_usr()); - IndexedFuncDef* parent_def = db->Resolve(parent_id); + IndexFunc* parent_def = db->Resolve(parent_id); func_def = db->Resolve(func_id); // ToFuncId invalidated func_def func_def->def.base = parent_id; @@ -1007,7 +1007,7 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { decl->semanticContainer, decl->lexicalContainer); IndexTypeId type_id = db->ToTypeId(decl->entityInfo->USR); - IndexedTypeDef* type_def = db->Resolve(type_id); + IndexType* type_def = db->Resolve(type_id); if (alias_of) type_def->def.alias_of = alias_of.value(); @@ -1029,7 +1029,7 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { Range decl_loc_spelling = ResolveSpelling(decl->cursor); IndexTypeId type_id = db->ToTypeId(decl->entityInfo->USR); - IndexedTypeDef* type_def = db->Resolve(type_id); + IndexType* type_def = db->Resolve(type_id); // TODO: Eventually run with this if. Right now I want to iron out bugs // this may shadow. @@ -1075,9 +1075,9 @@ void indexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) { optional parent_type_id = ResolveToDeclarationType(db, base_class->cursor); // type_def ptr could be invalidated by ResolveToDeclarationType. - IndexedTypeDef* type_def = db->Resolve(type_id); + IndexType* type_def = db->Resolve(type_id); if (parent_type_id) { - IndexedTypeDef* parent_type_def = + IndexType* parent_type_def = db->Resolve(parent_type_id.value()); parent_type_def->derived.push_back(type_id); type_def->def.parents.push_back(parent_type_id.value()); @@ -1196,7 +1196,7 @@ void indexEntityReference(CXClientData client_data, clang_getSpellingLocation(clang_indexLoc_getCXSourceLocation(ref->loc), &file, nullptr, nullptr, nullptr); IndexParam* param = static_cast(client_data); bool is_first_time_visiting_file = false; - IndexedFile* db = param->file_consumer->TryConsumeFile(file, &is_first_time_visiting_file); + IndexFile* db = param->file_consumer->TryConsumeFile(file, &is_first_time_visiting_file); if (!db) return; @@ -1207,7 +1207,7 @@ void indexEntityReference(CXClientData client_data, // ref->loc mainFile=1 // ref->referencedEntity mainFile=1 // - // Regardless, we need to do more advanced location processing to handle multiple output IndexedFile instances. + // Regardless, we need to do more advanced location processing to handle multiple output IndexFile instances. //bool mainFile = clang_Location_isFromMainFile(clang_indexLoc_getCXSourceLocation(ref->loc)); //Range loc_spelling = param->db->id_cache.ForceResolveSpelling(ref->cursor, false /*interesting*/); //std::cerr << "mainFile: " << mainFile << ", loc: " << loc_spelling.ToString() << std::endl; @@ -1240,7 +1240,7 @@ void indexEntityReference(CXClientData client_data, referenced = referenced.template_specialization_to_template_definition(); IndexVarId var_id = db->ToVarId(referenced.get_usr()); - IndexedVarDef* var_def = db->Resolve(var_id); + IndexVar* var_def = db->Resolve(var_id); UniqueAdd(var_def->uses, loc_spelling); break; } @@ -1267,13 +1267,13 @@ void indexEntityReference(CXClientData client_data, IndexFuncId called_id = db->ToFuncId(ref->referencedEntity->USR); if (IsFunctionCallContext(ref->container->cursor.kind)) { IndexFuncId caller_id = db->ToFuncId(ref->container->cursor); - IndexedFuncDef* caller_def = db->Resolve(caller_id); - IndexedFuncDef* called_def = db->Resolve(called_id); + IndexFunc* caller_def = db->Resolve(caller_id); + IndexFunc* called_def = db->Resolve(called_id); AddFuncRef(&caller_def->def.callees, IndexFuncRef(called_id, loc_spelling)); AddFuncRef(&called_def->callers, IndexFuncRef(caller_id, loc_spelling)); } else { - IndexedFuncDef* called_def = db->Resolve(called_id); + IndexFunc* called_def = db->Resolve(called_id); AddFuncRef(&called_def->callers, IndexFuncRef(loc_spelling)); } @@ -1292,7 +1292,7 @@ void indexEntityReference(CXClientData client_data, referenced = referenced.template_specialization_to_template_definition(); IndexTypeId referenced_id = db->ToTypeId(referenced.get_usr()); - IndexedTypeDef* referenced_def = db->Resolve(referenced_id); + IndexType* referenced_def = db->Resolve(referenced_id); // // The following will generate two TypeRefs to Foo, both located at the @@ -1376,7 +1376,7 @@ void indexEntityReference(CXClientData client_data, -std::vector> Parse( +std::vector> Parse( IndexerConfig* config, FileConsumer::SharedState* file_consumer_shared, std::string file, std::vector args, diff --git a/src/indexer.h b/src/indexer.h index 7441cb78..e8f5c10d 100644 --- a/src/indexer.h +++ b/src/indexer.h @@ -21,9 +21,9 @@ #include #include -struct IndexedTypeDef; -struct IndexedFuncDef; -struct IndexedVarDef; +struct IndexType; +struct IndexFunc; +struct IndexVar; using namespace std::experimental; @@ -59,9 +59,9 @@ bool operator!=(const Id& a, const Id& b) { return !(a == b); } -using IndexTypeId = Id; -using IndexFuncId = Id; -using IndexVarId = Id; +using IndexTypeId = Id; +using IndexFuncId = Id; +using IndexVarId = Id; struct IdCache; @@ -103,7 +103,7 @@ bool operator!=(const Ref& a, const Ref& b) { return !(a == b); } -using IndexFuncRef = Ref; +using IndexFuncRef = Ref; // TODO: skip as much forward-processing as possible when |is_system_def| is // set to false. @@ -196,7 +196,7 @@ void Reflect(TVisitor& visitor, REFLECT_MEMBER_END(); } -struct IndexedTypeDef { +struct IndexType { using Def = TypeDefDefinitionData; Def def; @@ -212,9 +212,9 @@ struct IndexedTypeDef { // NOTE: Do not insert directly! Use AddUsage instead. std::vector uses; - IndexedTypeDef() : def("") {} // For serialization + IndexType() : def("") {} // For serialization - IndexedTypeDef(IndexTypeId id, const std::string& usr); + IndexType(IndexTypeId id, const std::string& usr); bool HasInterestingState() const { return @@ -224,12 +224,12 @@ struct IndexedTypeDef { !uses.empty(); } - bool operator<(const IndexedTypeDef& other) const { + bool operator<(const IndexType& other) const { return def.usr < other.def.usr; } }; -MAKE_HASHABLE(IndexedTypeDef, t.def.usr); +MAKE_HASHABLE(IndexType, t.def.usr); template ; Def def; @@ -330,8 +330,8 @@ struct IndexedFuncDef { // def.definition_spelling. std::vector callers; - IndexedFuncDef() {} // For reflection. - IndexedFuncDef(IndexFuncId id, const std::string& usr) : def(usr), id(id) { + IndexFunc() {} // For reflection. + IndexFunc(IndexFuncId id, const std::string& usr) : def(usr), id(id) { // assert(usr.size() > 0); } @@ -344,11 +344,11 @@ struct IndexedFuncDef { !callers.empty(); } - bool operator<(const IndexedFuncDef& other) const { + bool operator<(const IndexFunc& other) const { return def.usr < other.def.usr; } }; -MAKE_HASHABLE(IndexedFuncDef, t.def.usr); +MAKE_HASHABLE(IndexFunc, t.def.usr); template ; Def def; @@ -427,9 +427,9 @@ struct IndexedVarDef { // Usages. std::vector uses; - IndexedVarDef() : def("") {} // For serialization + IndexVar() : def("") {} // For serialization - IndexedVarDef(IndexVarId id, const std::string& usr) : def(usr), id(id) { + IndexVar(IndexVarId id, const std::string& usr) : def(usr), id(id) { // assert(usr.size() > 0); } @@ -439,11 +439,11 @@ struct IndexedVarDef { !uses.empty(); } - bool operator<(const IndexedVarDef& other) const { + bool operator<(const IndexVar& other) const { return def.usr < other.def.usr; } }; -MAKE_HASHABLE(IndexedVarDef, t.def.usr); +MAKE_HASHABLE(IndexVar, t.def.usr); struct IdCache { std::string primary_file; @@ -457,7 +457,7 @@ struct IdCache { IdCache(const std::string& primary_file); }; -struct IndexedFile { +struct IndexFile { IdCache id_cache; static constexpr int kCurrentVersion = 2; @@ -468,7 +468,7 @@ struct IndexedFile { int64_t last_modification_time = 0; // The path to the translation unit cc file which caused the creation of this - // IndexedFile. When parsing a translation unit we generate many IndexedFile + // IndexFile. When parsing a translation unit we generate many IndexFile // instances (ie, each header has a separate one). When the user edits a // header we need to lookup the original translation unit and reindex that. std::string import_file; @@ -480,11 +480,11 @@ struct IndexedFile { NonElidedVector diagnostics; std::vector dependencies; - std::vector types; - std::vector funcs; - std::vector vars; + std::vector types; + std::vector funcs; + std::vector vars; - IndexedFile(const std::string& path); + IndexFile(const std::string& path); IndexTypeId ToTypeId(const std::string& usr); IndexFuncId ToFuncId(const std::string& usr); @@ -492,9 +492,9 @@ struct IndexedFile { IndexTypeId ToTypeId(const CXCursor& usr); IndexFuncId ToFuncId(const CXCursor& usr); IndexVarId ToVarId(const CXCursor& usr); - IndexedTypeDef* Resolve(IndexTypeId id); - IndexedFuncDef* Resolve(IndexFuncId id); - IndexedVarDef* Resolve(IndexVarId id); + IndexType* Resolve(IndexTypeId id); + IndexFunc* Resolve(IndexFuncId id); + IndexVar* Resolve(IndexVarId id); std::string ToString(); }; @@ -502,7 +502,7 @@ struct IndexedFile { // |import_file| is the cc file which is what gets passed to clang. // |desired_index_file| is the (h or cc) file which has actually changed. // |dependencies| are the existing dependencies of |import_file| if this is a reparse. -std::vector> Parse( +std::vector> Parse( IndexerConfig* config, FileConsumer::SharedState* file_consumer_shared, std::string file, std::vector args, diff --git a/src/query.cc b/src/query.cc index 00dfe2fc..6cffb866 100644 --- a/src/query.cc +++ b/src/query.cc @@ -17,7 +17,7 @@ namespace { -QueryType::DefUpdate ToQuery(const IdMap& id_map, const IndexedTypeDef::Def& type) { +QueryType::DefUpdate ToQuery(const IdMap& id_map, const IndexType::Def& type) { QueryType::DefUpdate result(type.usr); result.short_name = type.short_name; result.detailed_name = type.detailed_name; @@ -31,7 +31,7 @@ QueryType::DefUpdate ToQuery(const IdMap& id_map, const IndexedTypeDef::Def& typ return result; } -QueryFunc::DefUpdate ToQuery(const IdMap& id_map, const IndexedFuncDef::Def& func) { +QueryFunc::DefUpdate ToQuery(const IdMap& id_map, const IndexFunc::Def& func) { QueryFunc::DefUpdate result(func.usr); result.short_name = func.short_name; result.detailed_name = func.detailed_name; @@ -44,7 +44,7 @@ QueryFunc::DefUpdate ToQuery(const IdMap& id_map, const IndexedFuncDef::Def& fun return result; } -QueryVar::DefUpdate ToQuery(const IdMap& id_map, const IndexedVarDef::Def& var) { +QueryVar::DefUpdate ToQuery(const IdMap& id_map, const IndexVar::Def& var) { QueryVar::DefUpdate result(var.usr); result.short_name = var.short_name; result.detailed_name = var.detailed_name; @@ -159,7 +159,7 @@ void CompareGroups( } } -QueryFile::Def BuildFileDef(const IdMap& id_map, const IndexedFile& indexed) { +QueryFile::Def BuildFileDef(const IdMap& id_map, const IndexFile& indexed) { QueryFile::Def def; def.path = indexed.path; @@ -170,33 +170,33 @@ QueryFile::Def BuildFileDef(const IdMap& id_map, const IndexedFile& indexed) { def.all_symbols.push_back(SymbolRef(idx, id_map.ToQuery(range))); }; - for (const IndexedTypeDef& def : indexed.types) { - if (def.def.definition_spelling.has_value()) - add_all_symbols(id_map.ToSymbol(def.id), def.def.definition_spelling.value()); - if (def.def.definition_extent.has_value()) - add_outline(id_map.ToSymbol(def.id), def.def.definition_extent.value()); - for (const Range& use : def.uses) - add_all_symbols(id_map.ToSymbol(def.id), use); + for (const IndexType& type : indexed.types) { + if (type.def.definition_spelling.has_value()) + add_all_symbols(id_map.ToSymbol(type.id), type.def.definition_spelling.value()); + if (type.def.definition_extent.has_value()) + add_outline(id_map.ToSymbol(type.id), type.def.definition_extent.value()); + for (const Range& use : type.uses) + add_all_symbols(id_map.ToSymbol(type.id), use); } - for (const IndexedFuncDef& def : indexed.funcs) { - if (def.def.definition_spelling.has_value()) - add_all_symbols(id_map.ToSymbol(def.id), def.def.definition_spelling.value()); - if (def.def.definition_extent.has_value()) - add_outline(id_map.ToSymbol(def.id), def.def.definition_extent.value()); - for (Range decl : def.declarations) { - add_all_symbols(id_map.ToSymbol(def.id), decl); - add_outline(id_map.ToSymbol(def.id), decl); + for (const IndexFunc& func : indexed.funcs) { + if (func.def.definition_spelling.has_value()) + add_all_symbols(id_map.ToSymbol(func.id), func.def.definition_spelling.value()); + if (func.def.definition_extent.has_value()) + add_outline(id_map.ToSymbol(func.id), func.def.definition_extent.value()); + for (Range decl : func.declarations) { + add_all_symbols(id_map.ToSymbol(func.id), decl); + add_outline(id_map.ToSymbol(func.id), decl); } - for (const IndexFuncRef& caller : def.callers) - add_all_symbols(id_map.ToSymbol(def.id), caller.loc); + for (const IndexFuncRef& caller : func.callers) + add_all_symbols(id_map.ToSymbol(func.id), caller.loc); } - for (const IndexedVarDef& def : indexed.vars) { - if (def.def.definition_spelling.has_value()) - add_all_symbols(id_map.ToSymbol(def.id), def.def.definition_spelling.value()); - if (def.def.definition_extent.has_value()) - add_outline(id_map.ToSymbol(def.id), def.def.definition_extent.value()); - for (const Range& use : def.uses) - add_all_symbols(id_map.ToSymbol(def.id), use); + for (const IndexVar& var : indexed.vars) { + if (var.def.definition_spelling.has_value()) + add_all_symbols(id_map.ToSymbol(var.id), var.def.definition_spelling.value()); + if (var.def.definition_extent.has_value()) + add_outline(id_map.ToSymbol(var.id), var.def.definition_extent.value()); + for (const Range& use : var.uses) + add_all_symbols(id_map.ToSymbol(var.id), use); } std::sort(def.outline.begin(), def.outline.end(), [](const SymbolRef& a, const SymbolRef& b) { @@ -409,18 +409,18 @@ SymbolIdx IdMap::ToSymbol(IndexVarId id) const { // ---------------------- // static -IndexUpdate IndexUpdate::CreateDelta(const IdMap* previous_id_map, const IdMap* current_id_map, IndexedFile* previous, IndexedFile* current) { +IndexUpdate IndexUpdate::CreateDelta(const IdMap* previous_id_map, const IdMap* current_id_map, IndexFile* previous, IndexFile* current) { // This function runs on an indexer thread. if (!previous_id_map) { assert(!previous); - IndexedFile previous(current->path); + IndexFile previous(current->path); return IndexUpdate(*current_id_map, *current_id_map, previous, *current); } return IndexUpdate(*previous_id_map, *current_id_map, *previous, *current); } -IndexUpdate::IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_map, IndexedFile& previous_file, IndexedFile& current_file) { +IndexUpdate::IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_map, IndexFile& previous_file, IndexFile& current_file) { // This function runs on an indexer thread. // |query_name| is the name of the variable on the query type. @@ -444,11 +444,11 @@ IndexUpdate::IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_m files_def_update.push_back(BuildFileDef(current_id_map, current_file)); // Types - CompareGroups(previous_file.types, current_file.types, - /*onRemoved:*/[this](IndexedTypeDef* def) { + CompareGroups(previous_file.types, current_file.types, + /*onRemoved:*/[this](IndexType* def) { types_removed.push_back(def->def.usr); }, - /*onAdded:*/[this, ¤t_id_map](IndexedTypeDef* type) { + /*onAdded:*/[this, ¤t_id_map](IndexType* type) { if (!type->def.detailed_name.empty()) types_def_update.push_back(ToQuery(current_id_map, type->def)); if (!type->derived.empty()) @@ -458,7 +458,7 @@ IndexUpdate::IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_m if (!type->uses.empty()) types_uses.push_back(QueryType::UsesUpdate(current_id_map.ToQuery(type->id), current_id_map.ToQuery(type->uses))); }, - /*onFound:*/[this, &previous_id_map, ¤t_id_map](IndexedTypeDef* previous_def, IndexedTypeDef* current_def) { + /*onFound:*/[this, &previous_id_map, ¤t_id_map](IndexType* previous_def, IndexType* current_def) { optional previous_remapped_def = ToQuery(previous_id_map, previous_def->def); optional current_remapped_def = ToQuery(current_id_map, current_def->def); if (current_remapped_def && previous_remapped_def != current_remapped_def && !current_remapped_def->detailed_name.empty()) @@ -470,11 +470,11 @@ IndexUpdate::IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_m }); // Functions - CompareGroups(previous_file.funcs, current_file.funcs, - /*onRemoved:*/[this](IndexedFuncDef* def) { + CompareGroups(previous_file.funcs, current_file.funcs, + /*onRemoved:*/[this](IndexFunc* def) { funcs_removed.push_back(def->def.usr); }, - /*onAdded:*/[this, ¤t_id_map](IndexedFuncDef* func) { + /*onAdded:*/[this, ¤t_id_map](IndexFunc* func) { if (!func->def.detailed_name.empty()) funcs_def_update.push_back(ToQuery(current_id_map, func->def)); if (!func->declarations.empty()) @@ -484,7 +484,7 @@ IndexUpdate::IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_m if (!func->callers.empty()) funcs_callers.push_back(QueryFunc::CallersUpdate(current_id_map.ToQuery(func->id), current_id_map.ToQuery(func->callers))); }, - /*onFound:*/[this, &previous_id_map, ¤t_id_map](IndexedFuncDef* previous_def, IndexedFuncDef* current_def) { + /*onFound:*/[this, &previous_id_map, ¤t_id_map](IndexFunc* previous_def, IndexFunc* current_def) { optional previous_remapped_def = ToQuery(previous_id_map, previous_def->def); optional current_remapped_def = ToQuery(current_id_map, current_def->def); if (current_remapped_def && previous_remapped_def != current_remapped_def && !current_remapped_def->detailed_name.empty()) @@ -496,17 +496,17 @@ IndexUpdate::IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_m }); // Variables - CompareGroups(previous_file.vars, current_file.vars, - /*onRemoved:*/[this](IndexedVarDef* def) { + CompareGroups(previous_file.vars, current_file.vars, + /*onRemoved:*/[this](IndexVar* def) { vars_removed.push_back(def->def.usr); }, - /*onAdded:*/[this, ¤t_id_map](IndexedVarDef* var) { + /*onAdded:*/[this, ¤t_id_map](IndexVar* var) { if (!var->def.detailed_name.empty()) vars_def_update.push_back(ToQuery(current_id_map, var->def)); if (!var->uses.empty()) vars_uses.push_back(QueryVar::UsesUpdate(current_id_map.ToQuery(var->id), current_id_map.ToQuery(var->uses))); }, - /*onFound:*/[this, &previous_id_map, ¤t_id_map](IndexedVarDef* previous_def, IndexedVarDef* current_def) { + /*onFound:*/[this, &previous_id_map, ¤t_id_map](IndexVar* previous_def, IndexVar* current_def) { optional previous_remapped_def = ToQuery(previous_id_map, previous_def->def); optional current_remapped_def = ToQuery(current_id_map, current_def->def); if (current_remapped_def && previous_remapped_def != current_remapped_def && !current_remapped_def->detailed_name.empty()) @@ -754,3 +754,18 @@ void QueryDatabase::UpdateDetailedNames(size_t* qualified_name_index, SymbolKind detailed_names[*qualified_name_index] = name; } } + +#if false +void DoTest() { + IndexFile previous("foo.cc"); + IndexFile current("foo.cc"); + QueryDatabase db; + + IndexFunc* func = previous.Resolve(previous.ToFuncId("usr")); + + + IdMap previous_map(&db, previous.id_cache); + IdMap current_map(&db, current.id_cache); + IndexUpdate::CreateDelta(&previous_map, ¤t_map, &previous, ¤t); +} +#endif \ No newline at end of file diff --git a/src/query.h b/src/query.h index b18f85fc..e9d3f97d 100644 --- a/src/query.h +++ b/src/query.h @@ -205,7 +205,7 @@ struct QueryVar { struct IndexUpdate { // Creates a new IndexUpdate based on the delta from previous to current. If // no delta computation should be done just pass null for previous. - static IndexUpdate CreateDelta(const IdMap* previous_id_map, const IdMap* current_id_map, IndexedFile* previous, IndexedFile* current); + static IndexUpdate CreateDelta(const IdMap* previous_id_map, const IdMap* current_id_map, IndexFile* previous, IndexFile* current); // Merge |update| into this update; this can reduce overhead / index update // work can be parallelized. @@ -238,7 +238,7 @@ struct IndexUpdate { // Creates an index update assuming that |previous| is already // in the index, so only the delta between |previous| and |current| // will be applied. - IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_map, IndexedFile& previous, IndexedFile& current); + IndexUpdate(const IdMap& previous_id_map, const IdMap& current_id_map, IndexFile& previous, IndexFile& current); }; diff --git a/src/serializer.cc b/src/serializer.cc index e3f8c303..48cae64d 100644 --- a/src/serializer.cc +++ b/src/serializer.cc @@ -75,16 +75,16 @@ void Reflect(Writer& visitor, Id& value) { } -// Ref -void Reflect(Reader& visitor, Ref& value) { +// Ref +void Reflect(Reader& visitor, Ref& value) { const char* str_value = visitor.GetString(); uint64_t id = atol(str_value); const char* loc_string = strchr(str_value, '@') + 1; - value.id_ = Id(id); + value.id_ = Id(id); value.loc = Range(loc_string); } -void Reflect(Writer& visitor, Ref& value) { +void Reflect(Writer& visitor, Ref& value) { if (value.id_.id == -1) { std::string s = "-1@" + value.loc.ToString(); visitor.String(s.c_str()); @@ -105,12 +105,12 @@ void Reflect(Writer& visitor, Ref& value) { // TODO: Rename indexer.cpp to indexer.cc // TODO: Do not serialize a USR if it has no usages/etc outside of USR info. -// IndexedTypeDef -bool ReflectMemberStart(Reader& reader, IndexedTypeDef& value) { +// IndexType +bool ReflectMemberStart(Reader& reader, IndexType& value) { //value.is_bad_def = false; return true; } -bool ReflectMemberStart(Writer& writer, IndexedTypeDef& value) { +bool ReflectMemberStart(Writer& writer, IndexType& value) { // TODO: this is crashing // if (!value.HasInterestingState()) // std::cerr << "bad"; @@ -122,7 +122,7 @@ bool ReflectMemberStart(Writer& writer, IndexedTypeDef& value) { return true; } template -void Reflect(TVisitor& visitor, IndexedTypeDef& value) { +void Reflect(TVisitor& visitor, IndexType& value) { REFLECT_MEMBER_START(); REFLECT_MEMBER2("id", value.id); REFLECT_MEMBER2("usr", value.def.usr); @@ -142,12 +142,12 @@ void Reflect(TVisitor& visitor, IndexedTypeDef& value) { } -// IndexedFuncDef -bool ReflectMemberStart(Reader& reader, IndexedFuncDef& value) { +// IndexFunc +bool ReflectMemberStart(Reader& reader, IndexFunc& value) { //value.is_bad_def = false; return true; } -bool ReflectMemberStart(Writer& writer, IndexedFuncDef& value) { +bool ReflectMemberStart(Writer& writer, IndexFunc& value) { // TODO: this is crashing // if (!value.HasInterestingState()) // std::cerr << "bad"; @@ -159,7 +159,7 @@ bool ReflectMemberStart(Writer& writer, IndexedFuncDef& value) { return true; } template -void Reflect(TVisitor& visitor, IndexedFuncDef& value) { +void Reflect(TVisitor& visitor, IndexFunc& value) { REFLECT_MEMBER_START(); REFLECT_MEMBER2("id", value.id); REFLECT_MEMBER2("usr", value.def.usr); @@ -178,12 +178,12 @@ void Reflect(TVisitor& visitor, IndexedFuncDef& value) { } -// IndexedVarDef -bool ReflectMemberStart(Reader& reader, IndexedVarDef& value) { +// IndexVar +bool ReflectMemberStart(Reader& reader, IndexVar& value) { //value.is_bad_def = false; return true; } -bool ReflectMemberStart(Writer& writer, IndexedVarDef& value) { +bool ReflectMemberStart(Writer& writer, IndexVar& value) { // TODO: this is crashing // if (!value.HasInterestingState()) // std::cerr << "bad"; @@ -195,7 +195,7 @@ bool ReflectMemberStart(Writer& writer, IndexedVarDef& value) { return true; } template -void Reflect(TVisitor& visitor, IndexedVarDef& value) { +void Reflect(TVisitor& visitor, IndexVar& value) { REFLECT_MEMBER_START(); REFLECT_MEMBER2("id", value.id); REFLECT_MEMBER2("usr", value.def.usr); @@ -211,20 +211,20 @@ void Reflect(TVisitor& visitor, IndexedVarDef& value) { } -// IndexedFile -bool ReflectMemberStart(Writer& visitor, IndexedFile& value) { +// IndexFile +bool ReflectMemberStart(Writer& visitor, IndexFile& value) { auto it = value.id_cache.usr_to_type_id.find(""); if (it != value.id_cache.usr_to_type_id.end()) { value.Resolve(it->second)->def.short_name = ""; assert(value.Resolve(it->second)->uses.size() == 0); } - value.version = IndexedFile::kCurrentVersion; + value.version = IndexFile::kCurrentVersion; DefaultReflectMemberStart(visitor); return true; } template -void Reflect(TVisitor& visitor, IndexedFile& value) { +void Reflect(TVisitor& visitor, IndexFile& value) { REFLECT_MEMBER_START(); if (!gTestOutputMode) { REFLECT_MEMBER(version); @@ -246,7 +246,7 @@ void Reflect(TVisitor& visitor, IndexedFile& value) { -std::string Serialize(IndexedFile& file) { +std::string Serialize(IndexFile& file) { rapidjson::StringBuffer output; rapidjson::PrettyWriter writer(output); //Writer writer(output); @@ -259,13 +259,13 @@ std::string Serialize(IndexedFile& file) { return output.GetString(); } -optional Deserialize(std::string path, std::string serialized) { +optional Deserialize(std::string path, std::string serialized) { rapidjson::Document reader; reader.Parse(serialized.c_str()); if (reader.HasParseError()) return nullopt; - IndexedFile file(path); + IndexFile file(path); Reflect(reader, file); // Restore non-serialized state. diff --git a/src/serializer.h b/src/serializer.h index 128d0cd4..9455a1ca 100644 --- a/src/serializer.h +++ b/src/serializer.h @@ -14,7 +14,7 @@ using std::experimental::nullopt; using Reader = rapidjson::GenericValue>; using Writer = rapidjson::Writer; -struct IndexedFile; +struct IndexFile; #define REFLECT_MEMBER_START() \ if (!ReflectMemberStart(visitor, value)) return @@ -206,7 +206,7 @@ void ReflectMember(Reader& visitor, const char* name, T& value) { } } -std::string Serialize(IndexedFile& file); -optional Deserialize(std::string path, std::string serialized); +std::string Serialize(IndexFile& file); +optional Deserialize(std::string path, std::string serialized); void SetTestOutputMode(); \ No newline at end of file diff --git a/src/test.cc b/src/test.cc index 32b4d8f5..be8329a4 100644 --- a/src/test.cc +++ b/src/test.cc @@ -82,7 +82,7 @@ void DiffDocuments(std::string path, std::string path_section, rapidjson::Docume } } -void VerifySerializeToFrom(IndexedFile* file) { +void VerifySerializeToFrom(IndexFile* file) { std::string expected = file->ToString(); std::string actual = Deserialize("--.cc", Serialize(*file)).value().ToString(); if (expected != actual) { @@ -103,7 +103,7 @@ std::string FindExpectedOutputForFilename(std::string filename, const std::unord return "{}"; } -IndexedFile* FindDbForPathEnding(const std::string& path, const std::vector>& dbs) { +IndexFile* FindDbForPathEnding(const std::string& path, const std::vector>& dbs) { for (auto& db : dbs) { if (EndsWith(db->path, path)) return db.get(); @@ -137,7 +137,7 @@ void RunTests() { // Run test. std::cout << "[START] " << path << std::endl; - std::vector> dbs = Parse( + std::vector> dbs = Parse( &config, &file_consumer_shared, path, { @@ -184,7 +184,7 @@ void RunTests() { const std::string& expected_output = entry.second; // Get output from index operation. - IndexedFile* db = FindDbForPathEnding(expected_path, dbs); + IndexFile* db = FindDbForPathEnding(expected_path, dbs); std::string actual_output = "{}"; if (db) { VerifySerializeToFrom(db); @@ -227,6 +227,5 @@ void RunTests() { } // TODO: ctor/dtor, copy ctor -// TODO: Always pass IndexedFile by pointer, ie, search and remove all IndexedFile& refs. -// TODO: Rename IndexedFile to IndexFile +// TODO: Always pass IndexFile by pointer, ie, search and remove all IndexFile& refs.