Everywhere: Use east const in more places

These changes are compatible with clang-format 16 and will be mandatory
when we eventually bump clang-format version. So, since there are no
real downsides, let's commit them now.

AK/CheckedFormatString.h

@@ -28,7 +28,7 @@ struct Array {
     constexpr static size_t size() { return Size; }
     constexpr T const& operator[](size_t index) const { return __data[index]; }
     constexpr T& operator[](size_t index) { return __data[index]; }
-    using ConstIterator = SimpleIterator<const Array, T const>;
+    using ConstIterator = SimpleIterator<Array const, T const>;
     using Iterator = SimpleIterator<Array, T>;
 
     constexpr ConstIterator begin() const { return ConstIterator::begin(*this); }

AK/CircularQueue.h

@@ -80,7 +80,7 @@ public:
 
     private:
         friend class CircularQueue;
-        ConstIterator(CircularQueue const& queue, const size_t index)
+        ConstIterator(CircularQueue const& queue, size_t const index)
             : m_queue(queue)
             , m_index(index)
         {

AK/Complex.h

@@ -105,7 +105,7 @@ public:
     template<AK::Concepts::Arithmetic U>
     constexpr Complex<T> operator*=(Complex<U> const& x)
     {
-        const T real = m_real;
+        T const real = m_real;
         m_real = real * x.real() - m_imag * x.imag();
         m_imag = real * x.imag() + m_imag * x.real();
         return *this;
@@ -122,8 +122,8 @@ public:
     template<AK::Concepts::Arithmetic U>
     constexpr Complex<T> operator/=(Complex<U> const& x)
     {
-        const T real = m_real;
-        const T divisor = x.real() * x.real() + x.imag() * x.imag();
+        T const real = m_real;
+        T const divisor = x.real() * x.real() + x.imag() * x.imag();
         m_real = (real * x.real() + m_imag * x.imag()) / divisor;
         m_imag = (m_imag * x.real() - x.real() * x.imag()) / divisor;
         return *this;

AK/DoublyLinkedList.h

@@ -158,7 +158,7 @@ public:
     Iterator begin() { return Iterator(m_head); }
     Iterator end() { return Iterator::universal_end(); }
 
-    using ConstIterator = DoublyLinkedListIterator<const DoublyLinkedList, T const>;
+    using ConstIterator = DoublyLinkedListIterator<DoublyLinkedList const, T const>;
     friend ConstIterator;
     ConstIterator begin() const { return ConstIterator(m_head); }
     ConstIterator end() const { return ConstIterator::universal_end(); }

AK/FloatingPoint.h

@@ -95,9 +95,9 @@ static_assert(AssertSize<FloatExtractor<f32>, sizeof(f32)>());
 template<size_t S, size_t E, size_t M>
 requires(S <= 1 && E >= 1 && M >= 1 && (S + E + M) <= 64) class FloatingPointBits final {
 public:
-    static const size_t signbit = S;
-    static const size_t exponentbits = E;
-    static const size_t mantissabits = M;
+    static size_t const signbit = S;
+    static size_t const exponentbits = E;
+    static size_t const mantissabits = M;
 
     template<typename T>
     requires(IsIntegral<T> && IsUnsigned<T> && sizeof(T) <= 8) constexpr FloatingPointBits(T bits)

AK/HashTable.h

@@ -280,8 +280,8 @@ public:
     }
 
     using ConstIterator = Conditional<IsOrdered,
-        OrderedHashTableIterator<const HashTable, const T, BucketType const>,
-        HashTableIterator<const HashTable, const T, BucketType const>>;
+        OrderedHashTableIterator<HashTable const, T const, BucketType const>,
+        HashTableIterator<HashTable const, T const, BucketType const>>;
 
     [[nodiscard]] ConstIterator begin() const
     {

AK/Hex.cpp

@@ -35,7 +35,7 @@ ErrorOr<ByteBuffer> decode_hex(StringView input)
 }
 
 #ifdef KERNEL
-ErrorOr<NonnullOwnPtr<Kernel::KString>> encode_hex(const ReadonlyBytes input)
+ErrorOr<NonnullOwnPtr<Kernel::KString>> encode_hex(ReadonlyBytes const input)
 {
     StringBuilder output(input.size() * 2);
 
@@ -45,7 +45,7 @@ ErrorOr<NonnullOwnPtr<Kernel::KString>> encode_hex(const ReadonlyBytes input)
     return Kernel::KString::try_create(output.string_view());
 }
 #else
-ByteString encode_hex(const ReadonlyBytes input)
+ByteString encode_hex(ReadonlyBytes const input)
 {
     StringBuilder output(input.size() * 2);
 

AK/IPv4Address.h

@@ -41,7 +41,7 @@ public:
         m_data = (d << 24) | (c << 16) | (b << 8) | a;
     }
 
-    constexpr IPv4Address(const u8 data[4])
+    constexpr IPv4Address(u8 const data[4])
     {
         m_data = (u32(data[3]) << 24) | (u32(data[2]) << 16) | (u32(data[1]) << 8) | u32(data[0]);
     }
@@ -149,7 +149,7 @@ public:
     }
 
 private:
-    constexpr u32 octet(const SubnetClass subnet) const
+    constexpr u32 octet(SubnetClass const subnet) const
     {
         constexpr auto bits_per_byte = 8;
         auto const bits_to_shift = bits_per_byte * int(subnet);

AK/Random.cpp

@@ -17,7 +17,7 @@ u32 get_random_uniform(u32 max_bounds)
     // `arc4random() % max_bounds` would be insufficient. Here we compute the last number of the
     // last "full group". Note that if max_bounds is a divisor of UINT32_MAX,
     // then we end up with UINT32_MAX:
-    const u32 max_usable = UINT32_MAX - (static_cast<u64>(UINT32_MAX) + 1) % max_bounds;
+    u32 const max_usable = UINT32_MAX - (static_cast<u64>(UINT32_MAX) + 1) % max_bounds;
     auto random_value = get_random<u32>();
     for (int i = 0; i < 20 && random_value > max_usable; ++i) {
         // By chance we picked a value from the incomplete group. Note that this group has size at
@@ -34,7 +34,7 @@ u64 get_random_uniform_64(u64 max_bounds)
 {
     // Uses the same algorithm as `get_random_uniform`,
     // by replacing u64 with u128 and u32 with u64.
-    const u64 max_usable = UINT64_MAX - static_cast<u64>((static_cast<u128>(UINT64_MAX) + 1) % max_bounds);
+    u64 const max_usable = UINT64_MAX - static_cast<u64>((static_cast<u128>(UINT64_MAX) + 1) % max_bounds);
     auto random_value = get_random<u64>();
     for (int i = 0; i < 20 && random_value > max_usable; ++i) {
         random_value = get_random<u64>();

AK/RedBlackTree.h

@@ -505,7 +505,7 @@ public:
     Iterator end() { return {}; }
     Iterator begin_from(K key) { return Iterator(static_cast<Node*>(BaseTree::find(this->m_root, key))); }
 
-    using ConstIterator = RedBlackTreeIterator<const RedBlackTree, V const>;
+    using ConstIterator = RedBlackTreeIterator<RedBlackTree const, V const>;
     friend ConstIterator;
     ConstIterator begin() const { return ConstIterator(static_cast<Node*>(this->m_minimum)); }
     ConstIterator end() const { return {}; }

AK/SinglyLinkedList.h

@@ -205,7 +205,7 @@ public:
     Iterator begin() { return Iterator(m_head); }
     Iterator end() { return {}; }
 
-    using ConstIterator = SinglyLinkedListIterator<const SinglyLinkedList, T const>;
+    using ConstIterator = SinglyLinkedListIterator<SinglyLinkedList const, T const>;
     friend ConstIterator;
     ConstIterator begin() const { return ConstIterator(m_head); }
     ConstIterator end() const { return {}; }

AK/Trie.h

@@ -183,13 +183,13 @@ public:
         TRY(state.try_empend(false, m_children.begin(), m_children.end()));
 
         auto invoke = [&](auto& current_node) -> ErrorOr<IterationDecision> {
-            if constexpr (VoidFunction<Fn, const BaseType&>) {
-                callback(static_cast<const BaseType&>(current_node));
+            if constexpr (VoidFunction<Fn, BaseType const&>) {
+                callback(static_cast<BaseType const&>(current_node));
                 return IterationDecision::Continue;
-            } else if constexpr (IsSpecializationOf<decltype(callback(declval<const BaseType&>())), ErrorOr>) {
-                return callback(static_cast<const BaseType&>(current_node));
-            } else if constexpr (IteratorFunction<Fn, const BaseType&>) {
-                return callback(static_cast<const BaseType&>(current_node));
+            } else if constexpr (IsSpecializationOf<decltype(callback(declval<BaseType const&>())), ErrorOr>) {
+                return callback(static_cast<BaseType const&>(current_node));
+            } else if constexpr (IteratorFunction<Fn, BaseType const&>) {
+                return callback(static_cast<BaseType const&>(current_node));
             } else {
                 static_assert(DependentFalse<Fn>, "Invalid iterator function type signature");
             }

AK/Types.h

@@ -180,12 +180,12 @@ static_assert(explode_byte(0x80) == static_cast<FlatPtr>(0x8080808080808080ull))
 static_assert(explode_byte(0x7f) == static_cast<FlatPtr>(0x7f7f7f7f7f7f7f7full));
 static_assert(explode_byte(0) == 0);
 
-constexpr size_t align_up_to(const size_t value, const size_t alignment)
+constexpr size_t align_up_to(size_t const value, size_t const alignment)
 {
     return (value + (alignment - 1)) & ~(alignment - 1);
 }
 
-constexpr size_t align_down_to(const size_t value, const size_t alignment)
+constexpr size_t align_down_to(size_t const value, size_t const alignment)
 {
     return value & ~(alignment - 1);
 }

AK/UFixedBigInt.h

@@ -108,7 +108,7 @@ public:
     }
 
     template<UFixedInt T, size_t n>
-    requires((assumed_bit_size<T> * n) <= bit_size) constexpr UFixedBigInt(const T (&value)[n])
+    requires((assumed_bit_size<T> * n) <= bit_size) constexpr UFixedBigInt(T const (&value)[n])
     {
         size_t offset = 0;
 

AK/kmalloc.cpp

@@ -63,7 +63,7 @@ void operator delete[](void* ptr, size_t) noexcept
 // This is usually provided by libstdc++ in most cases, and the kernel has its own definition in
 // Kernel/Heap/kmalloc.cpp. If neither of those apply, the following should suffice to not fail during linking.
 namespace AK_REPLACED_STD_NAMESPACE {
-const nothrow_t nothrow;
+nothrow_t const nothrow;
 }
 
 #endif

Kernel/API/TimePage.h

@@ -22,9 +22,9 @@ inline bool time_page_supports(clockid_t clock_id)
 }
 
 struct TimePage {
-    volatile u32 update1;
+    u32 volatile update1;
     struct timespec clocks[CLOCK_ID_COUNT];
-    volatile u32 update2;
+    u32 volatile update2;
 };
 
 }

Kernel/API/kcov.h

@@ -8,5 +8,5 @@
 
 #include <AK/Types.h>
 
-typedef volatile u64 kcov_pc_t;
+typedef u64 volatile kcov_pc_t;
 #define KCOV_ENTRY_SIZE sizeof(kcov_pc_t)

Kernel/API/ttydefaultschars.h

@@ -18,7 +18,7 @@
 extern "C" {
 #endif
 
-static const cc_t ttydefchars[NCCS] = {
+static cc_t const ttydefchars[NCCS] = {
     [VINTR] = CINTR,
     [VQUIT] = CQUIT,
     [VERASE] = CERASE,

Kernel/Arch/Processor.h

@@ -192,7 +192,7 @@ private:
     // FIXME: On aarch64, once there is code in place to differentiate IRQs from synchronous exceptions (syscalls),
     //        this member should be incremented. Also this member shouldn't be a FlatPtr.
     FlatPtr m_in_irq { 0 };
-    volatile u32 m_in_critical;
+    u32 volatile m_in_critical;
     // NOTE: Since these variables are accessed with atomic magic on x86 (through GP with a single load instruction),
     //       they need to be FlatPtrs or everything becomes highly unsound and breaks. They are actually just booleans.
     FlatPtr m_in_scheduler;

Kernel/Arch/SmapDisabler.h

@@ -16,7 +16,7 @@ public:
     ~SmapDisabler();
 
 private:
-    const FlatPtr m_flags;
+    FlatPtr const m_flags;
 };
 
 }

Kernel/Arch/aarch64/RPi/Mailbox.cpp

@@ -76,7 +76,7 @@ static void wait_for_reply(MMIO& mmio)
 bool Mailbox::send_queue(void* queue, u32 queue_size) const
 {
     // According to Raspberry Pi specs this is the only channel implemented.
-    const u32 channel = ARM_TO_VIDEOCORE_CHANNEL;
+    u32 const channel = ARM_TO_VIDEOCORE_CHANNEL;
 
     auto message_header = reinterpret_cast<MessageHeader*>(queue);
     message_header->set_queue_size(queue_size);

Kernel/Arch/aarch64/RPi/MiniUART.cpp

@@ -105,7 +105,7 @@ ErrorOr<size_t> MiniUART::write(Kernel::OpenFileDescription& description, u64, K
         return EAGAIN;
 
     return buffer.read_buffered<128>(size, [&](ReadonlyBytes bytes) {
-        for (const auto& byte : bytes)
+        for (auto const& byte : bytes)
             put_char(byte);
         return bytes.size();
     });

Kernel/Arch/x86_64/InterruptManagement.h

@@ -34,10 +34,10 @@ public:
     u16 flags() const { return m_flags; }
 
 private:
-    const u8 m_bus;
-    const u8 m_source;
-    const u32 m_global_system_interrupt;
-    const u16 m_flags;
+    u8 const m_bus;
+    u8 const m_source;
+    u32 const m_global_system_interrupt;
+    u16 const m_flags;
 };
 
 class InterruptManagement {

Kernel/Arch/x86_64/Interrupts/IOAPIC.h

@@ -11,9 +11,9 @@
 
 namespace Kernel {
 struct [[gnu::packed]] ioapic_mmio_regs {
-    volatile u32 select;
+    u32 volatile select;
     u32 reserved[3];
-    volatile u32 window;
+    u32 volatile window;
 };
 
 class PCIInterruptOverrideMetadata {
@@ -28,13 +28,13 @@ public:
     u16 ioapic_interrupt_pin() const { return m_ioapic_interrupt_pin; }
 
 private:
-    const u8 m_bus_id;
-    const u8 m_polarity;
-    const u8 m_trigger_mode;
-    const u8 m_pci_interrupt_pin;
-    const u8 m_pci_device_number;
-    const u32 m_ioapic_id;
-    const u16 m_ioapic_interrupt_pin;
+    u8 const m_bus_id;
+    u8 const m_polarity;
+    u8 const m_trigger_mode;
+    u8 const m_pci_interrupt_pin;
+    u8 const m_pci_device_number;
+    u32 const m_ioapic_id;
+    u16 const m_ioapic_interrupt_pin;
 };
 
 class IOAPIC final : public IRQController {

Kernel/Arch/x86_64/Time/APICTimer.cpp

@@ -44,10 +44,10 @@ UNMAP_AFTER_INIT bool APICTimer::calibrate(HardwareTimerBase& calibration_source
         size_t ticks_in_100ms { 0 };
         Atomic<size_t, AK::memory_order_relaxed> calibration_ticks { 0 };
 #ifdef APIC_TIMER_MEASURE_CPU_CLOCK
-        volatile u64 start_tsc { 0 }, end_tsc { 0 };
+        u64 volatile start_tsc { 0 }, end_tsc { 0 };
 #endif
-        volatile u64 start_reference { 0 }, end_reference { 0 };
-        volatile u32 start_apic_count { 0 }, end_apic_count { 0 };
+        u64 volatile start_reference { 0 }, end_reference { 0 };
+        u32 volatile start_apic_count { 0 }, end_apic_count { 0 };
         bool query_reference { false };
     } state;
 

Kernel/Arch/x86_64/Time/HPET.cpp

@@ -46,26 +46,26 @@ enum class TimerConfiguration : u32 {
 
 struct [[gnu::packed]] HPETRegister {
     union {
-        volatile u64 full;
+        u64 volatile full;
         struct {
-            volatile u32 low;
-            volatile u32 high;
+            u32 volatile low;
+            u32 volatile high;
         };
     };
 };
 
 struct [[gnu::packed]] TimerStructure {
-    volatile u32 capabilities;
-    volatile u32 interrupt_routing;
+    u32 volatile capabilities;
+    u32 volatile interrupt_routing;
     HPETRegister comparator_value;
-    volatile u64 fsb_interrupt_route;
+    u64 volatile fsb_interrupt_route;
     u64 reserved;
 };
 
 struct [[gnu::packed]] HPETCapabilityRegister {
     // Note: We must do a 32 bit access to offsets 0x0, or 0x4 only, according to HPET spec.
-    volatile u32 attributes;
-    volatile u32 main_counter_tick_period;
+    u32 volatile attributes;
+    u32 volatile main_counter_tick_period;
     u64 reserved;
 };
 

Kernel/Bus/PCI/Definitions.h

@@ -337,9 +337,9 @@ public:
     void write32(size_t offset, u32 value) const;
 
 private:
-    const Address m_address;
-    const CapabilityID m_id;
-    const u8 m_ptr;
+    Address const m_address;
+    CapabilityID const m_id;
+    u8 const m_ptr;
 };
 
 AK_TYPEDEF_DISTINCT_ORDERED_ID(u8, ClassCode);

Kernel/Bus/USB/EHCI/Registers.h

@@ -202,21 +202,21 @@ struct OperationalRegisters {
     // 2.3.4 FRINDEX - Frame Index Register
     // Note: We use `volatile` to ensure 32 bit writes
     // Note: Only up to 14 bits are actually used, and the last 3 bits must never be `000` or `111`
-    volatile u32 frame_index;
+    u32 volatile frame_index;
 
     // 2.3.5 CTRLDSSEGMENT - Control Data Structure Segment Register
     // Note: We use `volatile` to ensure 32 bit writes
     // Note: Upper 32 bits of periodic-frame- and asynchronous-list pointers
-    volatile u32 segment_selector;
+    u32 volatile segment_selector;
 
     // 2.3.6 PERIODICLISTBASE - Periodic Frame List Base Address Register
     // Note: We use `volatile` to ensure 32 bit writes
     // Note: Page-aligned addresses only
-    volatile u32 frame_list_base_address;
+    u32 volatile frame_list_base_address;
     // 2.3.7 ASYNCLISTADDR - Current Asynchronous List Address Register
     // Note: We use `volatile` to ensure 32 bit writes
     // Note: 32 byte (cache-line) aligned addresses only
-    volatile u32 next_asynchronous_list_address;
+    u32 volatile next_asynchronous_list_address;
 
     u32 _padding[9];
 

Kernel/Bus/USB/UHCI/UHCIDescriptorTypes.h

@@ -241,7 +241,7 @@ struct alignas(16) TransferDescriptor final {
 
 private:
     u32 m_link_ptr;                // Points to another Queue Head or Transfer Descriptor
-    volatile u32 m_control_status; // Control and status field
+    u32 volatile m_control_status; // Control and status field
     u32 m_token;                   // Contains all information required to fill in a USB Start Token
     u32 m_buffer_ptr;              // Points to a data buffer for this transaction (i.e what we want to send or recv)
 
@@ -367,7 +367,7 @@ struct alignas(16) QueueHead {
 
 private:
     u32 m_link_ptr { 0 };                  // Pointer to the next horizontal object that the controller will execute after this one
-    volatile u32 m_element_link_ptr { 0 }; // Pointer to the first data object in the queue (can be modified by hw)
+    u32 volatile m_element_link_ptr { 0 }; // Pointer to the first data object in the queue (can be modified by hw)
 
     // This structure pointer will be ignored by the controller, but we can use it for configuration and bookkeeping
     QueueHeadBookkeeping* m_bookkeeping { nullptr };

Kernel/Bus/VirtIO/Queue.h

@@ -87,8 +87,8 @@ private:
         QueueDeviceItem rings[];
     };
 
-    const u16 m_queue_size;
-    const u16 m_notify_offset;
+    u16 const m_queue_size;
+    u16 const m_notify_offset;
     u16 m_free_buffers;
     u16 m_free_head { 0 };
     u16 m_used_tail { 0 };

Kernel/Devices/Audio/Channel.h

@@ -34,6 +34,6 @@ private:
     virtual StringView class_name() const override { return "AudioChannel"sv; }
 
     LockWeakPtr<AudioController> m_controller;
-    const size_t m_channel_index;
+    size_t const m_channel_index;
 };
 }

Kernel/Devices/BlockDevice.h

@@ -85,11 +85,11 @@ public:
 
 private:
     BlockDevice& m_block_device;
-    const RequestType m_request_type;
-    const u64 m_block_index;
-    const u32 m_block_count;
+    RequestType const m_request_type;
+    u64 const m_block_index;
+    u32 const m_block_count;
     UserOrKernelBuffer m_buffer;
-    const size_t m_buffer_size;
+    size_t const m_buffer_size;
 };
 
 }

Kernel/Devices/GPU/Intel/DisplayConnectorGroup.h

@@ -86,11 +86,11 @@ private:
     Array<OwnPtr<IntelDisplayTranscoder>, 5> m_transcoders;
     Array<OwnPtr<IntelDisplayPlane>, 3> m_planes;
 
-    const MMIORegion m_mmio_first_region;
-    const MMIORegion m_mmio_second_region;
+    MMIORegion const m_mmio_first_region;
+    MMIORegion const m_mmio_second_region;
     MMIORegion const& m_assigned_mmio_registers_region;
 
-    const IntelGraphics::Generation m_generation;
+    IntelGraphics::Generation const m_generation;
     NonnullOwnPtr<Memory::Region> m_registers_region;
     NonnullOwnPtr<GMBusConnector> m_gmbus_connector;
 };

Kernel/Devices/GPU/Intel/Plane/G33DisplayPlane.h

@@ -21,6 +21,6 @@ public:
     virtual ErrorOr<void> enable(Badge<IntelDisplayConnectorGroup>) override;
 
 private:
-    explicit IntelG33DisplayPlane(Memory::TypedMapping<volatile IntelDisplayPlane::PlaneRegisters> plane_registers_mapping);
+    explicit IntelG33DisplayPlane(Memory::TypedMapping<IntelDisplayPlane::PlaneRegisters volatile> plane_registers_mapping);
 };
 }

Kernel/Devices/GPU/VirtIO/GraphicsAdapter.cpp

@@ -305,7 +305,7 @@ ErrorOr<void> VirtIOGraphicsAdapter::ensure_backing_storage(Graphics::VirtIOGPU:
 
     auto writer = create_scratchspace_writer();
     auto& request = writer.append_structure<Graphics::VirtIOGPU::Protocol::ResourceAttachBacking>();
-    const size_t header_block_size = sizeof(request) + num_mem_regions * sizeof(Graphics::VirtIOGPU::Protocol::MemoryEntry);
+    size_t const header_block_size = sizeof(request) + num_mem_regions * sizeof(Graphics::VirtIOGPU::Protocol::MemoryEntry);
 
     populate_virtio_gpu_request_header(request.header, Graphics::VirtIOGPU::Protocol::CommandType::VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING, 0);
     request.resource_id = resource_id.value();

Kernel/Devices/Generic/ConsoleDevice.cpp

@@ -50,7 +50,7 @@ ErrorOr<size_t> ConsoleDevice::write(OpenFileDescription&, u64, Kernel::UserOrKe
         return 0;
 
     return data.read_buffered<256>(size, [&](ReadonlyBytes readonly_bytes) {
-        for (const auto& byte : readonly_bytes)
+        for (auto const& byte : readonly_bytes)
             put_char(byte);
         return readonly_bytes.size();
     });

Kernel/Devices/SerialDevice.cpp

@@ -57,7 +57,7 @@ ErrorOr<size_t> SerialDevice::write(OpenFileDescription& description, u64, UserO
         return EAGAIN;
 
     return buffer.read_buffered<128>(size, [&](ReadonlyBytes bytes) {
-        for (const auto& byte : bytes)
+        for (auto const& byte : bytes)
             put_char(byte);
         return bytes.size();
     });

Kernel/Devices/Storage/ATA/AHCI/Definitions.h

@@ -197,7 +197,7 @@ public:
 
 private:
     u32 volatile& m_bitfield;
-    const u32 m_bit_mask;
+    u32 const m_bit_mask;
 };
 
 enum Limits : u16 {

Kernel/Devices/Storage/ATA/ATADevice.h

@@ -39,8 +39,8 @@ protected:
     ATADevice(ATAController const&, Address, u16, u16, u64);
 
     LockWeakPtr<ATAController> m_controller;
-    const Address m_ata_address;
-    const u16 m_capabilities;
+    Address const m_ata_address;
+    u16 const m_capabilities;
 };
 
 }

Kernel/Devices/Storage/ATA/ATAPort.h

@@ -148,7 +148,7 @@ protected:
     RefPtr<Memory::PhysicalPage> m_prdt_page;
     RefPtr<Memory::PhysicalPage> m_dma_buffer_page;
 
-    const u8 m_port_index;
+    u8 const m_port_index;
     Vector<NonnullLockRefPtr<ATADevice>> m_ata_devices;
     NonnullOwnPtr<KBuffer> m_ata_identify_data_buffer;
     NonnullLockRefPtr<ATAController> m_parent_ata_controller;

Kernel/Devices/Storage/SD/SDHostController.cpp

@@ -157,7 +157,7 @@ ErrorOr<NonnullLockRefPtr<SDMemoryCard>> SDHostController::try_initialize_insert
     // 2. Send CMD8 (SEND_IF_COND) to the card
     // SD interface condition: 7:0 = check pattern, 11:8 = supply voltage
     //      0x1aa: check pattern = 10101010, supply voltage = 1 => 2.7-3.6V
-    const u32 voltage_window = 0x1aa;
+    u32 const voltage_window = 0x1aa;
     TRY(issue_command(SD::Commands::send_if_cond, voltage_window));
     auto interface_condition_response = wait_for_response();
 
@@ -456,14 +456,14 @@ ErrorOr<void> SDHostController::sd_clock_supply(u32 frequency)
     VERIFY((m_registers->host_configuration_1 & sd_clock_enable) == 0);
 
     // 1. Find out the divisor to determine the SD Clock Frequency
-    const u32 sd_clock_frequency = TRY(retrieve_sd_clock_frequency());
+    u32 const sd_clock_frequency = TRY(retrieve_sd_clock_frequency());
     u32 divisor = TRY(calculate_sd_clock_divisor(sd_clock_frequency, frequency));
 
     // 2. Set Internal Clock Enable and SDCLK Frequency Select in the Clock Control register
-    const u32 eight_lower_bits_of_sdclk_frequency_select = (divisor & 0xff) << 8;
+    u32 const eight_lower_bits_of_sdclk_frequency_select = (divisor & 0xff) << 8;
     u32 sdclk_frequency_select = eight_lower_bits_of_sdclk_frequency_select;
     if (host_version() == SD::HostVersion::Version3) {
-        const u32 two_upper_bits_of_sdclk_frequency_select = (divisor >> 8 & 0x3) << 6;
+        u32 const two_upper_bits_of_sdclk_frequency_select = (divisor >> 8 & 0x3) << 6;
         sdclk_frequency_select |= two_upper_bits_of_sdclk_frequency_select;
     }
     m_registers->host_configuration_1 = (m_registers->host_configuration_1 & ~sd_clock_divisor_mask) | internal_clock_enable | sdclk_frequency_select;
@@ -958,7 +958,7 @@ ErrorOr<u32> SDHostController::retrieve_sd_clock_frequency()
         // If these bits are all 0, the Host System has to get information via another method
         TODO();
     }
-    const i64 one_mhz = 1'000'000;
+    i64 const one_mhz = 1'000'000;
     return { m_registers->capabilities.base_clock_frequency * one_mhz };
 }
 

Kernel/Devices/TTY/SlavePTY.cpp

@@ -67,7 +67,7 @@ void SlavePTY::echo(u8 ch)
 void SlavePTY::on_master_write(UserOrKernelBuffer const& buffer, size_t size)
 {
     auto result = buffer.read_buffered<128>(size, [&](ReadonlyBytes data) {
-        for (const auto& byte : data)
+        for (auto const& byte : data)
             emit(byte, false);
         return data.size();
     });

Kernel/Devices/TTY/TTY.cpp

@@ -89,7 +89,7 @@ ErrorOr<size_t> TTY::write(OpenFileDescription&, u64, UserOrKernelBuffer const&
     return buffer.read_buffered<num_chars>(size, [&](ReadonlyBytes bytes) -> ErrorOr<size_t> {
         u8 modified_data[num_chars * 2];
         size_t modified_data_size = 0;
-        for (const auto& byte : bytes) {
+        for (auto const& byte : bytes) {
             process_output(byte, [&modified_data, &modified_data_size](u8 out_ch) {
                 modified_data[modified_data_size++] = out_ch;
             });

Kernel/Devices/TTY/VirtualConsole.cpp

@@ -285,7 +285,7 @@ ErrorOr<size_t> VirtualConsole::on_tty_write(UserOrKernelBuffer const& data, siz
 {
     SpinlockLocker global_lock(ConsoleManagement::the().tty_write_lock());
     auto result = data.read_buffered<512>(size, [&](ReadonlyBytes buffer) {
-        for (const auto& byte : buffer)
+        for (auto const& byte : buffer)
             m_console_impl.on_input(byte);
         return buffer.size();
     });

Kernel/FileSystem/MountFile.cpp

@@ -54,7 +54,7 @@ ErrorOr<void> MountFile::ioctl(OpenFileDescription&, unsigned request, Userspace
             if ((mount_specific_data.value_type == MountSpecificFlag::ValueType::SignedInteger || mount_specific_data.value_type == MountSpecificFlag::ValueType::UnsignedInteger) && mount_specific_data.value_length != 8)
                 return EDOM;
 
-            Syscall::StringArgument user_key_string { reinterpret_cast<const char*>(mount_specific_data.key_string_addr), static_cast<size_t>(mount_specific_data.key_string_length) };
+            Syscall::StringArgument user_key_string { reinterpret_cast<char const*>(mount_specific_data.key_string_addr), static_cast<size_t>(mount_specific_data.key_string_length) };
             auto key_string = TRY(Process::get_syscall_name_string_fixed_buffer<MOUNT_SPECIFIC_FLAG_KEY_STRING_MAX_LENGTH>(user_key_string));
 
             if (mount_specific_data.value_type != MountSpecificFlag::ValueType::Boolean && mount_specific_data.value_length == 0)

Kernel/FileSystem/Plan9FS/FileSystem.h

@@ -69,7 +69,7 @@ private:
     struct ReceiveCompletion final : public AtomicRefCounted<ReceiveCompletion> {
         mutable Spinlock<LockRank::None> lock {};
         bool completed { false };
-        const u16 tag;
+        u16 const tag;
         OwnPtr<Plan9FSMessage> message;
         ErrorOr<void> result;
 

Kernel/FileSystem/SysFS/Subsystems/Kernel/DiskUsage.cpp

@@ -45,13 +45,13 @@ ErrorOr<void> SysFSDiskUsage::try_generate(KBufferBuilder& builder)
             TRY(fs_object.add("source"sv, "unknown"));
         } else {
             if (fs.is_file_backed()) {
-                auto& file = static_cast<const FileBackedFileSystem&>(fs).file();
+                auto& file = static_cast<FileBackedFileSystem const&>(fs).file();
                 if (file.is_loop_device()) {
                     auto& device = static_cast<LoopDevice const&>(file);
                     auto path = TRY(device.custody().try_serialize_absolute_path());
                     TRY(fs_object.add("source"sv, path->view()));
                 } else {
-                    auto pseudo_path = TRY(static_cast<const FileBackedFileSystem&>(fs).file_description().pseudo_path());
+                    auto pseudo_path = TRY(static_cast<FileBackedFileSystem const&>(fs).file_description().pseudo_path());
                     TRY(fs_object.add("source"sv, pseudo_path->view()));
                 }
             } else {

Kernel/FileSystem/SysFS/Subsystems/Kernel/Processes.cpp

@@ -114,7 +114,7 @@ ErrorOr<void> SysFSOverallProcesses::try_generate(KBufferBuilder& builder)
         TRY(process_object.add("dumpable"sv, process.is_dumpable()));
         TRY(process_object.add("kernel"sv, process.is_kernel_process()));
         auto thread_array = TRY(process_object.add_array("threads"sv));
-        TRY(process.try_for_each_thread([&](const Thread& thread) -> ErrorOr<void> {
+        TRY(process.try_for_each_thread([&](Thread const& thread) -> ErrorOr<void> {
             SpinlockLocker locker(thread.get_lock());
             auto thread_object = TRY(thread_array.add_object());
 #if LOCK_DEBUG

Kernel/Heap/kmalloc.cpp

@@ -33,7 +33,7 @@ static constexpr size_t KMALLOC_DEFAULT_ALIGNMENT = 16;
 __attribute__((section(".heap"))) static u8 initial_kmalloc_memory[INITIAL_KMALLOC_MEMORY_SIZE];
 
 namespace std {
-const nothrow_t nothrow;
+nothrow_t const nothrow;
 }
 
 // FIXME: Figure out whether this can be MemoryManager.

Kernel/Heap/kmalloc.h

@@ -38,7 +38,7 @@ struct nothrow_t {
     explicit nothrow_t() = default;
 };
 
-extern const nothrow_t nothrow;
+extern nothrow_t const nothrow;
 
 enum class align_val_t : size_t {};
 };

Kernel/Library/StdLib.cpp

@@ -213,7 +213,7 @@ ErrorOr<void> memset_user(void* dest_ptr, int c, size_t n)
 // See https://bugs.llvm.org/show_bug.cgi?id=39634
 FlatPtr missing_got_workaround()
 {
-    extern volatile FlatPtr _GLOBAL_OFFSET_TABLE_;
+    extern FlatPtr volatile _GLOBAL_OFFSET_TABLE_;
     return _GLOBAL_OFFSET_TABLE_;
 }
 #endif

Kernel/Net/IPv4Socket.cpp

@@ -624,7 +624,7 @@ ErrorOr<void> IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspac
         rtentry route;
         TRY(copy_from_user(&route, user_route));
 
-        Userspace<const char*> user_rt_dev((FlatPtr)route.rt_dev);
+        Userspace<char const*> user_rt_dev((FlatPtr)route.rt_dev);
         auto ifname = TRY(Process::get_syscall_name_string_fixed_buffer<IFNAMSIZ>(user_rt_dev));
         auto adapter = NetworkingManagement::the().lookup_by_name(ifname.representable_view());
         if (!adapter)

Kernel/Net/Intel/E1000NetworkAdapter.h

@@ -51,22 +51,22 @@ protected:
     virtual StringView class_name() const override { return "E1000NetworkAdapter"sv; }
 
     struct [[gnu::packed]] e1000_rx_desc {
-        volatile uint64_t addr { 0 };
-        volatile uint16_t length { 0 };
-        volatile uint16_t checksum { 0 };
-        volatile uint8_t status { 0 };
-        volatile uint8_t errors { 0 };
-        volatile uint16_t special { 0 };
+        uint64_t volatile addr { 0 };
+        uint16_t volatile length { 0 };
+        uint16_t volatile checksum { 0 };
+        uint8_t volatile status { 0 };
+        uint8_t volatile errors { 0 };
+        uint16_t volatile special { 0 };
     };
 
     struct [[gnu::packed]] e1000_tx_desc {
-        volatile uint64_t addr { 0 };
-        volatile uint16_t length { 0 };
-        volatile uint8_t cso { 0 };
-        volatile uint8_t cmd { 0 };
-        volatile uint8_t status { 0 };
-        volatile uint8_t css { 0 };
-        volatile uint16_t special { 0 };
+        uint64_t volatile addr { 0 };
+        uint16_t volatile length { 0 };
+        uint8_t volatile cso { 0 };
+        uint8_t volatile cmd { 0 };
+        uint8_t volatile status { 0 };
+        uint8_t volatile css { 0 };
+        uint16_t volatile special { 0 };
     };
 
     virtual void detect_eeprom();

Kernel/Net/NetworkTask.cpp

@@ -340,9 +340,9 @@ void send_tcp_rst(IPv4Packet const& ipv4_packet, TCPPacket const& tcp_packet, Re
 
     auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
 
-    const size_t options_size = 0;
-    const size_t tcp_header_size = sizeof(TCPPacket) + options_size;
-    const size_t buffer_size = ipv4_payload_offset + tcp_header_size;
+    size_t const options_size = 0;
+    size_t const tcp_header_size = sizeof(TCPPacket) + options_size;
+    size_t const buffer_size = ipv4_payload_offset + tcp_header_size;
 
     auto packet = routing_decision.adapter->acquire_packet_buffer(buffer_size);
     if (!packet)

Kernel/Net/Realtek/RTL8168NetworkAdapter.h

@@ -50,12 +50,12 @@ private:
     bool determine_supported_version() const;
 
     struct [[gnu::packed]] TXDescriptor {
-        volatile u16 frame_length; // top 2 bits are reserved
-        volatile u16 flags;
-        volatile u16 vlan_tag;
-        volatile u16 vlan_flags;
-        volatile u32 buffer_address_low;
-        volatile u32 buffer_address_high;
+        u16 volatile frame_length; // top 2 bits are reserved
+        u16 volatile flags;
+        u16 volatile vlan_tag;
+        u16 volatile vlan_flags;
+        u32 volatile buffer_address_low;
+        u32 volatile buffer_address_high;
 
         // flags bit field
         static constexpr u16 Ownership = 0x8000u;
@@ -68,12 +68,12 @@ private:
     static_assert(AssertSize<TXDescriptor, 16u>());
 
     struct [[gnu::packed]] RXDescriptor {
-        volatile u16 buffer_size; // top 2 bits are reserved
-        volatile u16 flags;
-        volatile u16 vlan_tag;
-        volatile u16 vlan_flags;
-        volatile u32 buffer_address_low;
-        volatile u32 buffer_address_high;
+        u16 volatile buffer_size; // top 2 bits are reserved
+        u16 volatile flags;
+        u16 volatile vlan_tag;
+        u16 volatile vlan_flags;
+        u32 volatile buffer_address_low;
+        u32 volatile buffer_address_high;
 
         // flags bit field
         static constexpr u16 Ownership = 0x8000u;

Kernel/Net/Routing.h

@@ -34,10 +34,10 @@ struct Route final : public AtomicRefCounted<Route> {
         return destination == other.destination && (gateway == other.gateway || other.gateway.is_zero()) && netmask == other.netmask && flags == other.flags && adapter.ptr() == other.adapter.ptr();
     }
 
-    const IPv4Address destination;
-    const IPv4Address gateway;
-    const IPv4Address netmask;
-    const u16 flags;
+    IPv4Address const destination;
+    IPv4Address const gateway;
+    IPv4Address const netmask;
+    u16 const flags;
     NonnullRefPtr<NetworkAdapter> const adapter;
 
     IntrusiveListNode<Route, RefPtr<Route>> route_list_node {};

Kernel/Net/TCPSocket.cpp

@@ -733,7 +733,7 @@ void TCPSocket::retransmit_packets()
             packet.tx_counter++;
 
             if constexpr (TCP_SOCKET_DEBUG) {
-                auto& tcp_packet = *(const TCPPacket*)(packet.buffer->buffer->data() + packet.ipv4_payload_offset);
+                auto& tcp_packet = *(TCPPacket const*)(packet.buffer->buffer->data() + packet.ipv4_payload_offset);
                 dbgln("Sending TCP packet from {}:{} to {}:{} with ({}{}{}{}) seq_no={}, ack_no={}, tx_counter={}",
                     local_address(), local_port(),
                     peer_address(), peer_port(),

Kernel/Net/UDPSocket.cpp

@@ -91,7 +91,7 @@ ErrorOr<size_t> UDPSocket::protocol_send(UserOrKernelBuffer const& data, size_t
         return set_so_error(EHOSTUNREACH);
     auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
     data_length = min(data_length, routing_decision.adapter->mtu() - ipv4_payload_offset - sizeof(UDPPacket));
-    const size_t udp_buffer_size = sizeof(UDPPacket) + data_length;
+    size_t const udp_buffer_size = sizeof(UDPPacket) + data_length;
     auto packet = routing_decision.adapter->acquire_packet_buffer(ipv4_payload_offset + udp_buffer_size);
     if (!packet)
         return set_so_error(ENOMEM);

Kernel/Prekernel/UBSanitizer.cpp

@@ -130,8 +130,8 @@ void __ubsan_handle_implicit_conversion(ImplicitConversionData const& data, Valu
     print_location(data.location);
 }
 
-void __ubsan_handle_invalid_builtin(const InvalidBuiltinData) __attribute__((used));
-void __ubsan_handle_invalid_builtin(const InvalidBuiltinData data)
+void __ubsan_handle_invalid_builtin(InvalidBuiltinData const) __attribute__((used));
+void __ubsan_handle_invalid_builtin(InvalidBuiltinData const data)
 {
     print_location(data.location);
 }

Kernel/Security/UBSanitizer.cpp

@@ -188,8 +188,8 @@ void __ubsan_handle_implicit_conversion(ImplicitConversionData const& data, Valu
     print_location(data.location);
 }
 
-void __ubsan_handle_invalid_builtin(const InvalidBuiltinData) __attribute__((used));
-void __ubsan_handle_invalid_builtin(const InvalidBuiltinData data)
+void __ubsan_handle_invalid_builtin(InvalidBuiltinData const) __attribute__((used));
+void __ubsan_handle_invalid_builtin(InvalidBuiltinData const data)
 {
     critical_dmesgln("KUBSAN: passing invalid argument");
     print_location(data.location);

Kernel/Syscalls/SyscallHandler.cpp

@@ -31,7 +31,7 @@ struct HandlerMetadata {
 };
 
 #define __ENUMERATE_SYSCALL(sys_call, needs_lock) { bit_cast<Handler>(&Process::sys$##sys_call), needs_lock },
-static const HandlerMetadata s_syscall_table[] = {
+static HandlerMetadata const s_syscall_table[] = {
     ENUMERATE_SYSCALLS(__ENUMERATE_SYSCALL)
 };
 #undef __ENUMERATE_SYSCALL

Kernel/Tasks/Thread.h

@@ -526,7 +526,7 @@ public:
 
     private:
         NonnullRefPtr<OpenFileDescription> m_blocked_description;
-        const BlockFlags m_flags;
+        BlockFlags const m_flags;
         BlockFlags& m_unblocked_flags;
         bool m_did_unblock { false };
     };

Userland/Applications/3DFileViewer/Mesh.cpp

@@ -13,7 +13,7 @@
 
 #include "Mesh.h"
 
-const Color colors[] {
+Color const colors[] {
     Color::Red,
     Color::Green,
     Color::Blue,
@@ -36,17 +36,17 @@ void Mesh::draw(float uv_scale)
     for (u32 i = 0; i < m_triangle_list.size(); i++) {
         auto const& triangle = m_triangle_list[i];
 
-        const FloatVector3 vertex_a(
+        FloatVector3 const vertex_a(
             m_vertex_list.at(triangle.a).x,
             m_vertex_list.at(triangle.a).y,
             m_vertex_list.at(triangle.a).z);
 
-        const FloatVector3 vertex_b(
+        FloatVector3 const vertex_b(
             m_vertex_list.at(triangle.b).x,
             m_vertex_list.at(triangle.b).y,
             m_vertex_list.at(triangle.b).z);
 
-        const FloatVector3 vertex_c(
+        FloatVector3 const vertex_c(
             m_vertex_list.at(triangle.c).x,
             m_vertex_list.at(triangle.c).y,
             m_vertex_list.at(triangle.c).z);
@@ -70,8 +70,8 @@ void Mesh::draw(float uv_scale)
 
         } else {
             // Compute the triangle normal
-            const FloatVector3 vec_ab = vertex_b - vertex_a;
-            const FloatVector3 vec_ac = vertex_c - vertex_a;
+            FloatVector3 const vec_ab = vertex_b - vertex_a;
+            FloatVector3 const vec_ac = vertex_c - vertex_a;
             normal_a = vec_ab.cross(vec_ac).normalized();
             normal_b = normal_a;
             normal_c = normal_a;

Userland/Applications/Calendar/CalendarWidget.cpp

@@ -299,7 +299,7 @@ ErrorOr<NonnullRefPtr<GUI::Action>> CalendarWidget::create_open_settings_action(
 void CalendarWidget::create_on_tile_doubleclick()
 {
     m_event_calendar->on_tile_doubleclick = [&] {
-        for (const auto& event : m_event_calendar->event_manager().events()) {
+        for (auto const& event : m_event_calendar->event_manager().events()) {
             auto start = event.start;
             auto selected_date = m_event_calendar->selected_date();
 

Userland/Applications/Debugger/main.cpp

@@ -248,14 +248,14 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         }
 
         VERIFY(optional_regs.has_value());
-        const PtraceRegisters& regs = optional_regs.value();
+        PtraceRegisters const& regs = optional_regs.value();
 #if ARCH(X86_64)
-        const FlatPtr ip = regs.rip;
+        FlatPtr const ip = regs.rip;
 #elif ARCH(AARCH64)
-        const FlatPtr ip = 0; // FIXME
+        FlatPtr const ip = 0; // FIXME
         TODO_AARCH64();
 #elif ARCH(RISCV64)
-        const FlatPtr ip = 0; // FIXME
+        FlatPtr const ip = 0; // FIXME
         TODO_RISCV64();
 #else
 #    error Unknown architecture

Userland/Applications/KeyboardMapper/KeyboardMapperWidget.cpp

@@ -97,7 +97,7 @@ void KeyboardMapperWidget::create_frame()
     bottom_widget.add_spacer();
 }
 
-void KeyboardMapperWidget::add_map_radio_button(const StringView map_name, String button_text)
+void KeyboardMapperWidget::add_map_radio_button(StringView const map_name, String button_text)
 {
     auto& map_radio_button = m_map_group->add<GUI::RadioButton>(button_text);
     map_radio_button.set_name(map_name);
@@ -106,7 +106,7 @@ void KeyboardMapperWidget::add_map_radio_button(const StringView map_name, Strin
     };
 }
 
-u32* KeyboardMapperWidget::map_from_name(const StringView map_name)
+u32* KeyboardMapperWidget::map_from_name(StringView const map_name)
 {
     u32* map;
     if (map_name == "map"sv) {
@@ -234,7 +234,7 @@ void KeyboardMapperWidget::keyup_event(GUI::KeyEvent& event)
     }
 }
 
-void KeyboardMapperWidget::set_current_map(const ByteString current_map)
+void KeyboardMapperWidget::set_current_map(ByteString const current_map)
 {
     m_current_map_name = current_map;
     u32* map = map_from_name(m_current_map_name);

Userland/Applications/KeyboardMapper/KeyboardMapperWidget.h

@@ -31,7 +31,7 @@ protected:
     virtual void keydown_event(GUI::KeyEvent&) override;
     virtual void keyup_event(GUI::KeyEvent&) override;
 
-    void set_current_map(const ByteString);
+    void set_current_map(ByteString const);
     void update_window_title();
 
 private:
@@ -39,8 +39,8 @@ private:
 
     Vector<KeyButton*> m_keys;
     RefPtr<GUI::Widget> m_map_group;
-    void add_map_radio_button(const StringView map_name, String button_text);
-    u32* map_from_name(const StringView map_name);
+    void add_map_radio_button(StringView const map_name, String button_text);
+    u32* map_from_name(StringView const map_name);
     void update_modifier_radio_buttons(GUI::KeyEvent&);
 
     ByteString m_filename;

Userland/Applications/Mail/MailWidget.cpp

@@ -475,7 +475,7 @@ void MailWidget::selected_email_to_load(GUI::ModelIndex const& index)
 
     auto& body_data = fetch_response_data.body_data();
     auto body_text_part_iterator = body_data.find_if([](Tuple<IMAP::FetchCommand::DataItem, ByteString>& data) {
-        const auto data_item = data.get<0>();
+        auto const data_item = data.get<0>();
         return data_item.section.has_value() && data_item.section->type == IMAP::FetchCommand::DataItem::SectionType::Parts;
     });
     VERIFY(body_text_part_iterator != body_data.end());

Userland/Applications/Piano/Music.h

@@ -51,10 +51,10 @@ constexpr KeyColor key_pattern[] = {
     White,
 };
 
-const Color note_pressed_color(64, 64, 255);
-const Color column_playing_color(128, 128, 255);
+Color const note_pressed_color(64, 64, 255);
+Color const column_playing_color(128, 128, 255);
 
-const Color left_wave_colors[] = {
+Color const left_wave_colors[] = {
     // Sine
     {
         255,
@@ -96,7 +96,7 @@ const Color left_wave_colors[] = {
 // HACK: make the display code shut up for now
 constexpr int RecordedSample = 5;
 
-const Color right_wave_colors[] = {
+Color const right_wave_colors[] = {
     // Sine
     {
         255,

Userland/Applications/Piano/RollWidget.cpp

@@ -237,8 +237,8 @@ void RollWidget::mousemove_event(GUI::MouseEvent& event)
         int const x_start = get_note_for_x(m_mousedown_event.value().x());
         int const x_end = get_note_for_x(event.x());
 
-        const u32 on_sample = round(roll_length * (static_cast<double>(min(x_start, x_end)) / m_num_notes));
-        const u32 off_sample = round(roll_length * (static_cast<double>(max(x_start, x_end) + 1) / m_num_notes)) - 1;
+        u32 const on_sample = round(roll_length * (static_cast<double>(min(x_start, x_end)) / m_num_notes));
+        u32 const off_sample = round(roll_length * (static_cast<double>(max(x_start, x_end) + 1) / m_num_notes)) - 1;
         auto const note = RollNote { on_sample, off_sample, get_pitch_for_y(m_mousedown_event.value().y()), 127 };
 
         m_track_manager.current_track()->set_note(note);

Userland/Applications/PixelPaint/ImageEditor.cpp

@@ -248,8 +248,8 @@ void ImageEditor::paint_event(GUI::PaintEvent& event)
         }
 
         // Mouse position indicator
-        const Gfx::IntPoint indicator_x({ m_mouse_position.x(), m_ruler_thickness });
-        const Gfx::IntPoint indicator_y({ m_ruler_thickness, m_mouse_position.y() });
+        Gfx::IntPoint const indicator_x({ m_mouse_position.x(), m_ruler_thickness });
+        Gfx::IntPoint const indicator_y({ m_ruler_thickness, m_mouse_position.y() });
         painter.draw_triangle(indicator_x, indicator_x + Gfx::IntPoint(-m_mouse_indicator_triangle_size, -m_mouse_indicator_triangle_size), indicator_x + Gfx::IntPoint(m_mouse_indicator_triangle_size, -m_mouse_indicator_triangle_size), mouse_indicator_color);
         painter.draw_triangle(indicator_y, indicator_y + Gfx::IntPoint(-m_mouse_indicator_triangle_size, -m_mouse_indicator_triangle_size), indicator_y + Gfx::IntPoint(-m_mouse_indicator_triangle_size, m_mouse_indicator_triangle_size), mouse_indicator_color);
 
@@ -276,15 +276,15 @@ int ImageEditor::calculate_ruler_step_size() const
 
 Gfx::IntRect ImageEditor::mouse_indicator_rect_x() const
 {
-    const Gfx::IntPoint top_left({ m_ruler_thickness, m_ruler_thickness - m_mouse_indicator_triangle_size });
-    const Gfx::IntSize size({ width() + 1, m_mouse_indicator_triangle_size + 1 });
+    Gfx::IntPoint const top_left({ m_ruler_thickness, m_ruler_thickness - m_mouse_indicator_triangle_size });
+    Gfx::IntSize const size({ width() + 1, m_mouse_indicator_triangle_size + 1 });
     return Gfx::IntRect(top_left, size);
 }
 
 Gfx::IntRect ImageEditor::mouse_indicator_rect_y() const
 {
-    const Gfx::IntPoint top_left({ m_ruler_thickness - m_mouse_indicator_triangle_size, m_ruler_thickness });
-    const Gfx::IntSize size({ m_mouse_indicator_triangle_size + 1, height() + 1 });
+    Gfx::IntPoint const top_left({ m_ruler_thickness - m_mouse_indicator_triangle_size, m_ruler_thickness });
+    Gfx::IntSize const size({ m_mouse_indicator_triangle_size + 1, height() + 1 });
     return Gfx::IntRect(top_left, size);
 }
 

Userland/Applications/PixelPaint/Tools/GradientTool.cpp

@@ -343,7 +343,7 @@ void GradientTool::calculate_gradient_lines()
     m_editor->update();
 }
 
-void GradientTool::draw_gradient(GUI::Painter& painter, bool with_guidelines, const Gfx::FloatPoint drawing_offset, float scale, Optional<Gfx::IntRect const&> gradient_clip)
+void GradientTool::draw_gradient(GUI::Painter& painter, bool with_guidelines, Gfx::FloatPoint const drawing_offset, float scale, Optional<Gfx::IntRect const&> gradient_clip)
 {
     auto t_gradient_begin_line = m_gradient_begin_line.scaled(scale, scale).translated(drawing_offset);
     auto t_gradient_center_line = m_gradient_center_line.scaled(scale, scale).translated(drawing_offset);

Userland/Applications/PixelPaint/Tools/GradientTool.h

@@ -72,7 +72,7 @@ private:
 
     void calculate_gradient_lines();
     void calculate_transversal_points(float scale_fraction);
-    void draw_gradient(GUI::Painter&, bool with_guidelines = false, const Gfx::FloatPoint drawing_offset = { 0.0f, 0.0f }, float scale = 1, Optional<Gfx::IntRect const&> gradient_clip = {});
+    void draw_gradient(GUI::Painter&, bool with_guidelines = false, Gfx::FloatPoint const drawing_offset = { 0.0f, 0.0f }, float scale = 1, Optional<Gfx::IntRect const&> gradient_clip = {});
     bool has_gradient_data() { return m_gradient_center.has_value() && m_gradient_end.has_value() && m_gradient_start.has_value(); }
     void move_gradient_position(Gfx::IntPoint const movement_delta);
     void rasterize_gradient();

Userland/Applications/SoundPlayer/Playlist.h

@@ -41,8 +41,8 @@ private:
     class BloomFilter {
     public:
         void reset() { m_bitmap = 0; }
-        void add(const StringView key) { m_bitmap |= mask_for_key(key); }
-        bool maybe_contains(const StringView key) const
+        void add(StringView const key) { m_bitmap |= mask_for_key(key); }
+        bool maybe_contains(StringView const key) const
         {
             auto mask = mask_for_key(key);
             return (m_bitmap & mask) == mask;

Userland/Applications/SpaceAnalyzer/TreeMapWidget.cpp

@@ -122,12 +122,12 @@ void TreeMapWidget::lay_out_children(TreeNode const& node, Gfx::IntRect const& r
     Gfx::IntRect canvas = rect;
     bool remaining_nodes_are_too_small = false;
     for (size_t i = 0; !remaining_nodes_are_too_small && i < node.num_children(); i++) {
-        const i64 i_node_area = node.child_at(i).area();
+        i64 const i_node_area = node.child_at(i).area();
         if (i_node_area == 0)
             break;
 
-        const size_t long_side_size = max(canvas.width(), canvas.height());
-        const size_t short_side_size = min(canvas.width(), canvas.height());
+        size_t const long_side_size = max(canvas.width(), canvas.height());
+        size_t const short_side_size = min(canvas.width(), canvas.height());
 
         size_t row_or_column_size = long_side_size * i_node_area / total_area;
         i64 node_area_sum = i_node_area;
@@ -163,7 +163,7 @@ void TreeMapWidget::lay_out_children(TreeNode const& node, Gfx::IntRect const& r
 
         // Paint the elements from 'i' up to and including 'k-1'.
         {
-            const size_t fixed_side_size = row_or_column_size;
+            size_t const fixed_side_size = row_or_column_size;
             i64 placement_area = node_area_sum;
             size_t main_dim = short_side_size;
 

Userland/Applications/SpaceAnalyzer/main.cpp

@@ -163,7 +163,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
                 continue;
             }
 
-            const TreeNode* node = tree_map_widget.path_node(k);
+            TreeNode const* node = tree_map_widget.path_node(k);
 
             builder.append('/');
             builder.append(node->name());

Userland/Applications/Spreadsheet/CellTypeDialog.cpp

@@ -145,7 +145,7 @@ void CellTypeDialog::setup_tabs(GUI::TabWidget& tabs, Vector<Position> const& po
         type_list.set_model(*GUI::ItemListModel<ByteString>::create(g_types));
         type_list.set_should_hide_unnecessary_scrollbars(true);
         type_list.on_selection_change = [&] {
-            const auto& index = type_list.selection().first();
+            auto const& index = type_list.selection().first();
             if (!index.is_valid()) {
                 m_type = nullptr;
                 return;

Userland/Applications/Spreadsheet/Readers/XSV.h

@@ -107,7 +107,7 @@ public:
         size_t index() const { return m_index; }
         size_t size() const { return m_xsv.headers().size(); }
 
-        using ConstIterator = AK::SimpleIterator<const Row, StringView const>;
+        using ConstIterator = AK::SimpleIterator<Row const, StringView const>;
         using Iterator = AK::SimpleIterator<Row, StringView>;
 
         constexpr ConstIterator begin() const { return ConstIterator::begin(*this); }
@@ -168,7 +168,7 @@ public:
         size_t m_index { 0 };
     };
 
-    const Row operator[](size_t index) const;
+    Row const operator[](size_t index) const;
     Row operator[](size_t index);
 
     Row at(size_t index) const;

Userland/Applications/Spreadsheet/Spreadsheet.cpp

@@ -455,7 +455,7 @@ RefPtr<Sheet> Sheet::from_json(JsonObject const& object, Workbook& workbook)
             auto conditional_formats = obj.get_array("conditional_formats"sv);
             auto cformats = cell->conditional_formats();
             if (conditional_formats.has_value()) {
-                conditional_formats->for_each([&](const auto& fmt_val) {
+                conditional_formats->for_each([&](auto const& fmt_val) {
                     if (!fmt_val.is_object())
                         return IterationDecision::Continue;
 

Userland/Applications/Spreadsheet/SpreadsheetWidget.cpp

@@ -193,7 +193,7 @@ SpreadsheetWidget::SpreadsheetWidget(GUI::Window& parent_window, Vector<NonnullR
         auto& sheet = *worksheet_ptr;
         auto& cells = sheet.selected_cells();
         VERIFY(!cells.is_empty());
-        const auto& data = GUI::Clipboard::the().fetch_data_and_type();
+        auto const& data = GUI::Clipboard::the().fetch_data_and_type();
         if (auto spreadsheet_data = data.metadata.get("text/x-spreadsheet-data"); spreadsheet_data.has_value()) {
             Vector<Spreadsheet::Position> source_positions, target_positions;
             auto lines = spreadsheet_data.value().split_view('\n');

Userland/Demos/Gradient/Gradient.cpp

@@ -56,7 +56,7 @@ void Gradient::timer_event(Core::TimerEvent&)
 
 void Gradient::draw()
 {
-    const Color colors[] {
+    Color const colors[] {
         Color::Blue,
         Color::Cyan,
         Color::Green,
@@ -65,7 +65,7 @@ void Gradient::draw()
         Color::Yellow,
     };
 
-    const Orientation orientations[] {
+    Orientation const orientations[] {
         Gfx::Orientation::Horizontal,
         Gfx::Orientation::Vertical
     };

Userland/DevTools/HackStudio/ClassViewWidget.cpp

@@ -19,11 +19,11 @@ ClassViewWidget::ClassViewWidget()
     m_class_tree = add<GUI::TreeView>();
 
     m_class_tree->on_selection_change = [this] {
-        const auto& index = m_class_tree->selection().first();
+        auto const& index = m_class_tree->selection().first();
         if (!index.is_valid())
             return;
 
-        auto* node = static_cast<const ClassViewNode*>(index.internal_data());
+        auto* node = static_cast<ClassViewNode const*>(index.internal_data());
         if (!node->declaration)
             return;
 

Userland/DevTools/HackStudio/Debugger/DebugInfoWidget.cpp

@@ -81,7 +81,7 @@ DebugInfoWidget::DebugInfoWidget()
     variables_tab_widget.add_widget(build_registers_tab());
 
     m_backtrace_view->on_selection_change = [this] {
-        const auto& index = m_backtrace_view->selection().first();
+        auto const& index = m_backtrace_view->selection().first();
 
         if (!index.is_valid()) {
             return;

Userland/DevTools/HackStudio/Debugger/Debugger.cpp

@@ -187,7 +187,7 @@ int Debugger::debugger_loop(Debug::DebugSession::DesiredInitialDebugeeState init
         }
         remove_temporary_breakpoints();
         VERIFY(optional_regs.has_value());
-        const PtraceRegisters& regs = optional_regs.value();
+        PtraceRegisters const& regs = optional_regs.value();
 
         auto source_position = m_debug_session->get_source_position(regs.ip());
         if (!source_position.has_value())

Userland/DevTools/HackStudio/FindInFilesWidget.cpp

@@ -128,7 +128,7 @@ FindInFilesWidget::FindInFilesWidget()
     m_result_view = add<GUI::TableView>();
 
     m_result_view->on_activation = [](auto& index) {
-        auto& match = *(const Match*)index.internal_data();
+        auto& match = *(Match const*)index.internal_data();
         open_file(match.filename);
         current_editor().set_selection(match.range);
         current_editor().set_focus(true);

Userland/DevTools/HackStudio/Git/GitWidget.cpp

@@ -43,11 +43,11 @@ GitWidget::GitWidget()
         [this](auto const& file) { stage_file(file); },
         Gfx::Bitmap::load_from_file("/res/icons/16x16/plus.png"sv).release_value_but_fixme_should_propagate_errors());
     m_unstaged_files->on_selection_change = [this] {
-        const auto& index = m_unstaged_files->selection().first();
+        auto const& index = m_unstaged_files->selection().first();
         if (!index.is_valid())
             return;
 
-        const auto& selected = index.data().as_string();
+        auto const& selected = index.data().as_string();
         show_diff(selected);
     };
 

Userland/DevTools/HackStudio/HackStudioWidget.cpp

@@ -1044,7 +1044,7 @@ void HackStudioWidget::initialize_debugger()
         m_project->root_path(),
         [this](PtraceRegisters const& regs) {
             VERIFY(Debugger::the().session());
-            const auto& debug_session = *Debugger::the().session();
+            auto const& debug_session = *Debugger::the().session();
             auto source_position = debug_session.get_source_position(regs.ip());
             if (!source_position.has_value()) {
                 dbgln("Could not find source position for address: {:p}", regs.ip());

Userland/DevTools/HackStudio/ProjectTemplate.h

@@ -29,7 +29,7 @@ public:
     ByteString const& name() const { return m_name; }
     ByteString const& description() const { return m_description; }
     const GUI::Icon& icon() const { return m_icon; }
-    const ByteString content_path() const
+    ByteString const content_path() const
     {
         return LexicalPath::canonicalized_path(ByteString::formatted("{}/{}", templates_path(), m_id));
     }

Userland/Games/Chess/ChessWidget.cpp

@@ -121,8 +121,8 @@ void ChessWidget::paint_event(GUI::PaintEvent& event)
         float hdx = h * cosf(phi);
         float hdy = h * sinf(phi);
 
-        const auto cos_pi_2_phi = cosf(float { M_PI_2 } - phi);
-        const auto sin_pi_2_phi = sinf(float { M_PI_2 } - phi);
+        auto const cos_pi_2_phi = cosf(float { M_PI_2 } - phi);
+        auto const sin_pi_2_phi = sinf(float { M_PI_2 } - phi);
 
         Gfx::FloatPoint A1(A.x() - (w1 / 2) * cos_pi_2_phi, A.y() - (w1 / 2) * sin_pi_2_phi);
         Gfx::FloatPoint B3(A.x() + (w1 / 2) * cos_pi_2_phi, A.y() + (w1 / 2) * sin_pi_2_phi);

Userland/Games/FlappyBug/Game.h

@@ -176,8 +176,8 @@ private:
     float m_difficulty {};
     float m_restart_cooldown {};
     NonnullRefPtr<Gfx::Bitmap> m_background_bitmap { Gfx::Bitmap::load_from_file("/res/graphics/flappybug/background.png"sv).release_value_but_fixme_should_propagate_errors() };
-    const Gfx::IntRect m_score_rect { 10, 10, 20, 20 };
-    const Gfx::IntRect m_text_rect { game_width / 2 - 80, game_height / 2 - 40, 160, 80 };
+    Gfx::IntRect const m_score_rect { 10, 10, 20, 20 };
+    Gfx::IntRect const m_text_rect { game_width / 2 - 80, game_height / 2 - 40, 160, 80 };
 
     Game(Bug, Cloud);
 };

Userland/Libraries/LibAudio/Resampler.h

@@ -90,8 +90,8 @@ public:
     u32 target() const { return m_target; }
 
 private:
-    const u32 m_source;
-    const u32 m_target;
+    u32 const m_source;
+    u32 const m_target;
     u32 m_current_ratio { 0 };
     SampleType m_last_sample_l {};
     SampleType m_last_sample_r {};

Userland/Libraries/LibC/net.cpp

@@ -11,8 +11,8 @@
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 
-const in6_addr in6addr_any = IN6ADDR_ANY_INIT;
-const in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
+in6_addr const in6addr_any = IN6ADDR_ANY_INIT;
+in6_addr const in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
 
 // https://pubs.opengroup.org/onlinepubs/9699919799/functions/if_nametoindex.html
 unsigned int if_nametoindex([[maybe_unused]] char const* ifname)

Userland/Libraries/LibC/qsort.cpp

@@ -31,7 +31,7 @@ template<>
 inline void swap(SizedObject const& a, SizedObject const& b)
 {
     VERIFY(a.size() == b.size());
-    const size_t size = a.size();
+    size_t const size = a.size();
     auto const a_data = reinterpret_cast<char*>(a.data());
     auto const b_data = reinterpret_cast<char*>(b.data());
     for (auto i = 0u; i < size; ++i) {
@@ -49,7 +49,7 @@ public:
         , m_element_size(element_size)
     {
     }
-    const SizedObject operator[](size_t index)
+    SizedObject const operator[](size_t index)
     {
         return { static_cast<char*>(m_data) + index * m_element_size, m_element_size };
     }

Userland/Libraries/LibC/scanf.cpp

@@ -316,7 +316,7 @@ private:
         return invert ^ scan_set.contains(c);
     }
 
-    const StringView scan_set;
+    StringView const scan_set;
     bool invert { false };
 };
 

Userland/Libraries/LibC/stdlib.cpp

@@ -144,7 +144,7 @@ private:
         return m_sign != Sign::Negative;
     }
 
-    const T m_base;
+    T const m_base;
     T m_num;
     T m_cutoff;
     int m_max_digit_after_cutoff;
@@ -313,7 +313,7 @@ static T c_str_to_floating_point(char const* str, char** endptr)
     // - One of INF or INFINITY, ignoring case
     // - One of NAN or NAN(n-char-sequenceopt), ignoring case in the NAN part
 
-    const Sign sign = strtosign(parse_ptr, &parse_ptr);
+    Sign const sign = strtosign(parse_ptr, &parse_ptr);
 
     if (is_infinity_string(parse_ptr, endptr)) {
         // Don't set errno to ERANGE here:
@@ -973,7 +973,7 @@ long long strtoll(char const* str, char** endptr, int base)
     // Parse spaces and sign
     char* parse_ptr = const_cast<char*>(str);
     strtons(parse_ptr, &parse_ptr);
-    const Sign sign = strtosign(parse_ptr, &parse_ptr);
+    Sign const sign = strtosign(parse_ptr, &parse_ptr);
 
     // Parse base
     if (base == 0) {

Userland/Libraries/LibCards/Card.h

@@ -103,7 +103,7 @@ public:
     bool is_disabled() const { return m_disabled; }
     Gfx::Color color() const { return (m_suit == Suit::Diamonds || m_suit == Suit::Hearts) ? Color::Red : Color::Black; }
 
-    void set_position(const Gfx::IntPoint p) { m_rect.set_location(p); }
+    void set_position(Gfx::IntPoint const p) { m_rect.set_location(p); }
     void set_moving(bool moving) { m_moving = moving; }
     void set_upside_down(bool upside_down) { m_upside_down = upside_down; }
     void set_inverted(bool inverted) { m_inverted = inverted; }

Userland/Libraries/LibChess/Chess.cpp

@@ -116,7 +116,7 @@ ErrorOr<String> Move::to_long_algebraic() const
     return builder.to_string();
 }
 
-Move Move::from_algebraic(StringView algebraic, const Color turn, Board const& board)
+Move Move::from_algebraic(StringView algebraic, Color const turn, Board const& board)
 {
     auto move_string = algebraic;
     Move move({ 50, 50 }, { 50, 50 });
@@ -294,7 +294,7 @@ ErrorOr<String> Board::to_fen() const
     int empty = 0;
     for (int rank = 0; rank < 8; rank++) {
         for (int file = 0; file < 8; file++) {
-            const Piece p(get_piece({ 7 - rank, file }));
+            Piece const p(get_piece({ 7 - rank, file }));
             if (p.type == Type::None) {
                 empty++;
                 continue;

Userland/Libraries/LibChess/Chess.h

@@ -117,7 +117,7 @@ struct Move {
     }
     bool operator==(Move const& other) const { return from == other.from && to == other.to && promote_to == other.promote_to; }
 
-    static Move from_algebraic(StringView algebraic, const Color turn, Board const& board);
+    static Move from_algebraic(StringView algebraic, Color const turn, Board const& board);
     ErrorOr<String> to_long_algebraic() const;
     ErrorOr<String> to_algebraic() const;
 };

Userland/Libraries/LibCodeComprehension/Cpp/CppComprehensionEngine.cpp

@@ -206,7 +206,7 @@ Vector<StringView> CppComprehensionEngine::scope_of_reference_to_symbol(ASTNode
     return scope_parts;
 }
 
-Vector<CodeComprehension::AutocompleteResultEntry> CppComprehensionEngine::autocomplete_property(DocumentData const& document, MemberExpression const& parent, const ByteString partial_text) const
+Vector<CodeComprehension::AutocompleteResultEntry> CppComprehensionEngine::autocomplete_property(DocumentData const& document, MemberExpression const& parent, ByteString const partial_text) const
 {
     VERIFY(parent.object());
     auto type = type_of(document, *parent.object());

Userland/Libraries/LibCodeComprehension/Cpp/CppComprehensionEngine.h

@@ -95,7 +95,7 @@ private:
         HashTable<ByteString> m_available_headers;
     };
 
-    Vector<CodeComprehension::AutocompleteResultEntry> autocomplete_property(DocumentData const&, MemberExpression const&, const ByteString partial_text) const;
+    Vector<CodeComprehension::AutocompleteResultEntry> autocomplete_property(DocumentData const&, MemberExpression const&, ByteString const partial_text) const;
     Vector<AutocompleteResultEntry> autocomplete_name(DocumentData const&, ASTNode const&, ByteString const& partial_text) const;
     ByteString type_of(DocumentData const&, Expression const&) const;
     ByteString type_of_property(DocumentData const&, Identifier const&) const;