header-checker: Rename to IRReader

This commit renames `TextFormatToIRReader` to `IRReader`,
`ProtobufTextFormatToIRReader` to `ProtobufIRReader`, and
`JsonToIRReader` to `JsonIRReader`.

Test: ./tests/test.py
Test: ${ANDROID_HOST_OUT}/nativetest64/\
      header-checker-unittests/header-checker-unittests
Change-Id: I42e51eca31f6949f9e74b2e1c711075de22220fe

10 files changed, 175 insertions, 200 deletions

diff --git a/vndk/tools/header-checker/src/diff/abi_diff.cpp b/vndk/tools/header-checker/src/diff/abi_diff.cpp
index b67ca24a5..38110229f 100644
--- a/vndk/tools/header-checker/src/diff/abi_diff.cpp
+++ b/vndk/tools/header-checker/src/diff/abi_diff.cpp
@@ -30,11 +30,10 @@ namespace diff {
 
 
 repr::CompatibilityStatusIR HeaderAbiDiff::GenerateCompatibilityReport() {
-  using repr::TextFormatToIRReader;
-  std::unique_ptr<repr::TextFormatToIRReader> old_reader =
-      TextFormatToIRReader::CreateTextFormatToIRReader(text_format_old_);
-  std::unique_ptr<repr::TextFormatToIRReader> new_reader =
-      TextFormatToIRReader::CreateTextFormatToIRReader(text_format_new_);
+  std::unique_ptr<repr::IRReader> old_reader =
+      repr::IRReader::CreateIRReader(text_format_old_);
+  std::unique_ptr<repr::IRReader> new_reader =
+      repr::IRReader::CreateIRReader(text_format_new_);
   if (!old_reader || !new_reader || !old_reader->ReadDump(old_dump_) ||
       !new_reader->ReadDump(new_dump_)) {
     llvm::errs() << "Could not create Text Format readers\n";
@@ -52,8 +51,7 @@ repr::CompatibilityStatusIR HeaderAbiDiff::GenerateCompatibilityReport() {
 }
 
 repr::CompatibilityStatusIR HeaderAbiDiff::CompareTUs(
-    const repr::TextFormatToIRReader *old_tu,
-    const repr::TextFormatToIRReader *new_tu,
+    const repr::IRReader *old_tu, const repr::IRReader *new_tu,
     repr::IRDiffDumper *ir_diff_dumper) {
   // Collect all old and new types in maps, so that we can refer to them by
   // type name / linker_set_key later.
@@ -97,8 +95,7 @@ repr::CompatibilityStatusIR HeaderAbiDiff::CompareTUs(
 
 std::pair<AbiElementMap<const repr::EnumTypeIR *>,
           AbiElementMap<const repr::RecordTypeIR *>>
-HeaderAbiDiff::ExtractUserDefinedTypes(
-    const repr::TextFormatToIRReader *tu) {
+HeaderAbiDiff::ExtractUserDefinedTypes(const repr::IRReader *tu) {
   AbiElementMap<const repr::EnumTypeIR *> enum_types;
   AbiElementMap<const repr::RecordTypeIR *> record_types;
   // Iterate through the ODRListMap, if there is more than 1 element in the
@@ -136,8 +133,7 @@ HeaderAbiDiff::ExtractUserDefinedTypes(
 }
 
 bool HeaderAbiDiff::CollectUserDefinedTypes(
-    const repr::TextFormatToIRReader *old_tu,
-    const repr::TextFormatToIRReader *new_tu,
+    const repr::IRReader *old_tu, const repr::IRReader *new_tu,
     const AbiElementMap<const repr::TypeIR *> &old_types_map,
     const AbiElementMap<const repr::TypeIR *> &new_types_map,
     repr::IRDiffDumper *ir_diff_dumper) {
diff --git a/vndk/tools/header-checker/src/diff/abi_diff.h b/vndk/tools/header-checker/src/diff/abi_diff.h
index 83d691828..05298f689 100644
--- a/vndk/tools/header-checker/src/diff/abi_diff.h
+++ b/vndk/tools/header-checker/src/diff/abi_diff.h
@@ -52,8 +52,8 @@ class HeaderAbiDiff {
 
  private:
   repr::CompatibilityStatusIR CompareTUs(
-      const repr::TextFormatToIRReader *old_tu,
-      const repr::TextFormatToIRReader *new_tu,
+      const repr::IRReader *old_tu,
+      const repr::IRReader *new_tu,
       repr::IRDiffDumper *ir_diff_dumper);
 
   template <typename T, typename ElfSymbolType>
@@ -122,11 +122,11 @@ class HeaderAbiDiff {
 
   std::pair<AbiElementMap<const repr::EnumTypeIR *>,
             AbiElementMap<const repr::RecordTypeIR *>>
-  ExtractUserDefinedTypes(const repr::TextFormatToIRReader *tu);
+  ExtractUserDefinedTypes(const repr::IRReader *tu);
 
   bool CollectUserDefinedTypes(
-      const repr::TextFormatToIRReader *old_tu,
-      const repr::TextFormatToIRReader *new_tu,
+      const repr::IRReader *old_tu,
+      const repr::IRReader *new_tu,
       const AbiElementMap<const repr::TypeIR *> &old_types_map,
       const AbiElementMap<const repr::TypeIR *> &new_types_map,
       repr::IRDiffDumper *ir_diff_dumper);
diff --git a/vndk/tools/header-checker/src/linker/header_abi_linker.cpp b/vndk/tools/header-checker/src/linker/header_abi_linker.cpp
index 094e9e594..4955186f2 100644
--- a/vndk/tools/header-checker/src/linker/header_abi_linker.cpp
+++ b/vndk/tools/header-checker/src/linker/header_abi_linker.cpp
@@ -127,7 +127,7 @@ class HeaderAbiLinker {
                 const repr::AbiElementMap<T> &src,
                 const std::function<bool(const std::string &)> &symbol_filter);
 
-  std::unique_ptr<repr::TextFormatToIRReader> ReadInputDumpFiles();
+  std::unique_ptr<repr::IRReader> ReadInputDumpFiles();
 
   bool ReadExportedSymbols();
 
@@ -135,13 +135,12 @@ class HeaderAbiLinker {
 
   bool ReadExportedSymbolsFromSharedObjectFile();
 
-  bool LinkTypes(const repr::TextFormatToIRReader *ir_reader,
-                 repr::IRDumper *ir_dumper);
+  bool LinkTypes(const repr::IRReader *ir_reader, repr::IRDumper *ir_dumper);
 
-  bool LinkFunctions(const repr::TextFormatToIRReader *ir_reader,
+  bool LinkFunctions(const repr::IRReader *ir_reader,
                      repr::IRDumper *ir_dumper);
 
-  bool LinkGlobalVars(const repr::TextFormatToIRReader *ir_reader,
+  bool LinkGlobalVars(const repr::IRReader *ir_reader,
                       repr::IRDumper *ir_dumper);
 
   bool LinkExportedSymbols(repr::IRDumper *ir_dumper);
@@ -150,8 +149,7 @@ class HeaderAbiLinker {
                            const repr::ExportedSymbolSet &exported_symbols);
 
   template <typename SymbolMap>
-  bool LinkExportedSymbols(repr::IRDumper *ir_dumper,
-                           const SymbolMap &symbols);
+  bool LinkExportedSymbols(repr::IRDumper *ir_dumper, const SymbolMap &symbols);
 
   // Check whether a symbol name is considered as exported.  If both
   // `shared_object_symbols_` and `version_script_symbols_` exists, the symbol
@@ -180,11 +178,10 @@ class HeaderAbiLinker {
 static void DeDuplicateAbiElementsThread(
     const std::vector<std::string> &dump_files,
     const std::set<std::string> *exported_headers,
-    repr::TextFormatToIRReader *greader, std::mutex *greader_lock,
+    repr::IRReader *greader, std::mutex *greader_lock,
     std::atomic<std::size_t> *cnt) {
-  std::unique_ptr<repr::TextFormatToIRReader> local_reader =
-      repr::TextFormatToIRReader::CreateTextFormatToIRReader(
-          input_format, exported_headers);
+  std::unique_ptr<repr::IRReader> local_reader =
+      repr::IRReader::CreateIRReader(input_format, exported_headers);
 
   auto begin_it = dump_files.begin();
   std::size_t num_sources = dump_files.size();
@@ -195,9 +192,8 @@ static void DeDuplicateAbiElementsThread(
     }
     std::size_t end = std::min(i + kSourcesPerBatchThread, num_sources);
     for (auto it = begin_it; it != begin_it + end; it++) {
-      std::unique_ptr<repr::TextFormatToIRReader> reader =
-          repr::TextFormatToIRReader::CreateTextFormatToIRReader(
-              input_format, exported_headers);
+      std::unique_ptr<repr::IRReader> reader =
+          repr::IRReader::CreateIRReader(input_format, exported_headers);
       assert(reader != nullptr);
       if (!reader->ReadDump(*it)) {
         llvm::errs() << "ReadDump failed\n";
@@ -212,11 +208,10 @@ static void DeDuplicateAbiElementsThread(
   greader->MergeGraphs(*local_reader);
 }
 
-std::unique_ptr<repr::TextFormatToIRReader>
+std::unique_ptr<repr::IRReader>
 HeaderAbiLinker::ReadInputDumpFiles() {
-  std::unique_ptr<repr::TextFormatToIRReader> greader =
-      repr::TextFormatToIRReader::CreateTextFormatToIRReader(
-          input_format, &exported_headers_);
+  std::unique_ptr<repr::IRReader> greader =
+      repr::IRReader::CreateIRReader(input_format, &exported_headers_);
 
   std::size_t max_threads = std::thread::hardware_concurrency();
   std::size_t num_threads = kSourcesPerBatchThread < dump_files_.size() ?
@@ -301,7 +296,7 @@ bool HeaderAbiLinker::LinkDecl(
   return true;
 }
 
-bool HeaderAbiLinker::LinkTypes(const repr::TextFormatToIRReader *reader,
+bool HeaderAbiLinker::LinkTypes(const repr::IRReader *reader,
                                 repr::IRDumper *ir_dumper) {
   assert(reader != nullptr);
   auto no_filter = [](const std::string &symbol) { return true; };
@@ -327,8 +322,7 @@ bool HeaderAbiLinker::IsSymbolExported(const std::string &name) const {
 }
 
 bool HeaderAbiLinker::LinkFunctions(
-    const repr::TextFormatToIRReader *reader,
-    repr::IRDumper *ir_dumper) {
+    const repr::IRReader *reader, repr::IRDumper *ir_dumper) {
   assert(reader != nullptr);
   auto symbol_filter = [this](const std::string &linker_set_key) {
     return IsSymbolExported(linker_set_key);
@@ -337,8 +331,7 @@ bool HeaderAbiLinker::LinkFunctions(
 }
 
 bool HeaderAbiLinker::LinkGlobalVars(
-    const repr::TextFormatToIRReader *reader,
-    repr::IRDumper *ir_dumper) {
+    const repr::IRReader *reader, repr::IRDumper *ir_dumper) {
   assert(reader != nullptr);
   auto symbol_filter = [this](const std::string &linker_set_key) {
     return IsSymbolExported(linker_set_key);
diff --git a/vndk/tools/header-checker/src/repr/abi_diff_helpers.h b/vndk/tools/header-checker/src/repr/abi_diff_helpers.h
index b31d3ae34..40febf4c6 100644
--- a/vndk/tools/header-checker/src/repr/abi_diff_helpers.h
+++ b/vndk/tools/header-checker/src/repr/abi_diff_helpers.h
@@ -30,7 +30,7 @@ namespace repr {
 // Classes which act as middle-men between clang AST parsing routines and
 // message format specific dumpers.
 
-using MergeStatus = TextFormatToIRReader::MergeStatus;
+using MergeStatus = IRReader::MergeStatus;
 
 enum DiffStatus {
   // There was no diff found while comparing types.
diff --git a/vndk/tools/header-checker/src/repr/ir_reader.cpp b/vndk/tools/header-checker/src/repr/ir_reader.cpp
index 0b7ad2f3e..22594423a 100644
--- a/vndk/tools/header-checker/src/repr/ir_reader.cpp
+++ b/vndk/tools/header-checker/src/repr/ir_reader.cpp
@@ -33,17 +33,17 @@ namespace header_checker {
 namespace repr {
 
 
-using MergeStatus = TextFormatToIRReader::MergeStatus;
+using MergeStatus = IRReader::MergeStatus;
 
 
-std::unique_ptr<TextFormatToIRReader>
-TextFormatToIRReader::CreateTextFormatToIRReader(
+std::unique_ptr<IRReader>
+IRReader::CreateIRReader(
     TextFormatIR text_format, const std::set<std::string> *exported_headers) {
   switch (text_format) {
     case TextFormatIR::ProtobufTextFormat:
-      return std::make_unique<ProtobufTextFormatToIRReader>(exported_headers);
+      return std::make_unique<ProtobufIRReader>(exported_headers);
     case TextFormatIR::Json:
-      return std::make_unique<JsonToIRReader>(exported_headers);
+      return std::make_unique<JsonIRReader>(exported_headers);
     default:
       llvm::errs() << "Text format not supported yet\n";
       return nullptr;
@@ -51,8 +51,7 @@ TextFormatToIRReader::CreateTextFormatToIRReader(
 }
 
 
-void TextFormatToIRReader::AddToODRListMap(const std::string &key,
-                                           const TypeIR *value) {
+void IRReader::AddToODRListMap(const std::string &key, const TypeIR *value) {
   auto map_it = module_->odr_list_map_.find(key);
   if (map_it == module_->odr_list_map_.end()) {
     module_->odr_list_map_.emplace(key, std::list<const TypeIR *>({value}));
@@ -62,8 +61,8 @@ void TextFormatToIRReader::AddToODRListMap(const std::string &key,
 }
 
 
-MergeStatus TextFormatToIRReader::IsBuiltinTypeNodePresent(
-    const BuiltinTypeIR *builtin_type, const TextFormatToIRReader &addend,
+MergeStatus IRReader::IsBuiltinTypeNodePresent(
+    const BuiltinTypeIR *builtin_type, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   std::string builtin_linker_set_key = builtin_type->GetLinkerSetKey();
   auto builtin_it = module_->builtin_types_.find(builtin_linker_set_key);
@@ -86,8 +85,8 @@ MergeStatus TextFormatToIRReader::IsBuiltinTypeNodePresent(
 }
 
 
-MergeStatus TextFormatToIRReader::DoesUDTypeODRViolationExist(
-    const TypeIR *ud_type, const TextFormatToIRReader &addend,
+MergeStatus IRReader::DoesUDTypeODRViolationExist(
+    const TypeIR *ud_type, const IRReader &addend,
     const std::string ud_type_unique_id_and_source,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map_) {
   // Per entry in the map:
@@ -124,8 +123,8 @@ MergeStatus TextFormatToIRReader::DoesUDTypeODRViolationExist(
 }
 
 
-MergeStatus TextFormatToIRReader::IsTypeNodePresent(
-    const TypeIR *addend_node, const TextFormatToIRReader &addend,
+MergeStatus IRReader::IsTypeNodePresent(
+    const TypeIR *addend_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   std::string unique_type_id;
   switch (addend_node->GetKind()) {
@@ -155,8 +154,8 @@ MergeStatus TextFormatToIRReader::IsTypeNodePresent(
 // This method merges the type referenced by 'references_type' into the parent
 // graph. It also corrects the referenced_type field in the references_type
 // object passed and returns the merge status of the *referenced type*.
-MergeStatus TextFormatToIRReader::MergeReferencingTypeInternal(
-    const TextFormatToIRReader &addend,
+MergeStatus IRReader::MergeReferencingTypeInternal(
+    const IRReader &addend,
     ReferencesOtherType *references_type,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   // First look in the local_to_global_type_id_map for the referenced type's
@@ -192,8 +191,8 @@ MergeStatus TextFormatToIRReader::MergeReferencingTypeInternal(
 }
 
 
-void TextFormatToIRReader::MergeRecordFields(
-    const TextFormatToIRReader &addend, RecordTypeIR *added_node,
+void IRReader::MergeRecordFields(
+    const IRReader &addend, RecordTypeIR *added_node,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   for (auto &field : added_node->GetFields()) {
     MergeReferencingTypeInternal(addend, &field, local_to_global_type_id_map);
@@ -201,8 +200,8 @@ void TextFormatToIRReader::MergeRecordFields(
 }
 
 
-void TextFormatToIRReader::MergeRecordCXXBases(
-    const TextFormatToIRReader &addend, RecordTypeIR *added_node,
+void IRReader::MergeRecordCXXBases(
+    const IRReader &addend, RecordTypeIR *added_node,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   for (auto &base : added_node->GetBases()) {
     MergeReferencingTypeInternal(addend, &base, local_to_global_type_id_map);
@@ -210,8 +209,8 @@ void TextFormatToIRReader::MergeRecordCXXBases(
 }
 
 
-void TextFormatToIRReader::MergeRecordTemplateElements(
-    const TextFormatToIRReader &addend, RecordTypeIR *added_node,
+void IRReader::MergeRecordTemplateElements(
+    const IRReader &addend, RecordTypeIR *added_node,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   for (auto &template_element : added_node->GetTemplateElements()) {
     MergeReferencingTypeInternal(
@@ -220,8 +219,8 @@ void TextFormatToIRReader::MergeRecordTemplateElements(
 }
 
 
-void TextFormatToIRReader::MergeRecordDependencies(
-    const TextFormatToIRReader &addend, RecordTypeIR *added_node,
+void IRReader::MergeRecordDependencies(
+    const IRReader &addend, RecordTypeIR *added_node,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   // First call MergeType on all its fields.
   MergeRecordFields(addend, added_node, local_to_global_type_id_map);
@@ -235,8 +234,8 @@ void TextFormatToIRReader::MergeRecordDependencies(
 
 template <typename T>
 std::pair<MergeStatus, typename AbiElementMap<T>::iterator>
-TextFormatToIRReader::UpdateUDTypeAccounting(
-    const T *addend_node, const TextFormatToIRReader &addend,
+IRReader::UpdateUDTypeAccounting(
+    const T *addend_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map,
     AbiElementMap<T> *specific_type_map) {
   std::string added_type_id = AllocateNewTypeId();
@@ -261,8 +260,8 @@ TextFormatToIRReader::UpdateUDTypeAccounting(
 
 // This method is necessarily going to have a was_newly_merged_ = true in its
 // MergeStatus return. So it necessarily merges a new RecordType.
-MergeStatus TextFormatToIRReader::MergeRecordAndDependencies(
-  const RecordTypeIR *addend_node, const TextFormatToIRReader &addend,
+MergeStatus IRReader::MergeRecordAndDependencies(
+  const RecordTypeIR *addend_node, const IRReader &addend,
   AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   auto merge_status_and_it =
       UpdateUDTypeAccounting(addend_node, addend, local_to_global_type_id_map,
@@ -273,8 +272,8 @@ MergeStatus TextFormatToIRReader::MergeRecordAndDependencies(
 }
 
 
-void TextFormatToIRReader::MergeEnumDependencies(
-    const TextFormatToIRReader &addend, EnumTypeIR *added_node,
+void IRReader::MergeEnumDependencies(
+    const IRReader &addend, EnumTypeIR *added_node,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   const std::string underlying_type_id = added_node->GetUnderlyingType();
   // Get the underlying type, it nessarily has to be present in the addend's
@@ -293,8 +292,8 @@ void TextFormatToIRReader::MergeEnumDependencies(
 
 // This method is necessarily going to have a was_newly_merged_ = true in its
 // MergeStatus return. So it necessarily merges a new EnumType.
-MergeStatus TextFormatToIRReader::MergeEnumType(
-    const EnumTypeIR *addend_node, const TextFormatToIRReader &addend,
+MergeStatus IRReader::MergeEnumType(
+    const EnumTypeIR *addend_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   auto merge_status_and_it =
       UpdateUDTypeAccounting(addend_node, addend, local_to_global_type_id_map,
@@ -305,8 +304,8 @@ MergeStatus TextFormatToIRReader::MergeEnumType(
 }
 
 
-MergeStatus TextFormatToIRReader::MergeFunctionType(
-    const FunctionTypeIR *addend_node, const TextFormatToIRReader &addend,
+MergeStatus IRReader::MergeFunctionType(
+    const FunctionTypeIR *addend_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   auto merge_status_and_it =
       UpdateUDTypeAccounting(addend_node, addend, local_to_global_type_id_map,
@@ -318,8 +317,8 @@ MergeStatus TextFormatToIRReader::MergeFunctionType(
 
 
 template <typename T>
-MergeStatus TextFormatToIRReader::MergeReferencingTypeInternalAndUpdateParent(
-    const TextFormatToIRReader &addend, const T *addend_node,
+MergeStatus IRReader::MergeReferencingTypeInternalAndUpdateParent(
+    const IRReader &addend, const T *addend_node,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map,
     AbiElementMap<T> *parent_map, const std::string &updated_self_type_id) {
   MergeStatus merge_status;
@@ -380,8 +379,8 @@ MergeStatus TextFormatToIRReader::MergeReferencingTypeInternalAndUpdateParent(
 }
 
 
-MergeStatus TextFormatToIRReader::MergeReferencingType(
-    const TextFormatToIRReader &addend, const TypeIR *addend_node,
+MergeStatus IRReader::MergeReferencingType(
+    const IRReader &addend, const TypeIR *addend_node,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map,
     const std::string &updated_self_type_id) {
   switch (addend_node->GetKind()) {
@@ -419,8 +418,8 @@ MergeStatus TextFormatToIRReader::MergeReferencingType(
 
 // This method creates a new node for the addend node in the graph if MergeType
 // on the reference returned a MergeStatus with was_newly_added_ = true.
-MergeStatus TextFormatToIRReader::MergeGenericReferringType(
-    const TextFormatToIRReader &addend, const TypeIR *addend_node,
+MergeStatus IRReader::MergeGenericReferringType(
+    const IRReader &addend, const TypeIR *addend_node,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   // First add the type 'pro-actively'. We need to do this since we'll need to
   // fill in 'referenced-type' fields in all this type's descendants and
@@ -434,8 +433,8 @@ MergeStatus TextFormatToIRReader::MergeGenericReferringType(
 }
 
 
-MergeStatus TextFormatToIRReader::MergeTypeInternal(
-    const TypeIR *addend_node, const TextFormatToIRReader &addend,
+MergeStatus IRReader::MergeTypeInternal(
+    const TypeIR *addend_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   switch (addend_node->GetKind()) {
     case BuiltinTypeKind:
@@ -461,9 +460,8 @@ MergeStatus TextFormatToIRReader::MergeTypeInternal(
 }
 
 
-MergeStatus TextFormatToIRReader::MergeType(
-    const TypeIR *addend_node,
-    const TextFormatToIRReader &addend,
+MergeStatus IRReader::MergeType(
+    const TypeIR *addend_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   // Check if the addend type is already in the parent graph. Since we're
   // going to traverse all the dependencies add whichever ones are not in the
@@ -484,8 +482,8 @@ MergeStatus TextFormatToIRReader::MergeType(
 }
 
 
-void TextFormatToIRReader::MergeCFunctionLikeDeps(
-    const TextFormatToIRReader &addend, CFunctionLikeIR *cfunction_like_ir,
+void IRReader::MergeCFunctionLikeDeps(
+    const IRReader &addend, CFunctionLikeIR *cfunction_like_ir,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   // Merge the return type first.
   auto ret_type_it =
@@ -506,8 +504,8 @@ void TextFormatToIRReader::MergeCFunctionLikeDeps(
 }
 
 
-void TextFormatToIRReader::MergeFunctionDeps(
-    FunctionIR *added_node, const TextFormatToIRReader &addend,
+void IRReader::MergeFunctionDeps(
+    FunctionIR *added_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   MergeCFunctionLikeDeps(addend, added_node, local_to_global_type_id_map);
   // Merge and fix template parameters
@@ -525,8 +523,8 @@ static bool IsLinkableMessagePresent(const LinkableMessageIR *lm,
 }
 
 
-void TextFormatToIRReader::MergeFunction(
-    const FunctionIR *addend_node, const TextFormatToIRReader &addend,
+void IRReader::MergeFunction(
+    const FunctionIR *addend_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   const std::string &function_linkage_name = addend_node->GetLinkerSetKey();
   if (IsLinkableMessagePresent(addend_node, module_->functions_)) {
@@ -541,13 +539,13 @@ void TextFormatToIRReader::MergeFunction(
 }
 
 
-std::string TextFormatToIRReader::AllocateNewTypeId() {
+std::string IRReader::AllocateNewTypeId() {
   return "type-" + std::to_string(++max_type_id_);
 }
 
 
-void TextFormatToIRReader::MergeGlobalVariable(
-    const GlobalVarIR *addend_node, const TextFormatToIRReader &addend,
+void IRReader::MergeGlobalVariable(
+    const GlobalVarIR *addend_node, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
   const std::string &global_variable_linkage_name =
       addend_node->GetLinkerSetKey();
@@ -563,7 +561,7 @@ void TextFormatToIRReader::MergeGlobalVariable(
 }
 
 
-void TextFormatToIRReader::MergeGraphs(const TextFormatToIRReader &addend) {
+void IRReader::MergeGraphs(const IRReader &addend) {
   // Iterate through nodes of addend reader and merge them.
   // Keep a merged types cache since if a type is merged, so will all of its
   // dependencies which weren't already merged.
@@ -583,7 +581,7 @@ void TextFormatToIRReader::MergeGraphs(const TextFormatToIRReader &addend) {
 }
 
 
-bool TextFormatToIRReader::IsLinkableMessageInExportedHeaders(
+bool IRReader::IsLinkableMessageInExportedHeaders(
     const LinkableMessageIR *linkable_message) const {
   if (module_->exported_headers_ == nullptr ||
       module_->exported_headers_->empty()) {
diff --git a/vndk/tools/header-checker/src/repr/ir_reader.h b/vndk/tools/header-checker/src/repr/ir_reader.h
index ec380a890..d304e8498 100644
--- a/vndk/tools/header-checker/src/repr/ir_reader.h
+++ b/vndk/tools/header-checker/src/repr/ir_reader.h
@@ -29,7 +29,7 @@ namespace header_checker {
 namespace repr {
 
 
-class TextFormatToIRReader {
+class IRReader {
  public:
   struct MergeStatus {
     MergeStatus(bool was_newly_added, const std::string &type_id)
@@ -49,10 +49,10 @@ class TextFormatToIRReader {
   };
 
  public:
-  TextFormatToIRReader(const std::set<std::string> *exported_headers)
+  IRReader(const std::set<std::string> *exported_headers)
       : module_(new ModuleIR(exported_headers)) {}
 
-  virtual ~TextFormatToIRReader() {}
+  virtual ~IRReader() {}
 
   const AbiElementMap<FunctionIR> &GetFunctions() const {
     return module_->functions_;
@@ -117,7 +117,7 @@ class TextFormatToIRReader {
 
   virtual bool ReadDump(const std::string &dump_file) = 0;
 
-  void Merge(TextFormatToIRReader &&addend) {
+  void Merge(IRReader &&addend) {
     MergeElements(&module_->functions_, std::move(addend.module_->functions_));
     MergeElements(&module_->global_variables_,
                   std::move(addend.module_->global_variables_));
@@ -143,112 +143,112 @@ class TextFormatToIRReader {
 
   template <typename T>
   MergeStatus MergeReferencingTypeInternalAndUpdateParent(
-      const TextFormatToIRReader &addend, const T *addend_node,
+      const IRReader &addend, const T *addend_node,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map,
       AbiElementMap<T> *parent_map, const std::string  &updated_self_type_id);
 
   MergeStatus DoesUDTypeODRViolationExist(
-      const TypeIR *ud_type, const TextFormatToIRReader &addend,
+      const TypeIR *ud_type, const IRReader &addend,
       const std::string ud_type_unique_id,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map_);
 
   MergeStatus MergeReferencingTypeInternal(
-      const TextFormatToIRReader &addend, ReferencesOtherType *references_type,
+      const IRReader &addend, ReferencesOtherType *references_type,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   MergeStatus MergeReferencingType(
-      const TextFormatToIRReader &addend, const TypeIR *addend_node,
+      const IRReader &addend, const TypeIR *addend_node,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map,
       const std::string  &updated_self_type_id);
 
   MergeStatus MergeGenericReferringType(
-      const TextFormatToIRReader &addend, const TypeIR *addend_node,
+      const IRReader &addend, const TypeIR *addend_node,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   template <typename T>
   std::pair<MergeStatus, typename AbiElementMap<T>::iterator>
   UpdateUDTypeAccounting(
-      const T *addend_node, const TextFormatToIRReader &addend,
+      const T *addend_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map,
       AbiElementMap<T> *specific_type_map);
 
   MergeStatus MergeTypeInternal(
-      const TypeIR *addend_node, const TextFormatToIRReader &addend,
+      const TypeIR *addend_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeCFunctionLikeDeps(
-      const TextFormatToIRReader &addend, CFunctionLikeIR *cfunction_like_ir,
+      const IRReader &addend, CFunctionLikeIR *cfunction_like_ir,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   MergeStatus MergeFunctionType(
-      const FunctionTypeIR *addend_node, const TextFormatToIRReader &addend,
+      const FunctionTypeIR *addend_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   MergeStatus MergeEnumType(
-      const EnumTypeIR *addend_node, const TextFormatToIRReader &addend,
+      const EnumTypeIR *addend_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeEnumDependencies(
-      const TextFormatToIRReader &addend, EnumTypeIR *added_node,
+      const IRReader &addend, EnumTypeIR *added_node,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   MergeStatus MergeRecordAndDependencies(
-      const RecordTypeIR *addend_node, const TextFormatToIRReader &addend,
+      const RecordTypeIR *addend_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeRecordDependencies(
-      const TextFormatToIRReader &addend, RecordTypeIR *added_node,
+      const IRReader &addend, RecordTypeIR *added_node,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeRecordFields(
-      const TextFormatToIRReader &addend, RecordTypeIR *added_node,
+      const IRReader &addend, RecordTypeIR *added_node,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeRecordCXXBases(
-      const TextFormatToIRReader &addend, RecordTypeIR *added_node,
+      const IRReader &addend, RecordTypeIR *added_node,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeRecordTemplateElements(
-      const TextFormatToIRReader &addend, RecordTypeIR *added_node,
+      const IRReader &addend, RecordTypeIR *added_node,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   MergeStatus IsBuiltinTypeNodePresent(
-      const BuiltinTypeIR *builtin_type, const TextFormatToIRReader &addend,
+      const BuiltinTypeIR *builtin_type, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeGlobalVariable(
-      const GlobalVarIR *addend_node, const TextFormatToIRReader &addend,
+      const GlobalVarIR *addend_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeGlobalVariables(
-      const TextFormatToIRReader &addend,
+      const IRReader &addend,
       AbiElementMap<MergeStatus>  *local_to_global_type_id_map);
 
   void MergeFunctionDeps(
-      FunctionIR *added_node, const TextFormatToIRReader &addend,
+      FunctionIR *added_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   void MergeFunction(
-      const FunctionIR *addend_node, const TextFormatToIRReader &addend,
+      const FunctionIR *addend_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
-  void MergeGraphs(const TextFormatToIRReader &addend);
+  void MergeGraphs(const IRReader &addend);
 
-  void UpdateTextFormatToIRReaderTypeGraph(
+  void UpdateIRReaderTypeGraph(
       const TypeIR *addend_node, const std::string &added_type_id,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   MergeStatus IsTypeNodePresent(
-      const TypeIR *addend_node, const TextFormatToIRReader &addend,
+      const TypeIR *addend_node, const IRReader &addend,
       AbiElementMap<MergeStatus> *local_to_global_type_id_map);
 
   MergeStatus MergeType(
-      const TypeIR *addend_type, const TextFormatToIRReader &addend,
+      const TypeIR *addend_type, const IRReader &addend,
       AbiElementMap<MergeStatus> *merged_types_cache);
 
   std::string AllocateNewTypeId();
 
-  static std::unique_ptr<TextFormatToIRReader> CreateTextFormatToIRReader(
+  static std::unique_ptr<IRReader> CreateIRReader(
       TextFormatIR text_format,
       const std::set<std::string> *exported_headers = nullptr);
 
diff --git a/vndk/tools/header-checker/src/repr/json/ir_reader.cpp b/vndk/tools/header-checker/src/repr/json/ir_reader.cpp
index 72875901c..bd79eb977 100644
--- a/vndk/tools/header-checker/src/repr/json/ir_reader.cpp
+++ b/vndk/tools/header-checker/src/repr/json/ir_reader.cpp
@@ -151,7 +151,7 @@ GetElfSymbolBinding(const JsonObjectRef &elf_symbol) {
                    "Failed to convert JSON to ElfSymbolBinding");
 }
 
-bool JsonToIRReader::ReadDump(const std::string &dump_file) {
+bool JsonIRReader::ReadDump(const std::string &dump_file) {
   Json::Value tu_json;
   Json::Reader reader;
   std::ifstream input(dump_file);
@@ -188,13 +188,13 @@ bool JsonToIRReader::ReadDump(const std::string &dump_file) {
   return true;
 }
 
-void JsonToIRReader::ReadTagTypeInfo(const JsonObjectRef &type_decl,
-                                     TagTypeIR *tag_type_ir) {
+void JsonIRReader::ReadTagTypeInfo(const JsonObjectRef &type_decl,
+                                   TagTypeIR *tag_type_ir) {
   tag_type_ir->SetUniqueId(type_decl.GetString("unique_id"));
 }
 
-void JsonToIRReader::ReadTemplateInfo(const JsonObjectRef &type_decl,
-                                      TemplatedArtifactIR *template_ir) {
+void JsonIRReader::ReadTemplateInfo(const JsonObjectRef &type_decl,
+                                    TemplatedArtifactIR *template_ir) {
   TemplateInfoIR template_info_ir;
   for (auto &&referenced_type : type_decl.GetStrings("template_args")) {
     TemplateElementIR template_element_ir(referenced_type);
@@ -203,8 +203,8 @@ void JsonToIRReader::ReadTemplateInfo(const JsonObjectRef &type_decl,
   template_ir->SetTemplateInfo(std::move(template_info_ir));
 }
 
-void JsonToIRReader::ReadTypeInfo(const JsonObjectRef &type_decl,
-                                  TypeIR *type_ir) {
+void JsonIRReader::ReadTypeInfo(const JsonObjectRef &type_decl,
+                                TypeIR *type_ir) {
   type_ir->SetLinkerSetKey(type_decl.GetString("linker_set_key"));
   type_ir->SetSourceFile(type_decl.GetString("source_file"));
   type_ir->SetName(type_decl.GetString("name"));
@@ -214,8 +214,8 @@ void JsonToIRReader::ReadTypeInfo(const JsonObjectRef &type_decl,
   type_ir->SetAlignment(type_decl.GetUint("alignment"));
 }
 
-void JsonToIRReader::ReadRecordFields(const JsonObjectRef &record_type,
-                                      RecordTypeIR *record_ir) {
+void JsonIRReader::ReadRecordFields(const JsonObjectRef &record_type,
+                                    RecordTypeIR *record_ir) {
   for (auto &&field : record_type.GetObjects("fields")) {
     RecordFieldIR record_field_ir(
         field.GetString("field_name"), field.GetString("referenced_type"),
@@ -224,8 +224,8 @@ void JsonToIRReader::ReadRecordFields(const JsonObjectRef &record_type,
   }
 }
 
-void JsonToIRReader::ReadBaseSpecifiers(const JsonObjectRef &record_type,
-                                        RecordTypeIR *record_ir) {
+void JsonIRReader::ReadBaseSpecifiers(const JsonObjectRef &record_type,
+                                      RecordTypeIR *record_ir) {
   for (auto &&base_specifier : record_type.GetObjects("base_specifiers")) {
     CXXBaseSpecifierIR record_base_ir(
         base_specifier.GetString("referenced_type"),
@@ -234,8 +234,8 @@ void JsonToIRReader::ReadBaseSpecifiers(const JsonObjectRef &record_type,
   }
 }
 
-void JsonToIRReader::ReadVTableLayout(const JsonObjectRef &record_type,
-                                      RecordTypeIR *record_ir) {
+void JsonIRReader::ReadVTableLayout(const JsonObjectRef &record_type,
+                                    RecordTypeIR *record_ir) {
   VTableLayoutIR vtable_layout_ir;
   for (auto &&vtable_component : record_type.GetObjects("vtable_components")) {
     VTableComponentIR vtable_component_ir(
@@ -248,8 +248,8 @@ void JsonToIRReader::ReadVTableLayout(const JsonObjectRef &record_type,
   record_ir->SetVTableLayout(std::move(vtable_layout_ir));
 }
 
-void JsonToIRReader::ReadEnumFields(const JsonObjectRef &enum_type,
-                                    EnumTypeIR *enum_ir) {
+void JsonIRReader::ReadEnumFields(const JsonObjectRef &enum_type,
+                                  EnumTypeIR *enum_ir) {
   for (auto &&field : enum_type.GetObjects("enum_fields")) {
     EnumFieldIR enum_field_ir(field.GetString("name"),
                               field.GetInt("enum_field_value"));
@@ -257,7 +257,7 @@ void JsonToIRReader::ReadEnumFields(const JsonObjectRef &enum_type,
   }
 }
 
-void JsonToIRReader::ReadFunctionParametersAndReturnType(
+void JsonIRReader::ReadFunctionParametersAndReturnType(
     const JsonObjectRef &function, CFunctionLikeIR *function_ir) {
   function_ir->SetReturnType(function.GetString("return_type"));
   for (auto &&parameter : function.GetObjects("parameters")) {
@@ -268,7 +268,7 @@ void JsonToIRReader::ReadFunctionParametersAndReturnType(
   }
 }
 
-FunctionIR JsonToIRReader::FunctionJsonToIR(const JsonObjectRef &function) {
+FunctionIR JsonIRReader::FunctionJsonToIR(const JsonObjectRef &function) {
   FunctionIR function_ir;
   function_ir.SetLinkerSetKey(function.GetString("linker_set_key"));
   function_ir.SetName(function.GetString("function_name"));
@@ -280,7 +280,7 @@ FunctionIR JsonToIRReader::FunctionJsonToIR(const JsonObjectRef &function) {
 }
 
 FunctionTypeIR
-JsonToIRReader::FunctionTypeJsonToIR(const JsonObjectRef &function_type) {
+JsonIRReader::FunctionTypeJsonToIR(const JsonObjectRef &function_type) {
   FunctionTypeIR function_type_ir;
   ReadTypeInfo(function_type, &function_type_ir);
   ReadFunctionParametersAndReturnType(function_type, &function_type_ir);
@@ -288,7 +288,7 @@ JsonToIRReader::FunctionTypeJsonToIR(const JsonObjectRef &function_type) {
 }
 
 RecordTypeIR
-JsonToIRReader::RecordTypeJsonToIR(const JsonObjectRef &record_type) {
+JsonIRReader::RecordTypeJsonToIR(const JsonObjectRef &record_type) {
   RecordTypeIR record_type_ir;
   ReadTypeInfo(record_type, &record_type_ir);
   ReadTemplateInfo(record_type, &record_type_ir);
@@ -302,7 +302,7 @@ JsonToIRReader::RecordTypeJsonToIR(const JsonObjectRef &record_type) {
   return record_type_ir;
 }
 
-EnumTypeIR JsonToIRReader::EnumTypeJsonToIR(const JsonObjectRef &enum_type) {
+EnumTypeIR JsonIRReader::EnumTypeJsonToIR(const JsonObjectRef &enum_type) {
   EnumTypeIR enum_type_ir;
   ReadTypeInfo(enum_type, &enum_type_ir);
   enum_type_ir.SetUnderlyingType(enum_type.GetString("underlying_type"));
@@ -312,7 +312,7 @@ EnumTypeIR JsonToIRReader::EnumTypeJsonToIR(const JsonObjectRef &enum_type) {
   return enum_type_ir;
 }
 
-void JsonToIRReader::ReadGlobalVariables(const JsonObjectRef &tu) {
+void JsonIRReader::ReadGlobalVariables(const JsonObjectRef &tu) {
   for (auto &&global_variable : tu.GetObjects("global_vars")) {
     GlobalVarIR global_variable_ir;
     global_variable_ir.SetName(global_variable.GetString("name"));
@@ -330,7 +330,7 @@ void JsonToIRReader::ReadGlobalVariables(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadPointerTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadPointerTypes(const JsonObjectRef &tu) {
   for (auto &&pointer_type : tu.GetObjects("pointer_types")) {
     PointerTypeIR pointer_type_ir;
     ReadTypeInfo(pointer_type, &pointer_type_ir);
@@ -342,7 +342,7 @@ void JsonToIRReader::ReadPointerTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadBuiltinTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadBuiltinTypes(const JsonObjectRef &tu) {
   for (auto &&builtin_type : tu.GetObjects("builtin_types")) {
     BuiltinTypeIR builtin_type_ir;
     ReadTypeInfo(builtin_type, &builtin_type_ir);
@@ -353,7 +353,7 @@ void JsonToIRReader::ReadBuiltinTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadQualifiedTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadQualifiedTypes(const JsonObjectRef &tu) {
   for (auto &&qualified_type : tu.GetObjects("qualified_types")) {
     QualifiedTypeIR qualified_type_ir;
     ReadTypeInfo(qualified_type, &qualified_type_ir);
@@ -369,7 +369,7 @@ void JsonToIRReader::ReadQualifiedTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadArrayTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadArrayTypes(const JsonObjectRef &tu) {
   for (auto &&array_type : tu.GetObjects("array_types")) {
     ArrayTypeIR array_type_ir;
     ReadTypeInfo(array_type, &array_type_ir);
@@ -381,7 +381,7 @@ void JsonToIRReader::ReadArrayTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadLvalueReferenceTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadLvalueReferenceTypes(const JsonObjectRef &tu) {
   for (auto &&lvalue_reference_type : tu.GetObjects("lvalue_reference_types")) {
     LvalueReferenceTypeIR lvalue_reference_type_ir;
     ReadTypeInfo(lvalue_reference_type, &lvalue_reference_type_ir);
@@ -394,7 +394,7 @@ void JsonToIRReader::ReadLvalueReferenceTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadRvalueReferenceTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadRvalueReferenceTypes(const JsonObjectRef &tu) {
   for (auto &&rvalue_reference_type : tu.GetObjects("rvalue_reference_types")) {
     RvalueReferenceTypeIR rvalue_reference_type_ir;
     ReadTypeInfo(rvalue_reference_type, &rvalue_reference_type_ir);
@@ -407,7 +407,7 @@ void JsonToIRReader::ReadRvalueReferenceTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadFunctions(const JsonObjectRef &tu) {
+void JsonIRReader::ReadFunctions(const JsonObjectRef &tu) {
   for (auto &&function : tu.GetObjects("functions")) {
     FunctionIR function_ir = FunctionJsonToIR(function);
     if (!IsLinkableMessageInExportedHeaders(&function_ir)) {
@@ -418,7 +418,7 @@ void JsonToIRReader::ReadFunctions(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadRecordTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadRecordTypes(const JsonObjectRef &tu) {
   for (auto &&record_type : tu.GetObjects("record_types")) {
     RecordTypeIR record_type_ir = RecordTypeJsonToIR(record_type);
     if (!IsLinkableMessageInExportedHeaders(&record_type_ir)) {
@@ -432,7 +432,7 @@ void JsonToIRReader::ReadRecordTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadFunctionTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadFunctionTypes(const JsonObjectRef &tu) {
   for (auto &&function_type : tu.GetObjects("function_types")) {
     FunctionTypeIR function_type_ir = FunctionTypeJsonToIR(function_type);
     if (!IsLinkableMessageInExportedHeaders(&function_type_ir)) {
@@ -446,7 +446,7 @@ void JsonToIRReader::ReadFunctionTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadEnumTypes(const JsonObjectRef &tu) {
+void JsonIRReader::ReadEnumTypes(const JsonObjectRef &tu) {
   for (auto &&enum_type : tu.GetObjects("enum_types")) {
     EnumTypeIR enum_type_ir = EnumTypeJsonToIR(enum_type);
     if (!IsLinkableMessageInExportedHeaders(&enum_type_ir)) {
@@ -460,7 +460,7 @@ void JsonToIRReader::ReadEnumTypes(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadElfFunctions(const JsonObjectRef &tu) {
+void JsonIRReader::ReadElfFunctions(const JsonObjectRef &tu) {
   for (auto &&elf_function : tu.GetObjects("elf_functions")) {
     ElfFunctionIR elf_function_ir(elf_function.GetString("name"),
                                   GetElfSymbolBinding(elf_function));
@@ -469,7 +469,7 @@ void JsonToIRReader::ReadElfFunctions(const JsonObjectRef &tu) {
   }
 }
 
-void JsonToIRReader::ReadElfObjects(const JsonObjectRef &tu) {
+void JsonIRReader::ReadElfObjects(const JsonObjectRef &tu) {
   for (auto &&elf_object : tu.GetObjects("elf_objects")) {
     ElfObjectIR elf_object_ir(elf_object.GetString("name"),
                               GetElfSymbolBinding(elf_object));
diff --git a/vndk/tools/header-checker/src/repr/json/ir_reader.h b/vndk/tools/header-checker/src/repr/json/ir_reader.h
index 797e65e9b..cdaac6c9e 100644
--- a/vndk/tools/header-checker/src/repr/json/ir_reader.h
+++ b/vndk/tools/header-checker/src/repr/json/ir_reader.h
@@ -111,10 +111,10 @@ JsonObjectRef JsonArrayRef<JsonObjectRef>::Iterator::operator*() const;
 
 template <> std::string JsonArrayRef<std::string>::Iterator::operator*() const;
 
-class JsonToIRReader : public TextFormatToIRReader {
+class JsonIRReader : public IRReader {
  public:
-  JsonToIRReader(const std::set<std::string> *exported_headers)
-      : TextFormatToIRReader(exported_headers) {}
+  JsonIRReader(const std::set<std::string> *exported_headers)
+      : IRReader(exported_headers) {}
 
   bool ReadDump(const std::string &dump_file) override;
 
diff --git a/vndk/tools/header-checker/src/repr/protobuf/ir_reader.cpp b/vndk/tools/header-checker/src/repr/protobuf/ir_reader.cpp
index 2cf0da96c..f29dc8b60 100644
--- a/vndk/tools/header-checker/src/repr/protobuf/ir_reader.cpp
+++ b/vndk/tools/header-checker/src/repr/protobuf/ir_reader.cpp
@@ -26,7 +26,7 @@ namespace header_checker {
 namespace repr {
 
 
-void ProtobufTextFormatToIRReader::ReadTypeInfo(
+void ProtobufIRReader::ReadTypeInfo(
     const abi_dump::BasicNamedAndTypedDecl &type_info, TypeIR *typep) {
   typep->SetLinkerSetKey(type_info.linker_set_key());
   typep->SetName(type_info.name());
@@ -37,7 +37,7 @@ void ProtobufTextFormatToIRReader::ReadTypeInfo(
   typep->SetAlignment(type_info.alignment());
 }
 
-bool ProtobufTextFormatToIRReader::ReadDump(const std::string &dump_file) {
+bool ProtobufIRReader::ReadDump(const std::string &dump_file) {
   abi_dump::TranslationUnit tu;
   std::ifstream input(dump_file);
   google::protobuf::io::IstreamInputStream text_is(&input);
@@ -64,7 +64,7 @@ bool ProtobufTextFormatToIRReader::ReadDump(const std::string &dump_file) {
   return true;
 }
 
-TemplateInfoIR ProtobufTextFormatToIRReader::TemplateInfoProtobufToIR(
+TemplateInfoIR ProtobufIRReader::TemplateInfoProtobufToIR(
     const abi_dump::TemplateInfo &template_info_protobuf) {
   TemplateInfoIR template_info_ir;
   for (auto &&template_element : template_info_protobuf.elements()) {
@@ -85,7 +85,7 @@ static void SetupCFunctionLikeIR(const T &cfunction_like_protobuf,
   }
 }
 
-FunctionIR ProtobufTextFormatToIRReader::FunctionProtobufToIR(
+FunctionIR ProtobufIRReader::FunctionProtobufToIR(
     const abi_dump::FunctionDecl &function_protobuf) {
   FunctionIR function_ir;
   function_ir.SetReturnType(function_protobuf.return_type());
@@ -105,7 +105,7 @@ FunctionIR ProtobufTextFormatToIRReader::FunctionProtobufToIR(
   return function_ir;
 }
 
-FunctionTypeIR ProtobufTextFormatToIRReader::FunctionTypeProtobufToIR(
+FunctionTypeIR ProtobufIRReader::FunctionTypeProtobufToIR(
     const abi_dump::FunctionType &function_type_protobuf) {
   FunctionTypeIR function_type_ir;
   ReadTypeInfo(function_type_protobuf.type_info(), &function_type_ir);
@@ -113,7 +113,7 @@ FunctionTypeIR ProtobufTextFormatToIRReader::FunctionTypeProtobufToIR(
   return function_type_ir;
 }
 
-VTableLayoutIR ProtobufTextFormatToIRReader::VTableLayoutProtobufToIR(
+VTableLayoutIR ProtobufIRReader::VTableLayoutProtobufToIR(
     const abi_dump::VTableLayout &vtable_layout_protobuf) {
   VTableLayoutIR vtable_layout_ir;
   for (auto &&vtable_component : vtable_layout_protobuf.vtable_components()) {
@@ -127,8 +127,7 @@ VTableLayoutIR ProtobufTextFormatToIRReader::VTableLayoutProtobufToIR(
   return vtable_layout_ir;
 }
 
-std::vector<RecordFieldIR>
-ProtobufTextFormatToIRReader::RecordFieldsProtobufToIR(
+std::vector<RecordFieldIR> ProtobufIRReader::RecordFieldsProtobufToIR(
     const google::protobuf::RepeatedPtrField<abi_dump::RecordFieldDecl> &rfp) {
   std::vector<RecordFieldIR> record_type_fields_ir;
   for (auto &&field : rfp) {
@@ -141,7 +140,7 @@ ProtobufTextFormatToIRReader::RecordFieldsProtobufToIR(
 }
 
 std::vector<CXXBaseSpecifierIR>
-ProtobufTextFormatToIRReader::RecordCXXBaseSpecifiersProtobufToIR(
+ProtobufIRReader::RecordCXXBaseSpecifiersProtobufToIR(
     const google::protobuf::RepeatedPtrField<abi_dump::CXXBaseSpecifier> &rbs) {
   std::vector<CXXBaseSpecifierIR> record_type_bases_ir;
   for (auto &&base : rbs) {
@@ -153,7 +152,7 @@ ProtobufTextFormatToIRReader::RecordCXXBaseSpecifiersProtobufToIR(
   return record_type_bases_ir;
 }
 
-RecordTypeIR ProtobufTextFormatToIRReader::RecordTypeProtobufToIR(
+RecordTypeIR ProtobufIRReader::RecordTypeProtobufToIR(
     const abi_dump::RecordType &record_type_protobuf) {
   RecordTypeIR record_type_ir;
   ReadTypeInfo(record_type_protobuf.type_info(), &record_type_ir);
@@ -175,8 +174,7 @@ RecordTypeIR ProtobufTextFormatToIRReader::RecordTypeProtobufToIR(
   return record_type_ir;
 }
 
-std::vector<EnumFieldIR>
-ProtobufTextFormatToIRReader::EnumFieldsProtobufToIR(
+std::vector<EnumFieldIR> ProtobufIRReader::EnumFieldsProtobufToIR(
     const google::protobuf::RepeatedPtrField<abi_dump::EnumFieldDecl> &efp) {
   std::vector<EnumFieldIR> enum_type_fields_ir;
   for (auto &&field : efp) {
@@ -186,7 +184,7 @@ ProtobufTextFormatToIRReader::EnumFieldsProtobufToIR(
   return enum_type_fields_ir;
 }
 
-EnumTypeIR ProtobufTextFormatToIRReader::EnumTypeProtobufToIR(
+EnumTypeIR ProtobufIRReader::EnumTypeProtobufToIR(
     const abi_dump::EnumType &enum_type_protobuf) {
   EnumTypeIR enum_type_ir;
   ReadTypeInfo(enum_type_protobuf.type_info(), &enum_type_ir);
@@ -198,7 +196,7 @@ EnumTypeIR ProtobufTextFormatToIRReader::EnumTypeProtobufToIR(
   return enum_type_ir;
 }
 
-void ProtobufTextFormatToIRReader::ReadGlobalVariables(
+void ProtobufIRReader::ReadGlobalVariables(
     const abi_dump::TranslationUnit &tu) {
   for (auto &&global_variable_protobuf : tu.global_vars()) {
     GlobalVarIR global_variable_ir;
@@ -217,8 +215,7 @@ void ProtobufTextFormatToIRReader::ReadGlobalVariables(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadPointerTypes(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadPointerTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&pointer_type_protobuf : tu.pointer_types()) {
     PointerTypeIR pointer_type_ir;
     ReadTypeInfo(pointer_type_protobuf.type_info(), &pointer_type_ir);
@@ -230,8 +227,7 @@ void ProtobufTextFormatToIRReader::ReadPointerTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadBuiltinTypes(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadBuiltinTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&builtin_type_protobuf : tu.builtin_types()) {
     BuiltinTypeIR builtin_type_ir;
     ReadTypeInfo(builtin_type_protobuf.type_info(), &builtin_type_ir);
@@ -242,8 +238,7 @@ void ProtobufTextFormatToIRReader::ReadBuiltinTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadQualifiedTypes(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadQualifiedTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&qualified_type_protobuf : tu.qualified_types()) {
     QualifiedTypeIR qualified_type_ir;
     ReadTypeInfo(qualified_type_protobuf.type_info(), &qualified_type_ir);
@@ -259,8 +254,7 @@ void ProtobufTextFormatToIRReader::ReadQualifiedTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadArrayTypes(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadArrayTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&array_type_protobuf : tu.array_types()) {
     ArrayTypeIR array_type_ir;
     ReadTypeInfo(array_type_protobuf.type_info(), &array_type_ir);
@@ -272,7 +266,7 @@ void ProtobufTextFormatToIRReader::ReadArrayTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadLvalueReferenceTypes(
+void ProtobufIRReader::ReadLvalueReferenceTypes(
     const abi_dump::TranslationUnit &tu) {
   for (auto &&lvalue_reference_type_protobuf : tu.lvalue_reference_types()) {
     LvalueReferenceTypeIR lvalue_reference_type_ir;
@@ -287,7 +281,7 @@ void ProtobufTextFormatToIRReader::ReadLvalueReferenceTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadRvalueReferenceTypes(
+void ProtobufIRReader::ReadRvalueReferenceTypes(
     const abi_dump::TranslationUnit &tu) {
   for (auto &&rvalue_reference_type_protobuf : tu.rvalue_reference_types()) {
     RvalueReferenceTypeIR rvalue_reference_type_ir;
@@ -302,8 +296,7 @@ void ProtobufTextFormatToIRReader::ReadRvalueReferenceTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadFunctions(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadFunctions(const abi_dump::TranslationUnit &tu) {
   for (auto &&function_protobuf : tu.functions()) {
     FunctionIR function_ir = FunctionProtobufToIR(function_protobuf);
     if (!IsLinkableMessageInExportedHeaders(&function_ir)) {
@@ -314,8 +307,7 @@ void ProtobufTextFormatToIRReader::ReadFunctions(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadRecordTypes(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadRecordTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&record_type_protobuf : tu.record_types()) {
     RecordTypeIR record_type_ir = RecordTypeProtobufToIR(record_type_protobuf);
     if (!IsLinkableMessageInExportedHeaders(&record_type_ir)) {
@@ -329,8 +321,7 @@ void ProtobufTextFormatToIRReader::ReadRecordTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadFunctionTypes(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadFunctionTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&function_type_protobuf : tu.function_types()) {
     FunctionTypeIR function_type_ir =
         FunctionTypeProtobufToIR(function_type_protobuf);
@@ -345,8 +336,7 @@ void ProtobufTextFormatToIRReader::ReadFunctionTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadEnumTypes(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadEnumTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&enum_type_protobuf : tu.enum_types()) {
     EnumTypeIR enum_type_ir = EnumTypeProtobufToIR(enum_type_protobuf);
     if (!IsLinkableMessageInExportedHeaders(&enum_type_ir)) {
@@ -360,8 +350,7 @@ void ProtobufTextFormatToIRReader::ReadEnumTypes(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadElfFunctions(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadElfFunctions(const abi_dump::TranslationUnit &tu) {
   for (auto &&elf_function : tu.elf_functions()) {
     ElfFunctionIR elf_function_ir(
         elf_function.name(),
@@ -371,8 +360,7 @@ void ProtobufTextFormatToIRReader::ReadElfFunctions(
   }
 }
 
-void ProtobufTextFormatToIRReader::ReadElfObjects(
-    const abi_dump::TranslationUnit &tu) {
+void ProtobufIRReader::ReadElfObjects(const abi_dump::TranslationUnit &tu) {
   for (auto &&elf_object : tu.elf_objects()) {
     ElfObjectIR elf_object_ir(
         elf_object.name(), ElfSymbolBindingProtobufToIR(elf_object.binding()));
diff --git a/vndk/tools/header-checker/src/repr/protobuf/ir_reader.h b/vndk/tools/header-checker/src/repr/protobuf/ir_reader.h
index 15ade4cc5..c943e685a 100644
--- a/vndk/tools/header-checker/src/repr/protobuf/ir_reader.h
+++ b/vndk/tools/header-checker/src/repr/protobuf/ir_reader.h
@@ -31,15 +31,15 @@ namespace header_checker {
 namespace repr {
 
 
-class ProtobufTextFormatToIRReader : public TextFormatToIRReader {
+class ProtobufIRReader : public IRReader {
  private:
   template <typename T>
   using RepeatedPtrField = google::protobuf::RepeatedPtrField<T>;
 
 
  public:
-  ProtobufTextFormatToIRReader(const std::set<std::string> *exported_headers)
-      : TextFormatToIRReader(exported_headers) {}
+  ProtobufIRReader(const std::set<std::string> *exported_headers)
+      : IRReader(exported_headers) {}
 
 
   bool ReadDump(const std::string &dump_file) override;