Revert^2 "ART: Refactor typedef to using"

This reverts commit ee07743.

Reason for revert: fixed attributes.

Bug: 32619234
Test: m test-art-host
Test: m test-art-target-gtest-unstarted_runtime_test
Change-Id: I6f0a775adfdf6ecd132b470f7c5446e949872e20

build/Android.bp

@@ -23,6 +23,7 @@ art_clang_tidy_errors = [
     "bugprone-virtual-near-miss",
     "modernize-use-bool-literals",
     "modernize-use-nullptr",
+    "modernize-use-using",
     "performance-faster-string-find",
     "performance-for-range-copy",
     "performance-implicit-conversion-in-loop",
@@ -37,6 +38,7 @@ art_clang_tidy_errors_str = "bugprone-lambda-function-name"
         + ",modernize-redundant-void-arg"
         + ",modernize-use-bool-literals"
         + ",modernize-use-nullptr"
+        + ",modernize-use-using"
         + ",performance-faster-string-find"
         + ",performance-for-range-copy"
         + ",performance-implicit-conversion-in-loop"

compiler/dex/inline_method_analyser.cc

@@ -41,7 +41,7 @@ namespace {  // anonymous namespace
 class Matcher {
  public:
   // Match function type.
-  typedef bool MatchFn(Matcher* matcher);
+  using MatchFn = bool(Matcher*);
 
   template <size_t size>
   static bool Match(const CodeItemDataAccessor* code_item, MatchFn* const (&pattern)[size]);

compiler/optimizing/code_generator_x86.cc

@@ -8301,7 +8301,7 @@ void CodeGeneratorX86::PatchJitRootUse(uint8_t* code,
   uint32_t code_offset = info.label.Position() - kLabelPositionToLiteralOffsetAdjustment;
   uintptr_t address =
       reinterpret_cast<uintptr_t>(roots_data) + index_in_table * sizeof(GcRoot<mirror::Object>);
-  typedef __attribute__((__aligned__(1))) uint32_t unaligned_uint32_t;
+  using unaligned_uint32_t __attribute__((__aligned__(1))) = uint32_t;
   reinterpret_cast<unaligned_uint32_t*>(code + code_offset)[0] =
      dchecked_integral_cast<uint32_t>(address);
 }

compiler/optimizing/code_generator_x86_64.cc

@@ -7542,7 +7542,7 @@ void CodeGeneratorX86_64::PatchJitRootUse(uint8_t* code,
   uint32_t code_offset = info.label.Position() - kLabelPositionToLiteralOffsetAdjustment;
   uintptr_t address =
       reinterpret_cast<uintptr_t>(roots_data) + index_in_table * sizeof(GcRoot<mirror::Object>);
-  typedef __attribute__((__aligned__(1))) uint32_t unaligned_uint32_t;
+  using unaligned_uint32_t __attribute__((__aligned__(1))) = uint32_t;
   reinterpret_cast<unaligned_uint32_t*>(code + code_offset)[0] =
      dchecked_integral_cast<uint32_t>(address);
 }

compiler/optimizing/graph_visualizer.cc

@@ -106,8 +106,7 @@ std::ostream& operator<<(std::ostream& os, const StringList& list) {
   }
 }
 
-typedef Disassembler* create_disasm_prototype(InstructionSet instruction_set,
-                                              DisassemblerOptions* options);
+using create_disasm_prototype = Disassembler*(InstructionSet, DisassemblerOptions*);
 class HGraphVisualizerDisassembler {
  public:
   HGraphVisualizerDisassembler(InstructionSet instruction_set,

compiler/optimizing/parallel_move_test.cc

@@ -174,8 +174,8 @@ class ParallelMoveTest : public ::testing::Test {
 template<> const bool ParallelMoveTest<TestParallelMoveResolverWithSwap>::has_swap = true;
 template<> const bool ParallelMoveTest<TestParallelMoveResolverNoSwap>::has_swap = false;
 
-typedef ::testing::Types<TestParallelMoveResolverWithSwap, TestParallelMoveResolverNoSwap>
-    ParallelMoveResolverTestTypes;
+using ParallelMoveResolverTestTypes =
+    ::testing::Types<TestParallelMoveResolverWithSwap, TestParallelMoveResolverNoSwap>;
 
 TYPED_TEST_CASE(ParallelMoveTest, ParallelMoveResolverTestTypes);
 

compiler/utils/mips/assembler_mips.cc

@@ -179,7 +179,7 @@ void MipsAssembler::PatchCFI(size_t number_of_delayed_adjust_pcs) {
     return;
   }
 
-  typedef DebugFrameOpCodeWriterForAssembler::DelayedAdvancePC DelayedAdvancePC;
+  using DelayedAdvancePC = DebugFrameOpCodeWriterForAssembler::DelayedAdvancePC;
   const auto data = cfi().ReleaseStreamAndPrepareForDelayedAdvancePC();
   const std::vector<uint8_t>& old_stream = data.first;
   const std::vector<DelayedAdvancePC>& advances = data.second;

compiler/utils/mips/assembler_mips32r5_test.cc

@@ -38,12 +38,12 @@ class AssemblerMIPS32r5Test : public AssemblerTest<mips::MipsAssembler,
                                                    uint32_t,
                                                    mips::VectorRegister> {
  public:
-  typedef AssemblerTest<mips::MipsAssembler,
-                        mips::MipsLabel,
-                        mips::Register,
-                        mips::FRegister,
-                        uint32_t,
-                        mips::VectorRegister> Base;
+  using Base = AssemblerTest<mips::MipsAssembler,
+                             mips::MipsLabel,
+                             mips::Register,
+                             mips::FRegister,
+                             uint32_t,
+                             mips::VectorRegister>;
 
   // These tests were taking too long, so we hide the DriverStr() from AssemblerTest<>
   // and reimplement it without the verification against `assembly_string`. b/73903608

compiler/utils/mips/assembler_mips32r6_test.cc

@@ -38,12 +38,12 @@ class AssemblerMIPS32r6Test : public AssemblerTest<mips::MipsAssembler,
                                                    uint32_t,
                                                    mips::VectorRegister> {
  public:
-  typedef AssemblerTest<mips::MipsAssembler,
-                        mips::MipsLabel,
-                        mips::Register,
-                        mips::FRegister,
-                        uint32_t,
-                        mips::VectorRegister> Base;
+  using Base = AssemblerTest<mips::MipsAssembler,
+                             mips::MipsLabel,
+                             mips::Register,
+                             mips::FRegister,
+                             uint32_t,
+                             mips::VectorRegister>;
 
   // These tests were taking too long, so we hide the DriverStr() from AssemblerTest<>
   // and reimplement it without the verification against `assembly_string`. b/73903608

compiler/utils/mips/assembler_mips_test.cc

@@ -37,11 +37,11 @@ class AssemblerMIPSTest : public AssemblerTest<mips::MipsAssembler,
                                                mips::FRegister,
                                                uint32_t> {
  public:
-  typedef AssemblerTest<mips::MipsAssembler,
-                        mips::MipsLabel,
-                        mips::Register,
-                        mips::FRegister,
-                        uint32_t> Base;
+  using Base = AssemblerTest<mips::MipsAssembler,
+                             mips::MipsLabel,
+                             mips::Register,
+                             mips::FRegister,
+                             uint32_t>;
 
   // These tests were taking too long, so we hide the DriverStr() from AssemblerTest<>
   // and reimplement it without the verification against `assembly_string`. b/73903608

compiler/utils/mips64/assembler_mips64.cc

@@ -52,7 +52,7 @@ void Mips64Assembler::PatchCFI() {
     return;
   }
 
-  typedef DebugFrameOpCodeWriterForAssembler::DelayedAdvancePC DelayedAdvancePC;
+  using DelayedAdvancePC = DebugFrameOpCodeWriterForAssembler::DelayedAdvancePC;
   const auto data = cfi().ReleaseStreamAndPrepareForDelayedAdvancePC();
   const std::vector<uint8_t>& old_stream = data.first;
   const std::vector<DelayedAdvancePC>& advances = data.second;

compiler/utils/mips64/assembler_mips64_test.cc

@@ -41,12 +41,12 @@ class AssemblerMIPS64Test : public AssemblerTest<mips64::Mips64Assembler,
                                                  uint32_t,
                                                  mips64::VectorRegister> {
  public:
-  typedef AssemblerTest<mips64::Mips64Assembler,
-                        mips64::Mips64Label,
-                        mips64::GpuRegister,
-                        mips64::FpuRegister,
-                        uint32_t,
-                        mips64::VectorRegister> Base;
+  using Base = AssemblerTest<mips64::Mips64Assembler,
+                             mips64::Mips64Label,
+                             mips64::GpuRegister,
+                             mips64::FpuRegister,
+                             uint32_t,
+                             mips64::VectorRegister>;
 
   // These tests were taking too long, so we hide the DriverStr() from AssemblerTest<>
   // and reimplement it without the verification against `assembly_string`. b/73903608

compiler/utils/x86/assembler_x86_test.cc

@@ -44,11 +44,11 @@ class AssemblerX86Test : public AssemblerTest<x86::X86Assembler,
                                               x86::XmmRegister,
                                               x86::Immediate> {
  public:
-  typedef AssemblerTest<x86::X86Assembler,
-                        x86::Address,
-                        x86::Register,
-                        x86::XmmRegister,
-                        x86::Immediate> Base;
+  using Base = AssemblerTest<x86::X86Assembler,
+                             x86::Address,
+                             x86::Register,
+                             x86::XmmRegister,
+                             x86::Immediate>;
 
  protected:
   std::string GetArchitectureString() override {

compiler/utils/x86_64/assembler_x86_64_test.cc

@@ -137,11 +137,11 @@ class AssemblerX86_64Test : public AssemblerTest<x86_64::X86_64Assembler,
                                                  x86_64::XmmRegister,
                                                  x86_64::Immediate> {
  public:
-  typedef AssemblerTest<x86_64::X86_64Assembler,
-                        x86_64::Address,
-                        x86_64::CpuRegister,
-                        x86_64::XmmRegister,
-                        x86_64::Immediate> Base;
+  using Base = AssemblerTest<x86_64::X86_64Assembler,
+                             x86_64::Address,
+                             x86_64::CpuRegister,
+                             x86_64::XmmRegister,
+                             x86_64::Immediate>;
 
  protected:
   // Get the typically used name for this architecture, e.g., aarch64, x86-64, ...

dex2oat/linker/elf_writer_test.cc

@@ -164,7 +164,7 @@ TEST_F(ElfWriterTest, EncodeDecodeOatPatches) {
     // Patch manually.
     std::vector<uint8_t> expected = initial_data;
     for (uintptr_t location : patch_locations) {
-      typedef __attribute__((__aligned__(1))) uint32_t UnalignedAddress;
+      using UnalignedAddress __attribute__((__aligned__(1))) = uint32_t;
       *reinterpret_cast<UnalignedAddress*>(expected.data() + location) += delta;
     }
 

dex2oat/linker/oat_writer.cc

@@ -92,10 +92,10 @@ static constexpr bool kOatWriterForceOatCodeLayout = false;
 
 static constexpr bool kOatWriterDebugOatCodeLayout = false;
 
-typedef DexFile::Header __attribute__((aligned(1))) UnalignedDexFileHeader;
+using UnalignedDexFileHeader __attribute__((__aligned__(1))) = DexFile::Header;
 
 const UnalignedDexFileHeader* AsUnalignedDexFileHeader(const uint8_t* raw_data) {
-    return reinterpret_cast<const UnalignedDexFileHeader*>(raw_data);
+  return reinterpret_cast<const UnalignedDexFileHeader*>(raw_data);
 }
 
 class ChecksumUpdatingOutputStream : public OutputStream {

dex2oat/linker/x86/relative_patcher_x86_base.cc

@@ -50,7 +50,7 @@ void X86BaseRelativePatcher::PatchCall(std::vector<uint8_t>* code,
   uint32_t displacement = target_offset - patch_offset;
   displacement -= kPcDisplacement;  // The base PC is at the end of the 4-byte patch.
 
-  typedef __attribute__((__aligned__(1))) int32_t unaligned_int32_t;
+  using unaligned_int32_t __attribute__((__aligned__(1))) = int32_t;
   reinterpret_cast<unaligned_int32_t*>(&(*code)[literal_offset])[0] = displacement;
 }
 

dex2oat/linker/x86_64/relative_patcher_x86_64.cc

@@ -31,7 +31,7 @@ void X86_64RelativePatcher::PatchPcRelativeReference(std::vector<uint8_t>* code,
   uint32_t displacement = target_offset - patch_offset;
   displacement -= kPcDisplacement;  // The base PC is at the end of the 4-byte patch.
 
-  typedef __attribute__((__aligned__(1))) int32_t unaligned_int32_t;
+  using unaligned_int32_t __attribute__((__aligned__(1))) = int32_t;
   reinterpret_cast<unaligned_int32_t*>(&(*code)[patch.LiteralOffset()])[0] = displacement;
 }
 

dexdump/dexdump.cc

@@ -69,14 +69,14 @@ FILE* gOutFile = stdout;
 /*
  * Data types that match the definitions in the VM specification.
  */
-typedef uint8_t  u1;
-typedef uint16_t u2;
-typedef uint32_t u4;
-typedef uint64_t u8;
-typedef int8_t   s1;
-typedef int16_t  s2;
-typedef int32_t  s4;
-typedef int64_t  s8;
+using u1 = uint8_t;
+using u2 = uint16_t;
+using u4 = uint32_t;
+using u8 = uint64_t;
+using s1 = int8_t;
+using s2 = int16_t;
+using s4 = int32_t;
+using s8 = int64_t;
 
 /*
  * Basic information about a field or a method.

dexlist/dexlist.cc

@@ -55,9 +55,9 @@ static FILE* gOutFile = stdout;
 /*
  * Data types that match the definitions in the VM specification.
  */
-typedef uint8_t  u1;
-typedef uint32_t u4;
-typedef uint64_t u8;
+using u1 = uint8_t;
+using u4 = uint32_t;
+using u8 = uint64_t;
 
 /*
  * Returns a newly-allocated string for the "dot version" of the class

disassembler/disassembler_arm.cc

@@ -137,12 +137,12 @@ class DisassemblerArm::CustomDisassembler final : public PrintDisassembler {
 void DisassemblerArm::CustomDisassembler::CustomDisassemblerStream::PrintLiteral(LocationType type,
                                                                                  int32_t offset) {
   // Literal offsets are not required to be aligned, so we may need unaligned access.
-  typedef const int16_t unaligned_int16_t __attribute__ ((aligned (1)));
-  typedef const uint16_t unaligned_uint16_t __attribute__ ((aligned (1)));
-  typedef const int32_t unaligned_int32_t __attribute__ ((aligned (1)));
-  typedef const int64_t unaligned_int64_t __attribute__ ((aligned (1)));
-  typedef const float unaligned_float __attribute__ ((aligned (1)));
-  typedef const double unaligned_double __attribute__ ((aligned (1)));
+  using unaligned_int16_t  __attribute__((__aligned__(1))) = const int16_t;
+  using unaligned_uint16_t __attribute__((__aligned__(1))) = const uint16_t;
+  using unaligned_int32_t  __attribute__((__aligned__(1))) = const int32_t;
+  using unaligned_int64_t  __attribute__((__aligned__(1))) = const int64_t;
+  using unaligned_float    __attribute__((__aligned__(1))) = const float;
+  using unaligned_double   __attribute__((__aligned__(1))) = const double;
 
   // Zeros are used for the LocationType values this function does not care about.
   const size_t literal_size[kVst4Location + 1] = {

libdexfile/dex/dex_file_loader.cc

@@ -25,10 +25,6 @@
 #include "standard_dex_file.h"
 #include "ziparchive/zip_archive.h"
 
-// system/core/zip_archive definitions.
-struct ZipEntry;
-typedef void* ZipArchiveHandle;
-
 namespace art {
 
 namespace {

oatdump/oatdump.cc

@@ -419,7 +419,7 @@ class OatDumper {
     return instruction_set_;
   }
 
-  typedef std::vector<std::unique_ptr<const DexFile>> DexFileUniqV;
+  using DexFileUniqV = std::vector<std::unique_ptr<const DexFile>>;
 
   bool Dump(std::ostream& os) {
     bool success = true;
@@ -2480,7 +2480,7 @@ class ImageDumper {
       size_t bytes;
       size_t count;
     };
-    typedef SafeMap<std::string, SizeAndCount> SizeAndCountTable;
+    using SizeAndCountTable = SafeMap<std::string, SizeAndCount>;
     SizeAndCountTable sizes_and_counts;
 
     void Update(const char* descriptor, size_t object_bytes_in) {

runtime/base/mutex.cc

@@ -227,18 +227,15 @@ void BaseMutex::DumpAll(std::ostream& os) {
       // No mutexes have been created yet during at startup.
       return;
     }
-    typedef std::set<BaseMutex*>::const_iterator It;
     os << "(Contended)\n";
-    for (It it = all_mutexes->begin(); it != all_mutexes->end(); ++it) {
-      BaseMutex* mutex = *it;
+    for (const BaseMutex* mutex : *all_mutexes) {
       if (mutex->HasEverContended()) {
         mutex->Dump(os);
         os << "\n";
       }
     }
     os << "(Never contented)\n";
-    for (It it = all_mutexes->begin(); it != all_mutexes->end(); ++it) {
-      BaseMutex* mutex = *it;
+    for (const BaseMutex* mutex : *all_mutexes) {
       if (!mutex->HasEverContended()) {
         mutex->Dump(os);
         os << "\n";

runtime/class_linker.cc

@@ -307,7 +307,7 @@ struct FieldGapsComparator {
     return lhs.size < rhs.size || (lhs.size == rhs.size && lhs.start_offset > rhs.start_offset);
   }
 };
-typedef std::priority_queue<FieldGap, std::vector<FieldGap>, FieldGapsComparator> FieldGaps;
+using FieldGaps = std::priority_queue<FieldGap, std::vector<FieldGap>, FieldGapsComparator>;
 
 // Adds largest aligned gaps to queue of gaps.
 static void AddFieldGap(uint32_t gap_start, uint32_t gap_end, FieldGaps* gaps) {
@@ -2301,7 +2301,7 @@ ObjPtr<mirror::Class> ClassLinker::EnsureResolved(Thread* self,
   return klass;
 }
 
-typedef std::pair<const DexFile*, const DexFile::ClassDef*> ClassPathEntry;
+using ClassPathEntry = std::pair<const DexFile*, const DexFile::ClassDef*>;
 
 // Search a collection of DexFiles for a descriptor
 ClassPathEntry FindInClassPath(const char* descriptor,

runtime/elf_file.cc

@@ -1417,7 +1417,7 @@ template <typename ElfTypes>
 void ElfFileImpl<ElfTypes>::ApplyOatPatches(
     const uint8_t* patches, const uint8_t* patches_end, Elf_Addr delta,
     uint8_t* to_patch, const uint8_t* to_patch_end) {
-  typedef __attribute__((__aligned__(1))) Elf_Addr UnalignedAddress;
+  using UnalignedAddress __attribute__((__aligned__(1))) = Elf_Addr;
   while (patches < patches_end) {
     to_patch += DecodeUnsignedLeb128(&patches);
     DCHECK_LE(patches, patches_end) << "Unexpected end of patch list.";

runtime/hprof/hprof.cc

@@ -148,11 +148,11 @@ enum HprofBasicType {
   hprof_basic_long = 11,
 };
 
-typedef uint32_t HprofStringId;
-typedef uint32_t HprofClassObjectId;
-typedef uint32_t HprofClassSerialNumber;
-typedef uint32_t HprofStackTraceSerialNumber;
-typedef uint32_t HprofStackFrameId;
+using HprofStringId = uint32_t;
+using HprofClassObjectId = uint32_t;
+using HprofClassSerialNumber = uint32_t;
+using HprofStackTraceSerialNumber = uint32_t;
+using HprofStackFrameId = uint32_t;
 static constexpr HprofStackTraceSerialNumber kHprofNullStackTrace = 0;
 
 class EndianOutput {