Merge branch 'development' of https://github.com/o3de/o3de into daimini/dpiIssues/floatingWidgetFlickerBetweenScreens

Code/Framework/AzCore/AzCore/Component/Component.h

@@ -266,7 +266,7 @@ namespace AZ
                         _ComponentClass::RTTI_Type().ToString<AZStd::string>().c_str(), descriptor->GetName(), _ComponentClass::RTTI_TypeName());          \
                     return nullptr;                                                                                                     \
                 }                                                                                                                       \
-                else if (descriptor->GetName() != _ComponentClass::RTTI_TypeName())                                                     \
+                if (descriptor->GetName() != _ComponentClass::RTTI_TypeName())                                                     \
                 {                                                                                                                       \
                     AZ_Error("Component", false, "The same component UUID (%s) / name (%s) was registered twice.  This isn't allowed, " \
                              "it can cause lifetime management issues / crashes.\nThis situation can happen by declaring a component "  \

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -1251,6 +1251,8 @@ namespace AZ
 
                 return AZ::SettingsRegistryInterface::VisitResponse::Continue;
             }
+
+            using SettingsRegistryInterface::Visitor::Visit;
             void Visit(AZStd::string_view path, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type, bool value) override
             {
                 // By default the auto load option is true

Code/Framework/AzCore/AzCore/Component/ComponentApplication.h

@@ -196,14 +196,14 @@ namespace AZ
 
         //////////////////////////////////////////////////////////////////////////
         // ComponentApplicationRequests
-        void RegisterComponentDescriptor(const ComponentDescriptor* descriptor) override final;
-        void UnregisterComponentDescriptor(const ComponentDescriptor* descriptor) override final;
-        void RegisterEntityAddedEventHandler(EntityAddedEvent::Handler& handler) override final;
-        void RegisterEntityRemovedEventHandler(EntityRemovedEvent::Handler& handler) override final;
-        void RegisterEntityActivatedEventHandler(EntityActivatedEvent::Handler& handler) override final;
-        void RegisterEntityDeactivatedEventHandler(EntityDeactivatedEvent::Handler& handler) override final;
-        void SignalEntityActivated(Entity* entity) override final;
-        void SignalEntityDeactivated(Entity* entity) override final;
+        void RegisterComponentDescriptor(const ComponentDescriptor* descriptor) final;
+        void UnregisterComponentDescriptor(const ComponentDescriptor* descriptor) final;
+        void RegisterEntityAddedEventHandler(EntityAddedEvent::Handler& handler) final;
+        void RegisterEntityRemovedEventHandler(EntityRemovedEvent::Handler& handler) final;
+        void RegisterEntityActivatedEventHandler(EntityActivatedEvent::Handler& handler) final;
+        void RegisterEntityDeactivatedEventHandler(EntityDeactivatedEvent::Handler& handler) final;
+        void SignalEntityActivated(Entity* entity) final;
+        void SignalEntityDeactivated(Entity* entity) final;
         bool AddEntity(Entity* entity) override;
         bool RemoveEntity(Entity* entity) override;
         bool DeleteEntity(const EntityId& id) override;

Code/Framework/AzCore/AzCore/Debug/AssetTrackingTypes.h

@@ -86,6 +86,7 @@ namespace AZ
         class AssetTreeNodeBase
         {
         public:
+            virtual ~AssetTreeNodeBase() = default;
             virtual const AssetPrimaryInfo* GetAssetPrimaryInfo() const = 0;
             virtual AssetTreeNodeBase* FindOrAddChild(const AssetTrackingId& id, const AssetPrimaryInfo* info) = 0;
         };
@@ -94,6 +95,7 @@ namespace AZ
         class AssetTreeBase
         {
         public:
+            virtual ~AssetTreeBase() = default;
             virtual AssetTreeNodeBase& GetRoot() = 0;
         };
 
@@ -101,6 +103,7 @@ namespace AZ
         class AssetAllocationTableBase
         {
         public:
+            virtual ~AssetAllocationTableBase() = default;
             virtual AssetTreeNodeBase* FindAllocation(void* ptr) const = 0;
         };
     }

Code/Framework/AzCore/AzCore/Debug/AssetTrackingTypesImpl.h

@@ -31,6 +31,8 @@ namespace AZ
             {
             }
 
+            ~AssetTreeNode() override = default;
+
             const AssetPrimaryInfo* GetAssetPrimaryInfo() const override
             {
                 return m_primaryinfo;
@@ -67,6 +69,8 @@ namespace AZ
         class AssetTree : public AssetTreeBase
         {
         public:
+            ~AssetTree() override = default;
+
             AssetTreeNodeBase& GetRoot() override
             {
                 return m_rootAssets;
@@ -99,6 +103,7 @@ namespace AZ
             AllocationTable(mutex_type& mutex) : m_mutex(mutex)
             {
             }
+            ~AllocationTable() override = default;
 
             AssetTreeNodeBase* FindAllocation(void* ptr) const override
             {

Code/Framework/AzCore/AzCore/Debug/BudgetTracker.h

@@ -19,7 +19,7 @@ namespace AZ::Debug
     class BudgetTracker
     {
     public:
-        AZ_RTTI(BudgetTracker, "{E14A746D-BFFE-4C02-90FB-4699B79864A5}");
+        AZ_TYPE_INFO(BudgetTracker, "{E14A746D-BFFE-4C02-90FB-4699B79864A5}");
         static Budget* GetBudgetFromEnvironment(const char* budgetName, uint32_t crc);
 
         ~BudgetTracker();

Code/Framework/AzCore/AzCore/Debug/TraceMessagesDriller.h

@@ -28,21 +28,21 @@ namespace AZ
         protected:
             //////////////////////////////////////////////////////////////////////////
             // Driller
-            virtual const char* GroupName() const { return "SystemDrillers"; }
-            virtual const char* GetName() const { return "TraceMessagesDriller"; }
-            virtual const char* GetDescription() const { return "Handles all system messages like Assert, Exception, Error, Warning, Printf, etc."; }
-            virtual void Start(const Param* params = NULL, int numParams = 0);
-            virtual void Stop();
+            const char* GroupName() const override { return "SystemDrillers"; }
+            const char* GetName() const override { return "TraceMessagesDriller"; }
+            const char* GetDescription() const override { return "Handles all system messages like Assert, Exception, Error, Warning, Printf, etc."; }
+            void Start(const Param* params = NULL, int numParams = 0) override;
+            void Stop() override;
             //////////////////////////////////////////////////////////////////////////
 
             //////////////////////////////////////////////////////////////////////////
             // TraceMessagesDrillerBus
             /// Triggered when a AZ_Assert failed. This is terminating event! (the code will break, crash).
-            virtual void OnAssert(const char* message);
-            virtual void OnException(const char* message);
-            virtual void OnError(const char* window, const char* message);
-            virtual void OnWarning(const char* window, const char* message);
-            virtual void OnPrintf(const char* window, const char* message);
+            void OnAssert(const char* message) override;
+            void OnException(const char* message) override;
+            void OnError(const char* window, const char* message) override;
+            void OnWarning(const char* window, const char* message) override;
+            void OnPrintf(const char* window, const char* message) override;
             //////////////////////////////////////////////////////////////////////////
         };
     } // namespace Debug

Code/Framework/AzCore/AzCore/Driller/Stream.h

@@ -443,7 +443,7 @@ namespace AZ
             const unsigned char* GetData() const    { return m_data.data(); }
             unsigned int GetDataSize() const        { return static_cast<unsigned int>(m_data.size()); }
             inline void  Reset()                    { m_data.clear(); }
-            virtual void WriteBinary(const void* data, unsigned int dataSize)
+            void WriteBinary(const void* data, unsigned int dataSize) override
             {
                 m_data.insert(m_data.end(), reinterpret_cast<const unsigned char*>(data), reinterpret_cast<const unsigned char*>(data) + dataSize);
             }
@@ -489,7 +489,7 @@ namespace AZ
             }
 
             unsigned int GetDataLeft() const { return static_cast<unsigned int>(m_dataEnd - m_data); }
-            virtual unsigned int ReadBinary(void* data, unsigned int maxDataSize)
+            unsigned int ReadBinary(void* data, unsigned int maxDataSize) override
             {
                 AZ_Assert(m_data != nullptr, "You must call SetData function, before you can read data!");
                 AZ_Assert(data != nullptr && maxDataSize > 0, "We must have a valid pointer and max data size!");
@@ -523,7 +523,7 @@ namespace AZ
             bool Open(const char* fileName, int mode, int platformFlags = 0);
             void Close();
 
-            virtual void WriteBinary(const void* data, unsigned int dataSize);
+            void WriteBinary(const void* data, unsigned int dataSize) override;
         };
 
         /**
@@ -540,7 +540,7 @@ namespace AZ
             DrillerInputFileStream();
             ~DrillerInputFileStream();
             bool Open(const char* fileName, int mode, int platformFlags = 0);
-            virtual unsigned int ReadBinary(void* data, unsigned int maxDataSize);
+            unsigned int ReadBinary(void* data, unsigned int maxDataSize) override;
             void Close();
         };
 

Code/Framework/AzCore/AzCore/IO/CompressorZLib.h

@@ -98,21 +98,21 @@ namespace AZ
 
             /// Return compressor type id.
             static AZ::u32      TypeId();
-            virtual AZ::u32     GetTypeId() const           { return TypeId(); }
+            AZ::u32     GetTypeId() const override           { return TypeId(); }
             /// Called when we open a stream to Read for the first time. Data contains the first. dataSize <= m_maxHeaderSize.
-            virtual bool        ReadHeaderAndData(CompressorStream* stream, AZ::u8* data, unsigned int dataSize);
+            bool        ReadHeaderAndData(CompressorStream* stream, AZ::u8* data, unsigned int dataSize) override;
             /// Called when we are about to start writing to a compressed stream.
-            virtual bool        WriteHeaderAndData(CompressorStream* stream);
+            bool        WriteHeaderAndData(CompressorStream* stream) override;
             /// Forwarded function from the Device when we from a compressed stream.
-            virtual SizeType    Read(CompressorStream* stream, SizeType byteSize, SizeType offset, void* buffer);
+            SizeType    Read(CompressorStream* stream, SizeType byteSize, SizeType offset, void* buffer) override;
             /// Forwarded function from the Device when we write to a compressed stream.
-            virtual SizeType    Write(CompressorStream* stream, SizeType byteSize, const void* data, SizeType offset = SizeType(-1));
+            SizeType    Write(CompressorStream* stream, SizeType byteSize, const void* data, SizeType offset = SizeType(-1)) override;
             /// Write a seek point.
-            virtual bool        WriteSeekPoint(CompressorStream* stream);
+            bool        WriteSeekPoint(CompressorStream* stream) override;
             /// Set auto seek point even dataSize bytes.
-            virtual bool        StartCompressor(CompressorStream* stream, int compressionLevel, SizeType autoSeekDataSize);
+            bool        StartCompressor(CompressorStream* stream, int compressionLevel, SizeType autoSeekDataSize) override;
             /// Called just before we close the stream. All compression data will be flushed and finalized. (You can't add data afterwards).
-            virtual bool        Close(CompressorStream* stream);
+            bool        Close(CompressorStream* stream) override;
 
         protected:
 

Code/Framework/AzCore/AzCore/Jobs/Internal/JobNotify.h

@@ -31,7 +31,7 @@ namespace AZ
             {
             }
         protected:
-            virtual void Process()
+            void Process() override
             {
                 m_notifyFlag->store(true, AZStd::memory_order_release);
             }

Code/Framework/AzCore/AzCore/Math/InterpolationSample.h

@@ -77,7 +77,7 @@ namespace AZ
         : public Sample<Vector3>
     {
     public:
-        Vector3 GetInterpolatedValue(TimeType time) override final
+        Vector3 GetInterpolatedValue(TimeType time) final
         {
             Vector3 interpolatedValue = m_previousValue;
             if (m_targetTimestamp != 0)
@@ -108,7 +108,7 @@ namespace AZ
         : public Sample<Quaternion>
     {
     public:
-        Quaternion GetInterpolatedValue(TimeType time) override final
+        Quaternion GetInterpolatedValue(TimeType time) final
         {
             Quaternion interpolatedValue = m_previousValue;
             if (m_targetTimestamp != 0)
@@ -144,7 +144,7 @@ namespace AZ
         : public Sample<Vector3>
     {
     public:
-        Vector3 GetInterpolatedValue(TimeType /*time*/) override final
+        Vector3 GetInterpolatedValue(TimeType /*time*/) final
         {
             return GetTargetValue();
         }
@@ -155,7 +155,7 @@ namespace AZ
         : public Sample<Quaternion>
     {
     public:
-        Quaternion GetInterpolatedValue(TimeType /*time*/) override final
+        Quaternion GetInterpolatedValue(TimeType /*time*/) final
         {
             return GetTargetValue();
         }

Code/Framework/AzCore/AzCore/Memory/HeapSchema.h

@@ -48,18 +48,18 @@ namespace AZ
         HeapSchema(const Descriptor& desc);
         virtual ~HeapSchema();
 
-        virtual pointer_type    Allocate(size_type byteSize, size_type alignment, int flags, const char* name = 0, const char* fileName = 0, int lineNum = 0, unsigned int suppressStackRecord = 0);
-        virtual void            DeAllocate(pointer_type ptr, size_type byteSize = 0, size_type alignment = 0);
-        virtual pointer_type    ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment) { (void)ptr; (void)newSize; (void)newAlignment; return NULL; }
-        virtual size_type       Resize(pointer_type ptr, size_type newSize)                  { (void)ptr; (void)newSize; return 0; }
-        virtual size_type       AllocationSize(pointer_type ptr);
+        pointer_type    Allocate(size_type byteSize, size_type alignment, int flags, const char* name = 0, const char* fileName = 0, int lineNum = 0, unsigned int suppressStackRecord = 0) override;
+        void            DeAllocate(pointer_type ptr, size_type byteSize = 0, size_type alignment = 0) override;
+        pointer_type    ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment) override { (void)ptr; (void)newSize; (void)newAlignment; return NULL; }
+        size_type       Resize(pointer_type ptr, size_type newSize) override                  { (void)ptr; (void)newSize; return 0; }
+        size_type       AllocationSize(pointer_type ptr) override;
 
-        virtual size_type       NumAllocatedBytes() const               { return m_used; }
-        virtual size_type       Capacity() const                        { return m_capacity; }
-        virtual size_type       GetMaxAllocationSize() const;
-        size_type               GetMaxContiguousAllocationSize() const override;
-        virtual IAllocatorAllocate* GetSubAllocator()                   { return m_subAllocator; }
-        virtual void GarbageCollect()                                   {}
+        size_type       NumAllocatedBytes() const override               { return m_used; }
+        size_type       Capacity() const override                        { return m_capacity; }
+        size_type       GetMaxAllocationSize() const override;
+        size_type       GetMaxContiguousAllocationSize() const override;
+        IAllocatorAllocate* GetSubAllocator() override                   { return m_subAllocator; }
+        void GarbageCollect() override                                   {}
 
     private:
         AZ_FORCE_INLINE size_type ChunckSize(pointer_type ptr);

Code/Framework/AzCore/AzCore/Memory/HphaSchema.h

@@ -56,22 +56,22 @@ namespace AZ
         HphaSchema(const Descriptor& desc);
         virtual ~HphaSchema();
 
-        virtual pointer_type    Allocate(size_type byteSize, size_type alignment, int flags = 0, const char* name = 0, const char* fileName = 0, int lineNum = 0, unsigned int suppressStackRecord = 0);
-        virtual void            DeAllocate(pointer_type ptr, size_type byteSize = 0, size_type alignment = 0);
-        virtual pointer_type    ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment);
+        pointer_type    Allocate(size_type byteSize, size_type alignment, int flags = 0, const char* name = 0, const char* fileName = 0, int lineNum = 0, unsigned int suppressStackRecord = 0) override;
+        void            DeAllocate(pointer_type ptr, size_type byteSize = 0, size_type alignment = 0) override;
+        pointer_type    ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment) override;
         /// Resizes allocated memory block to the size possible and returns that size.
-        virtual size_type       Resize(pointer_type ptr, size_type newSize);
-        virtual size_type       AllocationSize(pointer_type ptr);
+        size_type       Resize(pointer_type ptr, size_type newSize) override;
+        size_type       AllocationSize(pointer_type ptr) override;
 
-        virtual size_type       NumAllocatedBytes() const;
-        virtual size_type       Capacity() const;
-        virtual size_type       GetMaxAllocationSize() const;
-        size_type               GetMaxContiguousAllocationSize() const override;
-        virtual size_type       GetUnAllocatedMemory(bool isPrint = false) const;
-        virtual IAllocatorAllocate* GetSubAllocator()                       { return m_desc.m_subAllocator; }
+        size_type       NumAllocatedBytes() const override;
+        size_type       Capacity() const override;
+        size_type       GetMaxAllocationSize() const override;
+        size_type       GetMaxContiguousAllocationSize() const override;
+        size_type       GetUnAllocatedMemory(bool isPrint = false) const override;
+        IAllocatorAllocate* GetSubAllocator() override                       { return m_desc.m_subAllocator; }
 
         /// Return unused memory to the OS (if we don't use fixed block). Don't call this unless you really need free memory, it is slow.
-        virtual void            GarbageCollect();
+        void            GarbageCollect() override;
 
     private:
         // [LY-84974][sconel@][2018-08-10] SliceStrike integration up to CL 671758

Code/Framework/AzCore/AzCore/Memory/MallocSchema.h

@@ -41,18 +41,18 @@ namespace AZ
         //---------------------------------------------------------------------
         // IAllocatorAllocate
         //---------------------------------------------------------------------
-        virtual pointer_type Allocate(size_type byteSize, size_type alignment, int flags, const char* name = 0, const char* fileName = 0, int lineNum = 0, unsigned int suppressStackRecord = 0) override;
-        virtual void DeAllocate(pointer_type ptr, size_type byteSize = 0, size_type alignment = 0) override;
-        virtual pointer_type ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment) override;
-        virtual size_type Resize(pointer_type ptr, size_type newSize) override;
-        virtual size_type AllocationSize(pointer_type ptr) override;
+        pointer_type Allocate(size_type byteSize, size_type alignment, int flags, const char* name = 0, const char* fileName = 0, int lineNum = 0, unsigned int suppressStackRecord = 0) override;
+        void DeAllocate(pointer_type ptr, size_type byteSize = 0, size_type alignment = 0) override;
+        pointer_type ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment) override;
+        size_type Resize(pointer_type ptr, size_type newSize) override;
+        size_type AllocationSize(pointer_type ptr) override;
 
-        virtual size_type NumAllocatedBytes() const override;
-        virtual size_type Capacity() const override;
-        virtual size_type GetMaxAllocationSize() const override;
-        virtual size_type GetMaxContiguousAllocationSize() const override;
-        virtual IAllocatorAllocate* GetSubAllocator() override;
-        virtual void GarbageCollect() override;
+        size_type NumAllocatedBytes() const override;
+        size_type Capacity() const override;
+        size_type GetMaxAllocationSize() const override;
+        size_type GetMaxContiguousAllocationSize() const override;
+        IAllocatorAllocate* GetSubAllocator() override;
+        void GarbageCollect() override;
 
     private:
         typedef void* (*MallocFn)(size_t);

Code/Framework/AzCore/AzCore/Memory/Memory.h

@@ -849,7 +849,7 @@ namespace AZ
             return AZ::AllocatorInstance<Parent>::Get().GetUnAllocatedMemory(isPrint);
         }
 
-        virtual IAllocatorAllocate*     GetSubAllocator() override
+        IAllocatorAllocate*     GetSubAllocator() override
         {
             return AZ::AllocatorInstance<Parent>::Get().GetSubAllocator();
         }

Code/Framework/AzCore/AzCore/Memory/MemoryDriller.h

@@ -38,24 +38,24 @@ namespace AZ
         protected:
             //////////////////////////////////////////////////////////////////////////
             // Driller
-            virtual const char*  GroupName() const          { return "SystemDrillers"; }
-            virtual const char*  GetName() const            { return "MemoryDriller"; }
-            virtual const char*  GetDescription() const     { return "Reports all allocators and memory allocations."; }
-            virtual void         Start(const Param* params = NULL, int numParams = 0);
-            virtual void         Stop();
+            const char*  GroupName() const override          { return "SystemDrillers"; }
+            const char*  GetName() const override            { return "MemoryDriller"; }
+            const char*  GetDescription() const override     { return "Reports all allocators and memory allocations."; }
+            void         Start(const Param* params = NULL, int numParams = 0) override;
+            void         Stop() override;
             //////////////////////////////////////////////////////////////////////////
 
             //////////////////////////////////////////////////////////////////////////
             // MemoryDrillerBus
-            virtual void RegisterAllocator(IAllocator* allocator);
-            virtual void UnregisterAllocator(IAllocator* allocator);
+            void RegisterAllocator(IAllocator* allocator) override;
+            void UnregisterAllocator(IAllocator* allocator) override;
 
-            virtual void RegisterAllocation(IAllocator* allocator, void* address, size_t byteSize, size_t alignment, const char* name, const char* fileName, int lineNum, unsigned int stackSuppressCount);
-            virtual void UnregisterAllocation(IAllocator* allocator, void* address, size_t byteSize, size_t alignment, AllocationInfo* info);
-            virtual void ReallocateAllocation(IAllocator* allocator, void* prevAddress, void* newAddress, size_t newByteSize, size_t newAlignment);
-            virtual void ResizeAllocation(IAllocator* allocator, void* address, size_t newSize);
+            void RegisterAllocation(IAllocator* allocator, void* address, size_t byteSize, size_t alignment, const char* name, const char* fileName, int lineNum, unsigned int stackSuppressCount) override;
+            void UnregisterAllocation(IAllocator* allocator, void* address, size_t byteSize, size_t alignment, AllocationInfo* info) override;
+            void ReallocateAllocation(IAllocator* allocator, void* prevAddress, void* newAddress, size_t newByteSize, size_t newAlignment) override;
+            void ResizeAllocation(IAllocator* allocator, void* address, size_t newSize) override;
 
-            virtual void DumpAllAllocations();
+            void DumpAllAllocations() override;
             //////////////////////////////////////////////////////////////////////////
 
             void RegisterAllocatorOutput(IAllocator* allocator);

Code/Framework/AzCore/AzCore/Memory/OverrunDetectionAllocator.h

@@ -77,18 +77,18 @@ namespace AZ
         //---------------------------------------------------------------------
         // IAllocatorAllocate
         //---------------------------------------------------------------------
-        virtual pointer_type Allocate(size_type byteSize, size_type alignment, int flags, const char* name = 0, const char* fileName = 0, int lineNum = 0, unsigned int suppressStackRecord = 0) override;
-        virtual void DeAllocate(pointer_type ptr, size_type byteSize = 0, size_type alignment = 0) override;
-        virtual pointer_type ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment) override;
-        virtual size_type Resize(pointer_type ptr, size_type newSize) override;
-        virtual size_type AllocationSize(pointer_type ptr) override;
+        pointer_type Allocate(size_type byteSize, size_type alignment, int flags, const char* name = 0, const char* fileName = 0, int lineNum = 0, unsigned int suppressStackRecord = 0) override;
+        void DeAllocate(pointer_type ptr, size_type byteSize = 0, size_type alignment = 0) override;
+        pointer_type ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment) override;
+        size_type Resize(pointer_type ptr, size_type newSize) override;
+        size_type AllocationSize(pointer_type ptr) override;
 
-        virtual size_type NumAllocatedBytes() const override;
-        virtual size_type Capacity() const override;
-        virtual size_type GetMaxAllocationSize() const override;
+        size_type NumAllocatedBytes() const override;
+        size_type Capacity() const override;
+        size_type GetMaxAllocationSize() const override;
         size_type GetMaxContiguousAllocationSize() const override;
-        virtual IAllocatorAllocate* GetSubAllocator() override;
-        virtual void GarbageCollect() override;
+        IAllocatorAllocate* GetSubAllocator() override;
+        void GarbageCollect() override;
 
     private:
         OverrunDetectionSchemaImpl* m_impl;

Code/Framework/AzCore/AzCore/Module/Module.h

@@ -62,7 +62,7 @@ namespace AZ
          * DO NOT OVERRIDE. This method will return in the future, but at this point things reflected here are not unreflected for all ReflectContexts (Serialize, Editor, Network, Script, etc.)
          * Place all calls to non-component reflect functions inside of a component reflect function to ensure that your types are unreflected.
          */
-        virtual void Reflect(AZ::ReflectContext*) final { }
+        void Reflect(AZ::ReflectContext*) {}
 
         /**
          * Override to require specific components on the system entity.

Code/Framework/AzCore/AzCore/RTTI/BehaviorContext.h

@@ -594,8 +594,8 @@ namespace AZ
             void SetArgumentName(size_t index, const AZStd::string& name) override;
             const AZStd::string* GetArgumentToolTip(size_t index) const override;
             void SetArgumentToolTip(size_t index, const AZStd::string& name) override;
-            virtual void SetDefaultValue(size_t index, BehaviorDefaultValuePtr defaultValue) override;
-            virtual BehaviorDefaultValuePtr GetDefaultValue(size_t index) const override;
+            void SetDefaultValue(size_t index, BehaviorDefaultValuePtr defaultValue) override;
+            BehaviorDefaultValuePtr GetDefaultValue(size_t index) const override;
             const BehaviorParameter* GetResult() const override;
 
             void OverrideParameterTraits(size_t index, AZ::u32 addTraits, AZ::u32 removeTraits) override;

Code/Framework/AzCore/AzCore/RTTI/RTTI.h

@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-#ifndef AZCORE_RTTI_H
-#define AZCORE_RTTI_H
+
+#pragma once
 
 #include <AzCore/RTTI/TypeInfo.h>
 #include <AzCore/Module/Environment.h>
@@ -44,21 +44,9 @@ namespace AZ
     /// RTTI typeId
     typedef void (* RTTI_EnumCallback)(const AZ::TypeId& /*typeId*/, void* /*userData*/);
 
-    // Disabling missing override warning because we intentionally want to allow for declaring RTTI base classes that don't impelment RTTI.
-#if defined(AZ_COMPILER_CLANG)
-#   define AZ_PUSH_DISABLE_OVERRIDE_WARNING \
-    _Pragma("clang diagnostic push")        \
-    _Pragma("clang diagnostic ignored \"-Winconsistent-missing-override\"")
-#   define AZ_POP_DISABLE_OVERRIDE_WARNING \
-    _Pragma("clang diagnostic pop")
-#else
-#   define AZ_PUSH_DISABLE_OVERRIDE_WARNING
-#   define AZ_POP_DISABLE_OVERRIDE_WARNING
-#endif
-
     // We require AZ_TYPE_INFO to be declared
     #define AZ_RTTI_COMMON()                                                                                                       \
-    AZ_PUSH_DISABLE_OVERRIDE_WARNING                                                                                               \
+    AZ_PUSH_DISABLE_WARNING(26433, "-Winconsistent-missing-override")                                                              \
     void RTTI_Enable();                                                                                                            \
     virtual inline const AZ::TypeId& RTTI_GetType() const { return RTTI_Type(); }                                                  \
     virtual inline const char*      RTTI_GetTypeName() const { return RTTI_TypeName(); }                                           \
@@ -66,7 +54,7 @@ namespace AZ
     virtual void                    RTTI_EnumTypes(AZ::RTTI_EnumCallback cb, void* userData) { RTTI_EnumHierarchy(cb, userData); } \
     static inline const AZ::TypeId& RTTI_Type() { return TYPEINFO_Uuid(); }                                                        \
     static inline const char*       RTTI_TypeName() { return TYPEINFO_Name(); }                                                    \
-    AZ_POP_DISABLE_OVERRIDE_WARNING
+    AZ_POP_DISABLE_WARNING
 
     //#define AZ_RTTI_1(_1)           static_assert(false,"You must provide a valid classUuid!")
 
@@ -74,8 +62,10 @@ namespace AZ
     #define AZ_RTTI_1()             AZ_RTTI_COMMON()                                                                        \
     static bool                 RTTI_IsContainType(const AZ::TypeId& id) { return id == RTTI_Type(); }                      \
     static void                 RTTI_EnumHierarchy(AZ::RTTI_EnumCallback cb, void* userData) { cb(RTTI_Type(), userData); } \
+    AZ_PUSH_DISABLE_WARNING(26433, "-Winconsistent-missing-override")                                                       \
     virtual inline const void*  RTTI_AddressOf(const AZ::TypeId& id) const { return (id == RTTI_Type()) ? this : nullptr; } \
-    virtual inline void*        RTTI_AddressOf(const AZ::TypeId& id) { return (id == RTTI_Type()) ? this : nullptr; }
+    virtual inline void*        RTTI_AddressOf(const AZ::TypeId& id) { return (id == RTTI_Type()) ? this : nullptr; }       \
+    AZ_POP_DISABLE_WARNING
 
     /// AZ_RTTI(BaseClass)
     #define AZ_RTTI_2(_1)           AZ_RTTI_COMMON()                                           \
@@ -85,14 +75,14 @@ namespace AZ
     static void                 RTTI_EnumHierarchy(AZ::RTTI_EnumCallback cb, void* userData) { \
         cb(RTTI_Type(), userData);                                                             \
         AZ::Internal::RttiCaller<_1>::RTTI_EnumHierarchy(cb, userData); }                      \
-    AZ_PUSH_DISABLE_OVERRIDE_WARNING                                                           \
+    AZ_PUSH_DISABLE_WARNING(26433, "-Winconsistent-missing-override")                          \
     virtual inline const void*  RTTI_AddressOf(const AZ::TypeId& id) const {                   \
         if (id == RTTI_Type()) { return this; }                                                \
         return AZ::Internal::RttiCaller<_1>::RTTI_AddressOf(this, id); }                       \
     virtual inline void*        RTTI_AddressOf(const AZ::TypeId& id) {                         \
         if (id == RTTI_Type()) { return this; }                                                \
         return AZ::Internal::RttiCaller<_1>::RTTI_AddressOf(this, id); }                       \
-    AZ_POP_DISABLE_OVERRIDE_WARNING
+    AZ_POP_DISABLE_WARNING
 
     /// AZ_RTTI(BaseClass1,BaseClass2)
     #define AZ_RTTI_3(_1, _2)        AZ_RTTI_COMMON()                                                \
@@ -104,7 +94,7 @@ namespace AZ
         cb(RTTI_Type(), userData);                                                                   \
         AZ::Internal::RttiCaller<_1>::RTTI_EnumHierarchy(cb, userData);                              \
         AZ::Internal::RttiCaller<_2>::RTTI_EnumHierarchy(cb, userData); }                            \
-    AZ_PUSH_DISABLE_OVERRIDE_WARNING                                                                 \
+    AZ_PUSH_DISABLE_WARNING(26433, "-Winconsistent-missing-override")                                \
     virtual inline const void*  RTTI_AddressOf(const AZ::TypeId& id) const {                         \
         if (id == RTTI_Type()) { return this; }                                                      \
         const void* r = AZ::Internal::RttiCaller<_1>::RTTI_AddressOf(this, id); if (r) { return r; } \
@@ -113,7 +103,7 @@ namespace AZ
         if (id == RTTI_Type()) { return this; }                                                      \
         void* r = AZ::Internal::RttiCaller<_1>::RTTI_AddressOf(this, id); if (r) { return r; }       \
         return AZ::Internal::RttiCaller<_2>::RTTI_AddressOf(this, id); }                             \
-    AZ_POP_DISABLE_OVERRIDE_WARNING
+    AZ_POP_DISABLE_WARNING
 
     /// AZ_RTTI(BaseClass1,BaseClass2,BaseClass3)
     #define AZ_RTTI_4(_1, _2, _3)    AZ_RTTI_COMMON()                                                \
@@ -127,7 +117,7 @@ namespace AZ
         AZ::Internal::RttiCaller<_1>::RTTI_EnumHierarchy(cb, userData);                              \
         AZ::Internal::RttiCaller<_2>::RTTI_EnumHierarchy(cb, userData);                              \
         AZ::Internal::RttiCaller<_3>::RTTI_EnumHierarchy(cb, userData); }                            \
-    AZ_PUSH_DISABLE_OVERRIDE_WARNING                                                                 \
+    AZ_PUSH_DISABLE_WARNING(26433, "-Winconsistent-missing-override")                                \
     virtual inline const void*  RTTI_AddressOf(const AZ::TypeId& id) const {                         \
         if (id == RTTI_Type()) { return this; }                                                      \
         const void* r = AZ::Internal::RttiCaller<_1>::RTTI_AddressOf(this, id); if (r) { return r; } \
@@ -138,7 +128,7 @@ namespace AZ
         void* r = AZ::Internal::RttiCaller<_1>::RTTI_AddressOf(this, id); if (r) { return r; }       \
         r = AZ::Internal::RttiCaller<_2>::RTTI_AddressOf(this, id); if (r) { return r; }             \
         return AZ::Internal::RttiCaller<_3>::RTTI_AddressOf(this, id); }                             \
-    AZ_POP_DISABLE_OVERRIDE_WARNING
+    AZ_POP_DISABLE_WARNING
 
     /// AZ_RTTI(BaseClass1,BaseClass2,BaseClass3,BaseClass4)
     #define AZ_RTTI_5(_1, _2, _3, _4)  AZ_RTTI_COMMON()                                              \
@@ -154,7 +144,7 @@ namespace AZ
         AZ::Internal::RttiCaller<_2>::RTTI_EnumHierarchy(cb, userData);                              \
         AZ::Internal::RttiCaller<_3>::RTTI_EnumHierarchy(cb, userData);                              \
         AZ::Internal::RttiCaller<_4>::RTTI_EnumHierarchy(cb, userData); }                            \
-    AZ_PUSH_DISABLE_OVERRIDE_WARNING                                                                 \
+    AZ_PUSH_DISABLE_WARNING(26433, "-Winconsistent-missing-override")                                \
     virtual inline const void*  RTTI_AddressOf(const AZ::TypeId& id) const {                         \
         if (id == RTTI_Type()) { return this; }                                                      \
         const void* r = AZ::Internal::RttiCaller<_1>::RTTI_AddressOf(this, id); if (r) { return r; } \
@@ -167,7 +157,7 @@ namespace AZ
         r = AZ::Internal::RttiCaller<_2>::RTTI_AddressOf(this, id); if (r) { return r; }             \
         r = AZ::Internal::RttiCaller<_3>::RTTI_AddressOf(this, id); if (r) { return r; }             \
         return AZ::Internal::RttiCaller<_4>::RTTI_AddressOf(this, id); }                             \
-    AZ_POP_DISABLE_OVERRIDE_WARNING
+    AZ_POP_DISABLE_WARNING
 
     /// AZ_RTTI(BaseClass1,BaseClass2,BaseClass3,BaseClass4,BaseClass5)
     #define AZ_RTTI_6(_1, _2, _3, _4, _5)  AZ_RTTI_COMMON()                                          \
@@ -185,7 +175,7 @@ namespace AZ
         AZ::Internal::RttiCaller<_3>::RTTI_EnumHierarchy(cb, userData);                              \
         AZ::Internal::RttiCaller<_4>::RTTI_EnumHierarchy(cb, userData);                              \
         AZ::Internal::RttiCaller<_5>::RTTI_EnumHierarchy(cb, userData); }                            \
-    AZ_PUSH_DISABLE_OVERRIDE_WARNING                                                                 \
+    AZ_PUSH_DISABLE_WARNING(26433, "-Winconsistent-missing-override")                                \
     virtual inline const void*  RTTI_AddressOf(const AZ::TypeId& id) const {                         \
         if (id == RTTI_Type()) { return this; }                                                      \
         const void* r = AZ::Internal::RttiCaller<_1>::RTTI_AddressOf(this, id); if (r) { return r; } \
@@ -200,7 +190,7 @@ namespace AZ
         r = AZ::Internal::RttiCaller<_3>::RTTI_AddressOf(this, id); if (r) { return r; }             \
         r = AZ::Internal::RttiCaller<_4>::RTTI_AddressOf(this, id); if (r) { return r; }             \
         return AZ::Internal::RttiCaller<_5>::RTTI_AddressOf(this, id); }                             \
-    AZ_POP_DISABLE_OVERRIDE_WARNING
+    AZ_POP_DISABLE_WARNING
 
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     // MACRO specialization to allow optional parameters for template version of AZ_RTTI
@@ -951,10 +941,7 @@ namespace AZ
         {
             return AZStd::shared_ptr<DestType>(ptr, castPtr);
         }
-        else
-        {
-            return AZStd::shared_ptr<DestType>();
-        }
+        return AZStd::shared_ptr<DestType>();
     }
 
     // RttiCast specialization for intrusive_ptr.
@@ -1077,7 +1064,6 @@ namespace AZ
     {
         return AZ::Internal::RttiIsTypeOfIdHelper<U>::Check(id, data, typename HasAZRtti<AZStd::remove_pointer_t<U>>::kind_type());
     }
+
 } // namespace AZ
 
-#endif // AZCORE_RTTI_H
-#pragma once

Code/Framework/AzCore/AzCore/Serialization/Json/JsonSystemComponent.h

@@ -19,8 +19,8 @@ namespace AZ
     public:
         AZ_COMPONENT(JsonSystemComponent, "{3C2C7234-9512-4E24-86F0-C40865D7EECE}", Component);
 
-        void Activate();
-        void Deactivate();
+        void Activate() override;
+        void Deactivate() override;
 
         static void Reflect(ReflectContext* reflectContext);
     };

Code/Framework/AzCore/AzCore/Serialization/Json/MapSerializer.h

@@ -46,7 +46,8 @@ namespace AZ
     public:
         AZ_RTTI(JsonUnorderedMapSerializer, "{EF4478D3-1820-4FDB-A7B7-C9711EB41602}", JsonMapSerializer);
         AZ_CLASS_ALLOCATOR_DECL;
-        
+
+        using JsonMapSerializer::Store;
         JsonSerializationResult::Result Store(rapidjson::Value& outputValue, const void* inputValue, const void* defaultValue,
             const Uuid& valueTypeId, JsonSerializerContext& context) override;
     };
@@ -63,6 +64,7 @@ namespace AZ
             const SerializeContext::ClassElement* keyElement, const SerializeContext::ClassElement* valueElement,
             const rapidjson::Value& key, const rapidjson::Value& value, JsonDeserializerContext& context) override;
 
+        using JsonMapSerializer::Store;
         JsonSerializationResult::Result Store(rapidjson::Value& outputValue, const void* inputValue, const void* defaultValue,
             const Uuid& valueTypeId, JsonSerializerContext& context) override;
     };

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp

@@ -78,6 +78,7 @@ namespace AZ::Internal
 
             struct EnginePathsVisitor : public AZ::SettingsRegistryInterface::Visitor
             {
+                using AZ::SettingsRegistryInterface::Visitor::Visit;
                 void Visit(
                     [[maybe_unused]] AZStd::string_view path, AZStd::string_view valueName,
                     [[maybe_unused]] AZ::SettingsRegistryInterface::Type type, AZStd::string_view value) override
@@ -355,6 +356,7 @@ namespace AZ::SettingsRegistryMergeUtils
                 : m_settingsSpecialization{ specializations }
             {}
 
+            using AZ::SettingsRegistryInterface::Visitor::Visit;
             void Visit([[maybe_unused]] AZStd::string_view path, AZStd::string_view valueName,
                 [[maybe_unused]] AZ::SettingsRegistryInterface::Type type, bool value) override
             {
@@ -761,6 +763,7 @@ namespace AZ::SettingsRegistryMergeUtils
                     return SettingsRegistryInterface::VisitResponse::Continue;
                 }
 
+                using AZ::SettingsRegistryInterface::Visitor::Visit;
                 void Visit(AZStd::string_view, [[maybe_unused]] AZStd::string_view valueName, SettingsRegistryInterface::Type, AZStd::string_view value) override
                 {
                     if (processingSourcePathKey)
@@ -896,6 +899,7 @@ namespace AZ::SettingsRegistryMergeUtils
         struct CommandLineVisitor
             : AZ::SettingsRegistryInterface::Visitor
         {
+            using AZ::SettingsRegistryInterface::Visitor::Visit;
             void Visit(AZStd::string_view, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type
                 , AZStd::string_view value) override
             {

Code/Framework/AzCore/AzCore/UnitTest/TestTypes.h

@@ -131,17 +131,23 @@ namespace UnitTest
         , public AllocatorsBase
     {
     public:
-        // Bring in both const and non-const SetUp and TearDown function into scope to resolve warning 4266
-        // no override available for virtual member function from base 'benchmark::Fixture'; function is hidden
-        using ::benchmark::Fixture::SetUp, ::benchmark::Fixture::TearDown;
-
         //Benchmark interface
+        void SetUp(const ::benchmark::State& st) override
+        {
+            AZ_UNUSED(st);
+            SetupAllocator();
+        }
         void SetUp(::benchmark::State& st) override
         {
             AZ_UNUSED(st);
             SetupAllocator();
         }
 
+        void TearDown(const ::benchmark::State& st) override
+        {
+            AZ_UNUSED(st);
+            TeardownAllocator();
+        }
         void TearDown(::benchmark::State& st) override
         {
             AZ_UNUSED(st);

Code/Framework/AzCore/AzCore/UserSettings/UserSettingsProvider.h

@@ -116,9 +116,9 @@ namespace AZ
 
         //////////////////////////////////////////////////////////////////////////
         // UserSettingsBus
-        virtual AZStd::intrusive_ptr<UserSettings>  FindUserSettings(u32 id);
-        virtual void                                AddUserSettings(u32 id, UserSettings* settings);
-        virtual bool                                Save(const char* settingsPath, SerializeContext* sc);
+        AZStd::intrusive_ptr<UserSettings>  FindUserSettings(u32 id) override;
+        void                                AddUserSettings(u32 id, UserSettings* settings) override;
+        bool                                Save(const char* settingsPath, SerializeContext* sc) override;
         //////////////////////////////////////////////////////////////////////////
 
         static void Reflect(ReflectContext* reflection);

Code/Framework/AzCore/AzCore/std/algorithm.h

@@ -831,7 +831,6 @@ namespace AZStd
         // find first element that value is before, using operator<
         typename iterator_traits<ForwardIterator>::difference_type count = AZStd::distance(first, last);
         typename iterator_traits<ForwardIterator>::difference_type step{};
-        count = AZStd::distance(first, last);
         for (; 0 < count; )
         {   // divide and conquer, find half that contains answer
             step = count / 2;

Code/Framework/AzCore/AzCore/std/parallel/thread.h

@@ -187,7 +187,7 @@ namespace AZStd
                 : m_f(AZStd::move(f)) {}
             thread_info_impl(Internal::thread_move_t<F> f)
                 : m_f(f) {}
-            virtual void execute() { m_f(); }
+            void execute() override { m_f(); }
         private:
             F m_f;
 

Code/Framework/AzCore/AzCore/std/smart_ptr/shared_count.h

@@ -129,16 +129,16 @@ namespace AZStd
             {
             }
 
-            virtual void dispose() // nothrow
+            void dispose() override // nothrow
             {
                 AZStd::checked_delete(px_);
             }
-            virtual void destroy() // nothrow
+            void destroy() override // nothrow
             {
                 this->~this_type();
                 a_.deallocate(this, sizeof(this_type), AZStd::alignment_of<this_type>::value);
             }
-            virtual void* get_deleter(Internal::sp_typeinfo const&)
+            void* get_deleter(Internal::sp_typeinfo const&) override
             {
                 return 0;
             }
@@ -176,18 +176,18 @@ namespace AZStd
             {
             }
 
-            virtual void dispose() // nothrow
+            void dispose() override // nothrow
             {
                 d_(p_);
             }
 
-            virtual void destroy() // nothrow
+            void destroy() override // nothrow
             {
                 this->~this_type();
                 a_.deallocate(this, sizeof(this_type), AZStd::alignment_of<this_type>::value);
             }
 
-            virtual void* get_deleter(Internal::sp_typeinfo const& ti)
+            void* get_deleter(Internal::sp_typeinfo const& ti) override
             {
                 return ti == aztypeid(D) ? &reinterpret_cast<char&>(d_) : 0;
             }

Code/Framework/AzCore/AzCore/std/string/regex.h

@@ -215,6 +215,7 @@ namespace AZStd
 
         struct ErrorSink
         {
+            virtual ~ErrorSink() = default;
             virtual void RegexError(regex_constants::error_type code) = 0;
         };
     }
@@ -1079,7 +1080,7 @@ namespace AZStd
         NodeBase* m_next;
         NodeBase* m_previous;
 
-        virtual ~NodeBase() { }
+        virtual ~NodeBase() = default;
     };
 
     inline void DestroyNode(NodeBase* node, NodeBase* end = nullptr)
@@ -1758,7 +1759,7 @@ namespace AZStd
             return (*this);
         }
 
-        ~basic_regex()
+        ~basic_regex() override
         {   // destroy the object
             Clear();
         }
@@ -2916,7 +2917,7 @@ namespace AZStd
     }
 
     template<class ForwardIterator, class Element, class RegExTraits>
-    inline NodeBase* Builder<ForwardIterator, Element, RegExTraits>::BeginGroup(void)
+    inline NodeBase* Builder<ForwardIterator, Element, RegExTraits>::BeginGroup()
     {   // add group node
         return (NewNode(NT_group));
     }
@@ -3026,7 +3027,7 @@ namespace AZStd
     }
 
     template<class ForwardIterator, class Element, class RegExTraits>
-    inline RootNode* Builder<ForwardIterator, Element, RegExTraits>::EndPattern(void)
+    inline RootNode* Builder<ForwardIterator, Element, RegExTraits>::EndPattern()
     {   // wrap up
         NewNode(NT_end);
         return m_root;

Code/Framework/AzCore/Platform/Common/WinAPI/AzCore/Memory/OverrunDetectionAllocator_WinAPI.h

@@ -21,7 +21,7 @@ namespace AZ
         class WinAPIOverrunDetectionSchema : public OverrunDetectionSchema::PlatformAllocator
         {
         public:
-            virtual SystemInformation GetSystemInformation() override
+            SystemInformation GetSystemInformation() override
             {
                 SystemInformation result;
                 SYSTEM_INFO info;
@@ -32,7 +32,7 @@ namespace AZ
                 return result;
             }
 
-            virtual void* ReserveBytes(size_t amount) override
+            void* ReserveBytes(size_t amount) override
             {
                 void* result = VirtualAlloc(0, amount, MEM_RESERVE, PAGE_NOACCESS);
 
@@ -45,12 +45,12 @@ namespace AZ
                 return result;
             }
 
-            virtual void ReleaseReservedBytes(void* base) override
+            void ReleaseReservedBytes(void* base) override
             {
                 VirtualFree(base, 0, MEM_RELEASE);
             }
 
-            virtual void* CommitBytes(void* base, size_t amount) override
+            void* CommitBytes(void* base, size_t amount) override
             {
                 void* result = VirtualAlloc(base, amount, MEM_COMMIT, PAGE_READWRITE);
 
@@ -63,7 +63,7 @@ namespace AZ
                 return result;
             }
 
-            virtual void DecommitBytes(void* base, size_t amount) override
+            void DecommitBytes(void* base, size_t amount) override
             {
                 VirtualFree(base, amount, MEM_DECOMMIT);
             }

Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StreamerConfiguration_Windows.cpp

@@ -267,6 +267,7 @@ namespace AZ::IO
                     SettingsRegistryInterface::VisitResponse::Continue : SettingsRegistryInterface::VisitResponse::Skip;
             }
 
+            using SettingsRegistryInterface::Visitor::Visit;
             void Visit([[maybe_unused]] AZStd::string_view path, [[maybe_unused]] AZStd::string_view valueName,
                 [[maybe_unused]] AZ::SettingsRegistryInterface::Type type, AZStd::string_view value) override
             {

Code/Framework/AzCore/Tests/AssetJsonSerializerTests.cpp

@@ -100,6 +100,7 @@ namespace JsonSerializationTests
             AZ::AllocatorInstance<AZ::PoolAllocator>::Destroy();
         }
 
+        using JsonSerializerConformityTestDescriptor<AZ::Data::Asset<TestAssetData>>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<Asset>();

Code/Framework/AzCore/Tests/IO/Path/PathTests.cpp

@@ -956,18 +956,8 @@ AZ_POP_DISABLE_WARNING
 namespace Benchmark
 {
     class PathBenchmarkFixture
-        : public ::benchmark::Fixture
-        , public ::UnitTest::AllocatorsBase
+        : public ::UnitTest::AllocatorsBenchmarkFixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
-        {
-            ::UnitTest::AllocatorsBase::SetupAllocator();
-        }
-        void TearDown([[maybe_unused]] const ::benchmark::State& state) override
-        {
-            ::UnitTest::AllocatorsBase::TeardownAllocator();
-        }
     protected:
         AZStd::fixed_vector<const char*, 20> m_appendPaths{ "foo", "bar", "baz", "bazzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
             "boo/bar/base", "C:\\path\\to\\O3DE", "C", "\\\\", "/", R"(test\\path/with\mixed\separators)" };

Code/Framework/AzCore/Tests/Jobs.cpp

@@ -1704,7 +1704,7 @@ namespace Benchmark
         static const AZ::u32 MEDIUM_NUMBER_OF_JOBS = 1024;
         static const AZ::u32 LARGE_NUMBER_OF_JOBS = 16384;
 
-        void SetUp([[maybe_unused]] ::benchmark::State& state) override
+        void internalSetUp()
         {
             AllocatorInstance<PoolAllocator>::Create();
             AllocatorInstance<ThreadPoolAllocator>::Create();
@@ -1749,8 +1749,16 @@ namespace Benchmark
                 return randomDepthDistribution(randomDepthGenerator);
             });
         }
+        void SetUp(::benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(const ::benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
-        void TearDown([[maybe_unused]] ::benchmark::State& state) override
+        void internalTearDown()
         {
             JobContext::SetGlobalContext(nullptr);
 
@@ -1763,6 +1771,14 @@ namespace Benchmark
             AllocatorInstance<ThreadPoolAllocator>::Destroy();
             AllocatorInstance<PoolAllocator>::Destroy();
         }
+        void TearDown(::benchmark::State&) override
+        {
+            internalTearDown();
+        }
+        void TearDown(const ::benchmark::State&) override
+        {
+            internalTearDown();
+        }
 
     protected:
         inline void RunCalculatePiJob(AZ::s32 depth, AZ::s8 priority)

Code/Framework/AzCore/Tests/Math/FrustumPerformanceTests.cpp

@@ -19,8 +19,7 @@ namespace Benchmark
     class BM_MathFrustum
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_testFrustum = AZ::Frustum(AZ::ViewFrustumAttributes(AZ::Transform::CreateIdentity(), 1.0f, 2.0f * atanf(0.5f), 10.0f, 90.0f));
 
@@ -40,6 +39,15 @@ namespace Benchmark
                 return data;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct Data
         {

Code/Framework/AzCore/Tests/Math/Matrix3x3PerformanceTests.cpp

@@ -23,8 +23,7 @@ namespace Benchmark
     class BM_MathMatrix3x3
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_testDataArray.resize(1000);
 
@@ -44,6 +43,15 @@ namespace Benchmark
                 return testData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct TestData
         {

Code/Framework/AzCore/Tests/Math/Matrix3x4PerformanceTests.cpp

@@ -21,8 +21,7 @@ namespace Benchmark
     class BM_MathMatrix3x4
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const::benchmark::State& state) override
+        void internalSetUp()
         {
             m_testDataArray.resize(1000);
 
@@ -58,6 +57,15 @@ namespace Benchmark
                 return testData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct TestData
         {

Code/Framework/AzCore/Tests/Math/Matrix4x4PerformanceTests.cpp

@@ -20,8 +20,7 @@ namespace Benchmark
     class BM_MathMatrix4x4
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_testDataArray.resize(1000);
 
@@ -41,6 +40,15 @@ namespace Benchmark
                 return testData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct TestData
         {

Code/Framework/AzCore/Tests/Math/ObbPerformanceTests.cpp

@@ -19,8 +19,7 @@ namespace Benchmark
     class BM_MathObb
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_position.Set(1.0f, 2.0f, 3.0f);
             m_rotation = AZ::Quaternion::CreateRotationZ(AZ::Constants::QuarterPi);
@@ -28,6 +27,16 @@ namespace Benchmark
             m_obb = AZ::Obb::CreateFromPositionRotationAndHalfLengths(m_position, m_rotation, m_halfLengths);
         }
 
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
+
         AZ::Obb m_obb;
         AZ::Vector3 m_position;
         AZ::Quaternion m_rotation;

Code/Framework/AzCore/Tests/Math/PlanePerformanceTests.cpp

@@ -18,14 +18,7 @@ namespace Benchmark
     class BM_MathPlane
         : public benchmark::Fixture
     {
-    public:
-        BM_MathPlane()
-        {
-            const unsigned int seed = 1;
-            rng = std::mt19937_64(seed);
-        }
-
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             for (int i = 0; i < m_numIters; ++i)
             {
@@ -39,7 +32,7 @@ namespace Benchmark
                 m_distance = unif(rng);
                 m_dists.push_back(m_distance);
 
-                //set these differently so they don't overlap with same values as other vectors
+                // set these differently so they don't overlap with same values as other vectors
                 m_normal = AZ::Vector3(unif(rng), unif(rng), unif(rng));
                 m_normal.Normalize();
                 m_distance = unif(rng);
@@ -47,6 +40,21 @@ namespace Benchmark
                 m_planes.push_back(m_plane);
             }
         }
+    public:
+        BM_MathPlane()
+        {
+            const unsigned int seed = 1;
+            rng = std::mt19937_64(seed);
+        }
+
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         AZ::Plane m_plane;
         AZ::Vector3 m_normal;

Code/Framework/AzCore/Tests/Math/QuaternionPerformanceTests.cpp

@@ -17,8 +17,7 @@ namespace Benchmark
     class BM_MathQuaternion
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_quatDataArray.resize(1000);
 
@@ -42,6 +41,15 @@ namespace Benchmark
                 return quatData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct QuatData
         {

Code/Framework/AzCore/Tests/Math/ShapeIntersectionPerformanceTests.cpp

@@ -35,8 +35,7 @@ namespace Benchmark
     class BM_MathShapeIntersection
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_testDataArray.resize(1000);
 
@@ -58,6 +57,15 @@ namespace Benchmark
                 return testData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct TestData
         {

Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp

@@ -22,8 +22,7 @@ namespace Benchmark
     class BM_MathTransform
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_testDataArray.resize(1000);
 
@@ -51,6 +50,15 @@ namespace Benchmark
                 return testData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct TestData
         {

Code/Framework/AzCore/Tests/Math/Vector2PerformanceTests.cpp

@@ -19,8 +19,7 @@ namespace Benchmark
     class BM_MathVector2
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_vecDataArray.resize(1000);
 
@@ -37,6 +36,15 @@ namespace Benchmark
                 return vecData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct VecData
         {

Code/Framework/AzCore/Tests/Math/Vector3PerformanceTests.cpp

@@ -19,8 +19,7 @@ namespace Benchmark
     class BM_MathVector3
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_vecDataArray.resize(1000);
 
@@ -37,6 +36,15 @@ namespace Benchmark
                 return vecData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct VecData
         {

Code/Framework/AzCore/Tests/Math/Vector4PerformanceTests.cpp

@@ -19,8 +19,7 @@ namespace Benchmark
     class BM_MathVector4
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             m_vecDataArray.resize(1000);
 
@@ -38,6 +37,15 @@ namespace Benchmark
                 return vecData;
             });
         }
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
 
         struct VecData
         {

Code/Framework/AzCore/Tests/Memory/HphaSchema.cpp

@@ -120,19 +120,34 @@ namespace Benchmark
     class HphaSchemaBenchmarkFixture 
         : public ::benchmark::Fixture
     {
-    public:
-        void SetUp(const ::benchmark::State& state) override
+        void internalSetUp()
         {
-            AZ_UNUSED(state);
             AZ::AllocatorInstance<HphaSchema_TestAllocator>::Create();
         }
 
-        void TearDown(const ::benchmark::State& state) override
+        void internalTearDown()
         {
-            AZ_UNUSED(state);
             AZ::AllocatorInstance<HphaSchema_TestAllocator>::Destroy();
         }
 
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void TearDown(const benchmark::State&) override
+        {
+            internalTearDown();
+        }
+        void TearDown(benchmark::State&) override
+        {
+            internalTearDown();
+        }
+
         static void BM_Allocations(benchmark::State& state, const AllocationSizeArray& allocationArray)
         {
             AZStd::vector<void*> allocations;

Code/Framework/AzCore/Tests/Platform/Windows/Tests/IO/Streamer/StorageDriveTests_Windows.cpp

@@ -1155,6 +1155,23 @@ namespace Benchmark
 {
     class StorageDriveWindowsFixture : public benchmark::Fixture
     {
+        void internalTearDown()
+        {
+            using namespace AZ::IO;
+
+            AZStd::string temp;
+            m_absolutePath.swap(temp);
+
+            delete m_streamer;
+            m_streamer = nullptr;
+
+            SystemFile::Delete(TestFileName);
+
+            AZ::IO::FileIOBase::SetInstance(nullptr);
+            AZ::IO::FileIOBase::SetInstance(m_previousFileIO);
+            delete m_fileIO;
+            m_fileIO = nullptr;
+        }
     public:
         constexpr static const char* TestFileName = "StreamerBenchmark.bin";
         constexpr static size_t FileSize = 64_mib;
@@ -1197,20 +1214,13 @@ namespace Benchmark
             }
         }
 
-        void TearDown([[maybe_unused]] const ::benchmark::State& state) override
+        void TearDown(const benchmark::State&) override
         {
-            using namespace AZ::IO;
-
-            AZStd::string temp;
-            m_absolutePath.swap(temp);
-
-            delete m_streamer;
-
-            SystemFile::Delete(TestFileName);
-            
-            AZ::IO::FileIOBase::SetInstance(nullptr);
-            AZ::IO::FileIOBase::SetInstance(m_previousFileIO);
-            delete m_fileIO;
+            internalTearDown();
+        }
+        void TearDown(benchmark::State&) override
+        {
+            internalTearDown();
         }
 
         void RepeatedlyReadFile(benchmark::State& state)

Code/Framework/AzCore/Tests/Serialization/Json/ArraySerializerTests.cpp

@@ -35,6 +35,7 @@ namespace JsonSerializationTests
             features.m_fixedSizeArray = true;
         }
 
+        using JsonSerializerConformityTestDescriptor<T>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<T>();
@@ -243,6 +244,7 @@ namespace JsonSerializationTests
             ])";
         }
 
+        using ArraySerializerTestDescriptionBase<AZStd::array<BaseClass2*, 4>>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             Base::Reflect(context);
@@ -299,6 +301,7 @@ namespace JsonSerializationTests
         AZ::JsonArraySerializer m_serializer;
 
     public:
+        using BaseJsonSerializerFixture::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<Array>();

Code/Framework/AzCore/Tests/Serialization/Json/BasicContainerSerializerTests.cpp

@@ -60,6 +60,7 @@ namespace JsonSerializationTests
             return "[188, 288, 388]";
         }
 
+        using BasicContainerConformityTestDescriptor<Container>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<Container>();
@@ -133,6 +134,7 @@ namespace JsonSerializationTests
             return "[188, 288, 388]";
         }
 
+        using BasicContainerConformityTestDescriptor<Container>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<Container>();
@@ -225,6 +227,7 @@ namespace JsonSerializationTests
             features.m_supportsPartialInitialization = true;
         }
 
+        using BasicContainerConformityTestDescriptor<Container>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             SimpleClass::Reflect(context, true);
@@ -291,6 +294,7 @@ namespace JsonSerializationTests
         using Container = AZStd::vector<SimpleClass>;
         using BaseClassContainer = AZStd::vector<AZStd::shared_ptr<BaseClass>>;
 
+        using JsonBasicContainerSerializerTests::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& serializeContext) override
         {
             SimpleClass::Reflect(serializeContext, true);
@@ -352,6 +356,7 @@ namespace JsonSerializationTests
         static constexpr size_t ContainerSize = 4;
         using Container = AZStd::fixed_vector<int, ContainerSize>;
 
+        using JsonBasicContainerSerializerTests::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& serializeContext) override
         {
             serializeContext->RegisterGenericType<Container>();
@@ -387,6 +392,7 @@ namespace JsonSerializationTests
     public:
         using Set = AZStd::set<int>;
 
+        using JsonBasicContainerSerializerTests::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& serializeContext) override
         {
             serializeContext->RegisterGenericType<Set>();

Code/Framework/AzCore/Tests/Serialization/Json/BoolSerializerTests.cpp

@@ -83,6 +83,7 @@ namespace JsonSerializationTests
             BaseJsonSerializerFixture::TearDown();
         }
 
+        using BaseJsonSerializerFixture::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& serializeContext) override
         {
             serializeContext->Class<BoolPointerWrapper>()

Code/Framework/AzCore/Tests/Serialization/Json/DoubleSerializerTests.cpp

@@ -95,6 +95,7 @@ namespace JsonSerializationTests
             BaseJsonSerializerFixture::TearDown();
         }
 
+        using BaseJsonSerializerFixture::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& serializeContext) override
         {
             serializeContext->Class<DoublePointerWrapper>()

Code/Framework/AzCore/Tests/Serialization/Json/MapSerializerTests.cpp

@@ -44,6 +44,7 @@ namespace JsonSerializationTests
             features.m_supportsPartialInitialization = false;
         }
 
+        using JsonSerializerConformityTestDescriptor<Map>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<Map>();
@@ -247,6 +248,7 @@ namespace JsonSerializationTests
             features.m_supportsPartialInitialization = true;
         }
 
+        using MapBaseTestDescription<T<SimpleClass*, SimpleClass*>, Serializer>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             SimpleClass::Reflect(context, true);

Code/Framework/AzCore/Tests/Serialization/Json/SmartPointerSerializerTests.cpp

@@ -33,6 +33,7 @@ namespace JsonSerializationTests
             return AZStd::make_shared<SmartPointer>();
         }
 
+        using JsonSerializerConformityTestDescriptor<SmartPointer>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<SmartPointer>();
@@ -102,6 +103,7 @@ namespace JsonSerializationTests
             return *lhs == *rhs;
         }
 
+        using Base::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             SimpleClass::Reflect(context, true);
@@ -176,6 +178,7 @@ namespace JsonSerializationTests
             features.m_supportsPartialInitialization = true;
         }
 
+        using SmartPointerBaseTestDescription<T<BaseClass>>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             SimpleInheritence::Reflect(context, true);
@@ -340,6 +343,7 @@ namespace JsonSerializationTests
             features.m_supportsPartialInitialization = true;
         }
 
+        using SmartPointerBaseTestDescription<T<BaseClass2>>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             MultipleInheritence::Reflect(context, true);
@@ -513,7 +517,8 @@ namespace JsonSerializationTests
     public:
         using SmartPointer = typename SmartPointerSimpleDerivedClassTestDescription<AZStd::shared_ptr>::SmartPointer;
         using InstanceSmartPointer = AZStd::shared_ptr<SimpleInheritence>;
-        
+
+        using BaseJsonSerializerFixture::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             m_description.Reflect(context);

Code/Framework/AzCore/Tests/Serialization/Json/TupleSerializerTests.cpp

@@ -72,6 +72,7 @@ namespace JsonSerializationTests
             TupleSerializerTestsInternal::ConfigureFeatures(features);
         }
 
+        using JsonSerializerConformityTestDescriptor<AZStd::pair<int, double>>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->Class<PairPlaceholder>()->Field("pair", &PairPlaceholder::m_pair);
@@ -126,6 +127,7 @@ namespace JsonSerializationTests
             TupleSerializerTestsInternal::ConfigureFeatures(features);
         }
 
+        using JsonSerializerConformityTestDescriptor<Tuple>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<Tuple>();
@@ -344,6 +346,7 @@ namespace JsonSerializationTests
             features.m_enableNewInstanceTests = false;
         }
 
+        using JsonSerializerConformityTestDescriptor::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->Class<TupleClass>()
@@ -477,6 +480,7 @@ namespace JsonSerializationTests
             features.m_typeToInject = rapidjson::kNullType;
         }
 
+        using JsonSerializerConformityTestDescriptor<Tuple>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<Tuple>();
@@ -535,6 +539,7 @@ namespace JsonSerializationTests
             BaseJsonSerializerFixture::TearDown();
         }
 
+        using BaseJsonSerializerFixture::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& serializeContext) override
         {
             SimpleClass::Reflect(serializeContext, true);

Code/Framework/AzCore/Tests/Serialization/Json/UnorderedSetSerializerTests.cpp

@@ -54,6 +54,7 @@ namespace JsonSerializationTests
             features.m_supportsPartialInitialization = false;
         }
 
+        using JsonSerializerConformityTestDescriptor<AZStd::unordered_set<int>>::Reflect;
         void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context) override
         {
             context->RegisterGenericType<Set>();
@@ -108,6 +109,7 @@ namespace JsonSerializationTests
             context->RegisterGenericType<MultiSet>();
         }
 
+        using JsonSerializerConformityTestDescriptor<MultiSet>::Reflect;
         bool AreEqual(const MultiSet& lhs, const MultiSet& rhs) override
         {
             return
@@ -139,6 +141,7 @@ namespace JsonSerializationTests
             BaseJsonSerializerFixture::TearDown();
         }
 
+        using BaseJsonSerializerFixture::RegisterAdditional;
         void RegisterAdditional(AZStd::unique_ptr<AZ::SerializeContext>& serializeContext) override
         {
             serializeContext->RegisterGenericType<Set>();

Code/Framework/AzCore/Tests/SettingsRegistryTests.cpp

@@ -423,6 +423,8 @@ namespace SettingsRegistryTests
 
         struct : public AZ::SettingsRegistryInterface::Visitor
         {
+            using AZ::SettingsRegistryInterface::Visitor::Visit;
+
             using ValueType [[maybe_unused]] = typename SettingsType<TypeParam>::ValueType;
             void Visit([[maybe_unused]] AZStd::string_view path, [[maybe_unused]] AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type type, ValueType value) override
             {
@@ -452,6 +454,8 @@ namespace SettingsRegistryTests
 
         struct : public AZ::SettingsRegistryInterface::Visitor
         {
+            using AZ::SettingsRegistryInterface::Visitor::Visit;
+
             using ValueType [[maybe_unused]] = typename SettingsType<TypeParam>::ValueType;
             void Visit([[maybe_unused]] AZStd::string_view path, [[maybe_unused]] AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type type, ValueType value) override
             {
@@ -482,6 +486,7 @@ namespace SettingsRegistryTests
 
         struct : public AZ::SettingsRegistryInterface::Visitor
         {
+            using AZ::SettingsRegistryInterface::Visitor::Visit;
             void Visit([[maybe_unused]] AZStd::string_view path, [[maybe_unused]] AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type type, AZ::s64 value) override
             {
                 EXPECT_EQ(AZ::SettingsRegistryInterface::Type::Integer, type);
@@ -517,6 +522,8 @@ namespace SettingsRegistryTests
                 EXPECT_TRUE(path.ends_with(valueName));
                 return AZ::SettingsRegistryInterface::VisitResponse::Continue;
             }
+
+            using AZ::SettingsRegistryInterface::Visitor::Visit;
             void Visit(AZStd::string_view path, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type , AZStd::string_view)override
             {
                 EXPECT_TRUE(path.ends_with(valueName));

Code/Framework/AzCore/Tests/TaskTests.cpp

@@ -551,19 +551,37 @@ namespace Benchmark
 {
     class TaskGraphBenchmarkFixture : public ::benchmark::Fixture
     {
-    public:
-        void SetUp(benchmark::State&) override
+        void internalSetUp()
         {
             executor = new TaskExecutor;
             graph = new TaskGraph;
         }
 
-        void TearDown(benchmark::State&) override
+        void internalTearDown()
         {
             delete graph;
             delete executor;
         }
 
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
+
+        void TearDown(const benchmark::State&) override
+        {
+            internalTearDown();
+        }
+        void TearDown(benchmark::State&) override
+        {
+            internalTearDown();
+        }
+
         TaskDescriptor descriptors[4] = { { "critical", "benchmark", TaskPriority::CRITICAL },
                                          { "high", "benchmark", TaskPriority::HIGH },
                                          { "medium", "benchmark", TaskPriority::MEDIUM },

Code/Framework/AzFramework/AzFramework/Archive/ArchiveFileIO.h

@@ -65,7 +65,7 @@ namespace AZ::IO
         void SetAlias(const char* alias, const char* path) override;
         void ClearAlias(const char* alias) override;
         AZStd::optional<AZ::u64> ConvertToAlias(char* inOutBuffer, AZ::u64 bufferLength) const override;
-        bool ConvertToAlias(AZ::IO::FixedMaxPath& convertedPath, const AZ::IO::PathView& path) const;
+        bool ConvertToAlias(AZ::IO::FixedMaxPath& convertedPath, const AZ::IO::PathView& path) const override;
         using FileIOBase::ConvertToAlias;
         const char* GetAlias(const char* alias) const override;
         bool ResolvePath(const char* path, char* resolvedPath, AZ::u64 resolvedPathSize) const override;

Code/Framework/AzFramework/AzFramework/Archive/NestedArchive.h

@@ -40,7 +40,7 @@ namespace AZ::IO
         NestedArchive(IArchive* pArchive, AZStd::string_view strBindRoot, ZipDir::CachePtr pCache, uint32_t nFlags = 0);
         ~NestedArchive() override;
         
-        auto GetRootFolderHandle() -> Handle;
+        auto GetRootFolderHandle() -> Handle override;
 
         // Adds a new file to the zip or update an existing one
         // adds a directory (creates several nested directories if needed)
@@ -66,26 +66,26 @@ namespace AZ::IO
         int RemoveDir(AZStd::string_view szRelativePath) override;
         
         // deletes all files from the archive
-        int RemoveAll();
+        int RemoveAll() override;
 
         // finds the file; you don't have to close the returned handle
-        Handle FindFile(AZStd::string_view szRelativePath);
+        Handle FindFile(AZStd::string_view szRelativePath) override;
 
         // returns the size of the file (unpacked) by the handle
-        uint64_t GetFileSize(Handle fileHandle);
+        uint64_t GetFileSize(Handle fileHandle) override;
 
         // reads the file into the preallocated buffer (must be at least the size of GetFileSize())
-        int ReadFile(Handle fileHandle, void* pBuffer);
+        int ReadFile(Handle fileHandle, void* pBuffer) override;
 
         // returns the full path to the archive file
-        const char* GetFullPath() const;
+        const char* GetFullPath() const override;
         ZipDir::Cache* GetCache();
 
-        uint32_t GetFlags() const;
-        bool SetFlags(uint32_t nFlagsToSet);
-        bool ResetFlags(uint32_t nFlagsToReset);
+        uint32_t GetFlags() const override;
+        bool SetFlags(uint32_t nFlagsToSet) override;
+        bool ResetFlags(uint32_t nFlagsToReset) override;
 
-        bool SetPackAccessible(bool bAccessible);
+        bool SetPackAccessible(bool bAccessible) override;
 
     protected:
         // returns the pointer to the relative file path to be passed

Code/Framework/AzFramework/AzFramework/Asset/AssetProcessorMessages.h

@@ -866,7 +866,7 @@ namespace AzFramework
 
             FileIsReadOnlyResponse() = default;
             FileIsReadOnlyResponse(bool isReadOnly);
-            unsigned int GetMessageType() const;
+            unsigned int GetMessageType() const override;
 
             bool m_isReadOnly;
         };
@@ -945,7 +945,7 @@ namespace AzFramework
 
             FileModTimeRequest() = default;
             FileModTimeRequest(const AZ::OSString& filePath);
-            unsigned int GetMessageType() const;
+            unsigned int GetMessageType() const override;
 
             AZ::OSString m_filePath;
         };

Code/Framework/AzFramework/AzFramework/Asset/GenericAssetHandler.h

@@ -75,7 +75,7 @@ namespace AzFramework
     {
     public:
         AZ_RTTI(GenericAssetHandlerBase, "{B153B8B5-25CC-4BB7-A2BD-9A47ECF4123C}", AZ::Data::AssetHandler);
-        virtual ~GenericAssetHandlerBase() {}
+        virtual ~GenericAssetHandlerBase() = default;
     };
 
     template <typename AssetType>
@@ -186,7 +186,7 @@ namespace AzFramework
             }
         }
 
-        bool CanHandleAsset(const AZ::Data::AssetId& id) const
+        bool CanHandleAsset(const AZ::Data::AssetId& id) const override
         {
             AZStd::string assetPath;
             EBUS_EVENT_RESULT(assetPath, AZ::Data::AssetCatalogRequestBus, GetAssetPathById, id);

Code/Framework/AzFramework/AzFramework/Components/NonUniformScaleComponent.h

@@ -28,7 +28,7 @@ namespace AzFramework
         // AZ::NonUniformScaleRequests::Handler ...
         AZ::Vector3 GetScale() const override;
         void SetScale(const AZ::Vector3& scale) override;
-        void RegisterScaleChangedEvent(AZ::NonUniformScaleChangedEvent::Handler& handler);
+        void RegisterScaleChangedEvent(AZ::NonUniformScaleChangedEvent::Handler& handler) override;
 
     protected:
         // AZ::Component ...

Code/Framework/AzFramework/AzFramework/Entity/EntityDebugDisplayBus.h

@@ -105,7 +105,7 @@ namespace AzFramework
         virtual AZ::Matrix3x4 PopPremultipliedMatrix() { return AZ::Matrix3x4::CreateIdentity(); }
 
     protected:
-        ~DebugDisplayRequests() = default;
+        virtual ~DebugDisplayRequests() = default;
     };
 
     /// Inherit from DebugDisplayRequestBus::Handler to implement the DebugDisplayRequests interface.

Code/Framework/AzFramework/AzFramework/Entity/GameEntityContextComponent.h

@@ -69,7 +69,7 @@ namespace AzFramework
         // EntityContext
         AZ::Entity* CreateEntity(const char* name) override;
         void OnRootEntityReloaded() override;
-        void OnContextEntitiesAdded(const EntityList& entities);
+        void OnContextEntitiesAdded(const EntityList& entities) override;
         void OnContextReset() override;
         bool ValidateEntitiesAreValidForContext(const EntityList& entities) override;
         //////////////////////////////////////////////////////////////////////////

Code/Framework/AzFramework/AzFramework/Gem/GemInfo.cpp

@@ -34,6 +34,7 @@ namespace AzFramework
             {
             }
 
+            using AZ::SettingsRegistryInterface::Visitor::Visit;
             void Visit(AZStd::string_view path, AZStd::string_view, AZ::SettingsRegistryInterface::Type,
                 AZStd::string_view value) override
             {

Code/Framework/AzFramework/AzFramework/Logging/LoggingComponent.h

@@ -31,9 +31,9 @@ namespace AzFramework
 
         //////////////////////////////////////////////////////////////////////////
         // AZ::Component
-        virtual void Init();
-        virtual void Activate();
-        virtual void Deactivate();
+        void Init() override;
+        void Activate() override;
+        void Deactivate() override;
         //////////////////////////////////////////////////////////////////////////
 
         //////////////////////////////////////////////////////////////////////////

Code/Framework/AzFramework/AzFramework/TargetManagement/TargetManagementAPI.h

@@ -195,7 +195,7 @@ namespace AzFramework
         TmMsgCallback(const MsgCB& cb = NULL)
             : m_cb(cb) {}
 
-        virtual void OnReceivedMsg(TmMsgPtr msg)
+        void OnReceivedMsg(TmMsgPtr msg) override
         {
             if (m_cb)
             {

Code/Framework/AzFramework/AzFramework/UnitTest/TestDebugDisplayRequests.h

@@ -19,6 +19,8 @@ namespace UnitTest
     {
     public:
         TestDebugDisplayRequests();
+        ~TestDebugDisplayRequests() override = default;
+
         const AZStd::vector<AZ::Vector3>& GetPoints() const;
         void ClearPoints();
         //! Returns the AABB of the points generated from received draw calls.
@@ -27,7 +29,9 @@ namespace UnitTest
         // DebugDisplayRequests ...
         void DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max) override;
         void DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max) override;
+        using AzFramework::DebugDisplayRequests::DrawWireQuad;
         void DrawWireQuad(float width, float height) override;
+        using AzFramework::DebugDisplayRequests::DrawQuad;
         void DrawQuad(float width, float height) override;
         void DrawTriangles(const AZStd::vector<AZ::Vector3>& vertices, const AZ::Color& color) override;
         void DrawTrianglesIndexed(const AZStd::vector<AZ::Vector3>& vertices, const AZStd::vector<AZ::u32>& indices, const AZ::Color& color) override;

Code/Framework/AzFramework/AzFramework/Viewport/ViewportControllerList.h

@@ -45,10 +45,10 @@ namespace AzFramework
         //! All current and added controllers will be registered with this viewport.
         void RegisterViewportContext(ViewportId viewport) override;
         //! Unregisters a Viewport from this list and all associated controllers.
-        void UnregisterViewportContext(ViewportId viewport);
+        void UnregisterViewportContext(ViewportId viewport) override;
         //! All ViewportControllerLists have a priority of Custom to ensure
         //! that they receive events at all priorities from any parent controllers.
-        AzFramework::ViewportControllerPriority GetPriority() const { return ViewportControllerPriority::DispatchToAllPriorities; }
+        AzFramework::ViewportControllerPriority GetPriority() const override { return ViewportControllerPriority::DispatchToAllPriorities; }
         //! Returns true if this controller list is enabled, i.e.
         //! it is accepting and forwarding input and update events to its children.
         bool IsEnabled() const;

Code/Framework/AzFramework/Tests/OctreePerformanceTests.cpp

@@ -20,8 +20,7 @@ namespace Benchmark
     class BM_Octree
         : public benchmark::Fixture
     {
-    public:
-        void SetUp([[maybe_unused]] const ::benchmark::State& state) override
+        void internalSetUp()
         {
             // Create the SystemAllocator if not available
             if (!AZ::AllocatorInstance<AZ::SystemAllocator>::IsReady())
@@ -72,7 +71,7 @@ namespace Benchmark
             });
         }
 
-        void TearDown([[maybe_unused]] const ::benchmark::State& state) override
+        void internalTearDown()
         {
             m_octreeSystemComponent->DestroyVisibilityScene(m_visScene);
             delete m_octreeSystemComponent;
@@ -91,6 +90,25 @@ namespace Benchmark
             }
         }
 
+    public:
+        void SetUp(const benchmark::State&) override
+        {
+            internalSetUp();
+        }
+        void SetUp(benchmark::State&) override
+        {
+            internalSetUp();
+        }
+
+        void TearDown(const benchmark::State&) override
+        {
+            internalTearDown();
+        }
+        void TearDown(benchmark::State&) override
+        {
+            internalTearDown();
+        }
+
         void InsertEntries(uint32_t entryCount)
         {
             for (uint32_t i = 0; i < entryCount; ++i)

Code/Framework/AzManipulatorTestFramework/Include/AzManipulatorTestFramework/ViewportInteraction.h

@@ -40,7 +40,7 @@ namespace AzManipulatorTestFramework
 
         // ViewportInteractionRequestBus overrides ...
         AzFramework::CameraState GetCameraState() override;
-        AzFramework::ScreenPoint ViewportWorldToScreen(const AZ::Vector3& worldPosition);
+        AzFramework::ScreenPoint ViewportWorldToScreen(const AZ::Vector3& worldPosition) override;
         AZStd::optional<AZ::Vector3> ViewportScreenToWorld(const AzFramework::ScreenPoint& screenPosition, float depth) override;
         AZStd::optional<AzToolsFramework::ViewportInteraction::ProjectedViewportRay> ViewportScreenToWorldRay(
             const AzFramework::ScreenPoint& screenPosition) override;

Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpFragmentQueue.h

@@ -30,6 +30,7 @@ namespace AzNetworking
     {
 
     public:
+        virtual ~UdpFragmentQueue() = default;
 
         //! Updates the UdpFragmentQueue timeout queue.
         void Update();
@@ -53,7 +54,7 @@ namespace AzNetworking
         //! Handler callback for timed out items.
         //! @param item containing registered timeout details
         //! @return ETimeoutResult for whether to re-register or discard the timeout params
-        virtual TimeoutResult HandleTimeout(TimeoutQueue::TimeoutItem& item) override;
+        TimeoutResult HandleTimeout(TimeoutQueue::TimeoutItem& item) override;
 
         TimeoutQueue m_timeoutQueue;
         SequenceGenerator m_sequenceGenerator;

Code/Framework/AzNetworking/Tests/TcpTransport/TcpTransportTests.cpp

@@ -33,7 +33,7 @@ namespace UnitTest
             ;
         }
 
-        PacketDispatchResult OnPacketReceived([[maybe_unused]] IConnection* connection, const IPacketHeader& packetHeader, [[maybe_unused]] ISerializer& serializer)
+        PacketDispatchResult OnPacketReceived([[maybe_unused]] IConnection* connection, const IPacketHeader& packetHeader, [[maybe_unused]] ISerializer& serializer) override
         {
             EXPECT_TRUE((packetHeader.GetPacketType() == static_cast<PacketType>(CorePackets::PacketType::InitiateConnectionPacket))
                      || (packetHeader.GetPacketType() == static_cast<PacketType>(CorePackets::PacketType::HeartbeatPacket)));

Code/Framework/AzNetworking/Tests/UdpTransport/UdpTransportTests.cpp

@@ -36,7 +36,7 @@ namespace UnitTest
             ;
         }
 
-        PacketDispatchResult OnPacketReceived([[maybe_unused]] IConnection* connection, const IPacketHeader& packetHeader, [[maybe_unused]] ISerializer& serializer)
+        PacketDispatchResult OnPacketReceived([[maybe_unused]] IConnection* connection, const IPacketHeader& packetHeader, [[maybe_unused]] ISerializer& serializer) override
         {
             EXPECT_TRUE((packetHeader.GetPacketType() == static_cast<PacketType>(CorePackets::PacketType::InitiateConnectionPacket))
                      || (packetHeader.GetPacketType() == static_cast<PacketType>(CorePackets::PacketType::HeartbeatPacket)));

Code/Framework/AzQtComponents/AzQtComponents/Components/Style.h

@@ -137,8 +137,10 @@ namespace AzQtComponents
 
         int pixelMetric(QStyle::PixelMetric metric, const QStyleOption* option, const QWidget* widget) const override;
 
+        using QProxyStyle::polish;
         void polish(QApplication* application) override;
         void polish(QWidget* widget) override;
+        using QProxyStyle::unpolish;
         void unpolish(QWidget* widget) override;
 
         QPalette standardPalette() const override;

Code/Framework/AzTest/AzTest/AzTest.h

@@ -44,12 +44,12 @@ namespace AZ
             virtual ~ITestEnvironment()
             {}
 
-            void SetUp() override final
+            void SetUp() final
             {
                 SetupEnvironment();
             }
 
-            void TearDown() override final
+            void TearDown() final
             {
                 TeardownEnvironment();
             }
@@ -218,7 +218,7 @@ namespace AZ
         public:
             std::list<std::string> resultList;
             
-            void OnTestEnd(const ::testing::TestInfo& test_info)
+            void OnTestEnd(const ::testing::TestInfo& test_info) override
             {
                 std::string result;
                 if (test_info.result()->Failed())
@@ -233,7 +233,7 @@ namespace AZ
                 resultList.emplace_back(formattedResult);
             }
 
-            void OnTestProgramEnd(const ::testing::UnitTest& unit_test)
+            void OnTestProgramEnd(const ::testing::UnitTest& unit_test) override
             {
                 for (std::string testResults : resultList)
                 {

Code/Framework/AzToolsFramework/AzToolsFramework/Application/EditorEntityManager.h

@@ -17,7 +17,7 @@ namespace AzToolsFramework
         : public EditorEntityAPI
     {
     public:
-        ~EditorEntityManager();
+        virtual ~EditorEntityManager();
 
         void Start();
 

Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.h

@@ -37,7 +37,7 @@ namespace AzToolsFramework
         ToolsApplication(int* argc = nullptr, char*** argv = nullptr);
         ~ToolsApplication();
 
-        void Stop();
+        void Stop() override;
         void CreateReflectionManager() override;
         void Reflect(AZ::ReflectContext* context) override;
 

Code/Framework/AzToolsFramework/AzToolsFramework/Asset/AssetUtils.cpp

@@ -97,6 +97,7 @@ namespace AzToolsFramework::AssetUtils
     struct EnabledPlatformsVisitor
         : AZ::SettingsRegistryInterface::Visitor
     {
+        using AZ::SettingsRegistryInterface::Visitor::Visit;
         void Visit(AZStd::string_view path, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type, AZStd::string_view value) override;
 
         AZStd::vector<AZStd::string> m_enabledPlatforms;

Code/Framework/AzToolsFramework/AzToolsFramework/Commands/PreemptiveUndoCache.h

@@ -34,7 +34,7 @@ namespace AzToolsFramework
 
         static PreemptiveUndoCache* Get();
         PreemptiveUndoCache();
-        ~PreemptiveUndoCache();
+        virtual ~PreemptiveUndoCache();
 
         void RegisterToUndoCacheInterface();
 

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntitySortComponent.h

@@ -65,7 +65,7 @@ namespace AzToolsFramework
                 /**
                 * Called right before we start reading from the instance pointed by classPtr.
                 */
-                void OnReadBegin(void* classPtr)
+                void OnReadBegin(void* classPtr) override
                 {
                     EditorEntitySortComponent* component = reinterpret_cast<EditorEntitySortComponent*>(classPtr);
                     component->PrepareSave();

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceToTemplatePropagator.h

@@ -31,7 +31,7 @@ namespace AzToolsFramework
 
             void AppendEntityAliasToPatchPaths(PrefabDom& providedPatch, const AZ::EntityId& entityId) override;
 
-            InstanceOptionalReference GetTopMostInstanceInHierarchy(AZ::EntityId entityId);
+            InstanceOptionalReference GetTopMostInstanceInHierarchy(AZ::EntityId entityId) override;
 
             bool PatchTemplate(PrefabDomValue& providedPatch, TemplateId templateId, InstanceOptionalReference instanceToExclude = AZStd::nullopt) override;
 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndoCache.h

@@ -32,6 +32,8 @@ namespace AzToolsFramework
         public:
             AZ_CLASS_ALLOCATOR(PrefabUndoCache, AZ::SystemAllocator, 0);
 
+            virtual ~PrefabUndoCache() = default;
+
             void Initialize();
             void Destroy();
 

Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceMetadataEntityContextComponent.h

@@ -76,10 +76,10 @@ namespace AzToolsFramework
         void ResetContext() override;
         void GetRequiredComponentTypes(AZ::ComponentTypeList& required) override;
         bool IsSliceMetadataEntity(const AZ::EntityId entityId) override;
-        AZ::Entity* GetMetadataEntity(const AZ::EntityId entityId);
+        AZ::Entity* GetMetadataEntity(const AZ::EntityId entityId) override;
         AZ::EntityId GetMetadataEntityIdFromEditorEntity(const AZ::EntityId editorEntityId) override;
         AZ::EntityId GetMetadataEntityIdFromSliceAddress(const AZ::SliceComponent::SliceInstanceAddress& address) override;
-        void AddMetadataEntityToContext(const AZ::SliceComponent::SliceInstanceAddress& /*sliceAddress*/, AZ::Entity& entity);
+        void AddMetadataEntityToContext(const AZ::SliceComponent::SliceInstanceAddress& /*sliceAddress*/, AZ::Entity& entity) override;
         //////////////////////////////////////////////////////////////////////////
 
 

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorInspectorComponent.h

@@ -61,7 +61,7 @@ namespace AzToolsFramework
                 /** 
                  * Called right before we start reading from the instance pointed by classPtr.
                  */
-                void OnReadBegin(void* classPtr)
+                void OnReadBegin(void* classPtr) override
                 {
                     EditorInspectorComponent* component = reinterpret_cast<EditorInspectorComponent*>(classPtr);
                     component->PrepareSave();

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorNonUniformScaleComponent.h

@@ -37,7 +37,7 @@ namespace AzToolsFramework
             // AZ::NonUniformScaleRequestBus::Handler ...
             AZ::Vector3 GetScale() const override;
             void SetScale(const AZ::Vector3& scale) override;
-            void RegisterScaleChangedEvent(AZ::NonUniformScaleChangedEvent::Handler& handler);
+            void RegisterScaleChangedEvent(AZ::NonUniformScaleChangedEvent::Handler& handler) override;
 
         private:
             static void GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent);

Code/Framework/AzToolsFramework/AzToolsFramework/UI/LegacyFramework/Core/EditorFrameworkApplication.h

@@ -63,23 +63,23 @@ namespace LegacyFramework
 
         // ------------------------------------------------------------------
         // implementation of FrameworkApplicationMessages::Handler
-        virtual bool IsRunningInGUIMode() { return m_desc.m_enableGUI; }
-        virtual bool RequiresGameProject() { return m_desc.m_enableProjectManager; }
-        virtual bool ShouldRunAssetProcessor() { return m_desc.m_shouldRunAssetProcessor; }
-        virtual void* GetMainModule();
-        virtual const char* GetApplicationName();
-        virtual const char* GetApplicationModule();
-        virtual const char* GetApplicationDirectory();
-        virtual const AzFramework::CommandLine* GetCommandLineParser();
-        virtual void TeardownApplicationComponent();
-        virtual void RunAssetProcessor() override;
+        bool IsRunningInGUIMode() override { return m_desc.m_enableGUI; }
+        bool RequiresGameProject() override { return m_desc.m_enableProjectManager; }
+        bool ShouldRunAssetProcessor() override { return m_desc.m_shouldRunAssetProcessor; }
+        void* GetMainModule() override;
+        const char* GetApplicationName() override;
+        const char* GetApplicationModule() override;
+        const char* GetApplicationDirectory() override;
+        const AzFramework::CommandLine* GetCommandLineParser() override;
+        void TeardownApplicationComponent() override;
+        void RunAssetProcessor() override;
         // ------------------------------------------------------------------
 
         void SetSettingsRegistrySpecializations(AZ::SettingsRegistryInterface::Specializations& specializations) override;
 
         // ------------------------------------------------------------------
         // implementation of CoreMessageBus::Handler
-        virtual void OnProjectSet(const char*  /*pathToProject*/);
+        void OnProjectSet(const char*  /*pathToProject*/) override;
         // ------------------------------------------------------------------
 
         // This is called during the bootstrap and makes all the components we should have for SYSTEM minimal functionality.
@@ -114,17 +114,17 @@ namespace LegacyFramework
          * ComponentApplication::RegisterCoreComponents and then register the application
          * specific core components.
          */
-        virtual void RegisterCoreComponents();
+        void RegisterCoreComponents() override;
         AZ::Entity* m_ptrSystemEntity;
 
-        virtual int GetDesiredExitCode() override { return m_desiredExitCode; }
-        virtual void SetDesiredExitCode(int code) override { m_desiredExitCode = code; }
-        virtual bool GetAbortRequested() override { return m_abortRequested; }
-        virtual void SetAbortRequested() override { m_abortRequested = true; }
-        virtual AZStd::string GetApplicationGlobalStoragePath() override;
-        virtual bool IsPrimary() override { return m_isPrimary; }
+        int GetDesiredExitCode() override { return m_desiredExitCode; }
+        void SetDesiredExitCode(int code) override { m_desiredExitCode = code; }
+        bool GetAbortRequested() override { return m_abortRequested; }
+        void SetAbortRequested() override { m_abortRequested = true; }
+        AZStd::string GetApplicationGlobalStoragePath() override;
+        bool IsPrimary() override { return m_isPrimary; }
 
-        virtual bool IsAppConfigWritable() override;
+        bool IsAppConfigWritable() override;
 
         AZ::Entity* m_applicationEntity;
 

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Logging/LogPanel_Panel.h

@@ -300,13 +300,13 @@ namespace AzToolsFramework
             bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) override;
             void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
 
-            QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const;
+            QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
 
-            void setEditorData(QWidget* editor, const QModelIndex& index) const;
-            void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const;
+            void setEditorData(QWidget* editor, const QModelIndex& index) const override;
+            void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const override;
 
             QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override;
-            void updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const;
+            void updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
 
             QWidget* pOwnerWidget;
             QLabel* m_painterLabel;

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Logging/TracePrintFLogPanel.h

@@ -62,11 +62,11 @@ namespace AzToolsFramework
 
             //////////////////////////////////////////////////////////////////////////
             // TraceMessagesBus
-            virtual bool OnAssert(const char* message);
-            virtual bool OnException(const char* message);
-            virtual bool OnError(const char* window, const char* message);
-            virtual bool OnWarning(const char* window, const char* message);
-            virtual bool OnPrintf(const char* window, const char* message);
+            bool OnAssert(const char* message) override;
+            bool OnException(const char* message) override;
+            bool OnError(const char* window, const char* message) override;
+            bool OnWarning(const char* window, const char* message) override;
+            bool OnPrintf(const char* window, const char* message) override;
             //////////////////////////////////////////////////////////////////////////
 
             /// Log a message received from the TraceMessageBus

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerListModel.hxx

@@ -230,7 +230,7 @@ namespace AzToolsFramework
         bool DropMimeDataAssets(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent);
         bool CanDropMimeDataAssets(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const;
 
-        QMap<int, QVariant> itemData(const QModelIndex& index) const;
+        QMap<int, QVariant> itemData(const QModelIndex& index) const override;
         QVariant dataForAll(const QModelIndex& index, int role) const;
         QVariant dataForName(const QModelIndex& index, int role) const;
         QVariant dataForVisibility(const QModelIndex& index, int role) const;

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.hxx

@@ -139,8 +139,8 @@ namespace AzToolsFramework
         EntityPropertyEditor(QWidget* pParent = NULL, Qt::WindowFlags flags = Qt::WindowFlags(), bool isLevelEntityEditor = false);
         virtual ~EntityPropertyEditor();
 
-        virtual void BeforeUndoRedo();
-        virtual void AfterUndoRedo();
+        void BeforeUndoRedo() override;
+        void AfterUndoRedo() override;
 
         static void Reflect(AZ::ReflectContext* context);
 
@@ -249,8 +249,8 @@ namespace AzToolsFramework
         bool IsEntitySelected(const AZ::EntityId& id) const;
         bool IsSingleEntitySelected(const AZ::EntityId& id) const;
 
-        virtual void GotSceneSourceControlStatus(AzToolsFramework::SourceControlFileInfo& fileInfo);
-        virtual void PerformActionsBasedOnSceneStatus(bool sceneIsNew, bool readOnly);
+        void GotSceneSourceControlStatus(AzToolsFramework::SourceControlFileInfo& fileInfo) override;
+        void PerformActionsBasedOnSceneStatus(bool sceneIsNew, bool readOnly) override;
 
         // enable/disable editor
         void EnableEditor(bool enabled);

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/MultiLineTextEditHandler.h

@@ -41,7 +41,7 @@ namespace AzToolsFramework
 
         QWidget* CreateGUI(QWidget* parent) override;
         AZ::u32 GetHandlerName() const override;
-        bool AutoDelete() const;
+        bool AutoDelete() const override;
 
         void ConsumeAttribute(GrowTextEdit* widget, AZ::u32 attrib, AzToolsFramework::PropertyAttributeReader* attrValue, const char* debugName) override;
         void WriteGUIValuesIntoProperty(size_t index, GrowTextEdit* GUI, property_t& instance, AzToolsFramework::InstanceDataNode* node) override;

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h

@@ -55,12 +55,12 @@ namespace AzToolsFramework
         // GUI is a pointer to the GUI used to editor your property (the one you created in CreateGUI)
         // and instance is a the actual value (PropertyType).
         // you may not cache the pointer to anything.
-        virtual void WriteGUIValuesIntoProperty(size_t index, WidgetType* GUI, PropertyType& instance, InstanceDataNode* node) = 0;
+        void WriteGUIValuesIntoProperty(size_t index, WidgetType* GUI, PropertyType& instance, InstanceDataNode* node) override = 0;
 
         // this will get called in order to initialize your gui.  It will be called once for each instance.
         // for example if you have multiple objects selected, index will go from 0 to however many there are.
         // you may not cache the pointer to anything.
-        virtual bool ReadValuesIntoGUI(size_t index, WidgetType* GUI, const PropertyType& instance, InstanceDataNode* node) = 0;
+        bool ReadValuesIntoGUI(size_t index, WidgetType* GUI, const PropertyType& instance, InstanceDataNode* node) override = 0;
 
         // this will be called in order to initialize or refresh your gui.  Your class will be fed one attribute at a time
         // you may override this to interpret the attributes as you wish - use attrValue->Read<int>() for example, to interpret it as an int.
@@ -87,19 +87,19 @@ namespace AzToolsFramework
         // and cause the next row to tab to your last button, when the user hits shift+tab on the next row.
         // if your widget is a single widget or has a single focus proxy there is no need to override.
         // you may not cache the pointer to anything.
-        virtual QWidget* GetFirstInTabOrder(WidgetType* widget) { return widget; }
-        virtual QWidget* GetLastInTabOrder(WidgetType* widget) { return widget; }
+        QWidget* GetFirstInTabOrder(WidgetType* widget) override { return widget; }
+        QWidget* GetLastInTabOrder(WidgetType* widget) override { return widget; }
 
         // implement this function in order to set your internal tab order between child controls.
         // just call a series of QWidget::setTabOrder
         // you may not cache the pointer to anything.
-        virtual void UpdateWidgetInternalTabbing(WidgetType* /*widget*/) { }
+        void UpdateWidgetInternalTabbing(WidgetType* /*widget*/) override {}
 
         // you must implement CreateGUI:
         // create an instance of the GUI that is used to edit this property type.
         // the QWidget pointer you return also serves as a handle for accessing data.  This means that in order to trigger
         // a write, you need to call RequestWrite(...) on that same widget handle you return.
-        virtual QWidget* CreateGUI(QWidget *pParent) override = 0;
+        QWidget* CreateGUI(QWidget *pParent) override = 0;
 
         // you MAY override this if you wish to pool your widgets or reuse them.  The default implementation simply calls delete.
         //virtual QWidget* DestroyGUI(QWidget* object) override;
@@ -129,24 +129,24 @@ namespace AzToolsFramework
             return false;
         }
 
-        virtual QWidget* GetFirstInTabOrder(WidgetType* widget) { return widget; }
-        virtual QWidget* GetLastInTabOrder(WidgetType* widget) { return widget; }
-        virtual void UpdateWidgetInternalTabbing(WidgetType* /*widget*/) { }
+        QWidget* GetFirstInTabOrder(WidgetType* widget) override { return widget; }
+        QWidget* GetLastInTabOrder(WidgetType* widget) override { return widget; }
+        void UpdateWidgetInternalTabbing(WidgetType* /*widget*/) override {}
 
-        virtual QWidget* CreateGUI(QWidget *pParent) override = 0;
+        QWidget* CreateGUI(QWidget *pParent) override = 0;
     protected:
-        virtual bool HandlesType(const AZ::Uuid& id) const override
+        bool HandlesType(const AZ::Uuid& id) const override
         {
             (void)id;
             return true;
         }
 
-        virtual const AZ::Uuid& GetHandledType() const override
+        const AZ::Uuid& GetHandledType() const override
         {
             return nullUuid;
         }
 
-        virtual void WriteGUIValuesIntoProperty_Internal(QWidget* widget, InstanceDataNode* node) override
+        void WriteGUIValuesIntoProperty_Internal(QWidget* widget, InstanceDataNode* node) override
         {
             for (size_t i = 0; i < node->GetNumInstances(); ++i)
             {
@@ -154,13 +154,13 @@ namespace AzToolsFramework
             }
         }
 
-        virtual void WriteGUIValuesIntoTempProperty_Internal(QWidget* widget, void* tempValue, const AZ::Uuid& propertyType, AZ::SerializeContext* serializeContext) override
+        void WriteGUIValuesIntoTempProperty_Internal(QWidget* widget, void* tempValue, const AZ::Uuid& propertyType, AZ::SerializeContext* serializeContext) override
         {
             (void)serializeContext;
             WriteGUIValuesIntoProperty(0, reinterpret_cast<WidgetType*>(widget), tempValue, propertyType);
         }
 
-        virtual void ReadValuesIntoGUI_Internal(QWidget* widget, InstanceDataNode* node) override
+        void ReadValuesIntoGUI_Internal(QWidget* widget, InstanceDataNode* node) override
         {
             AZ_PROFILE_FUNCTION(AzToolsFramework);
 

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyManagerComponent.h

@@ -34,11 +34,11 @@ namespace AzToolsFramework
 
             //////////////////////////////////////////////////////////////////////////
             // AZ::Component
-            virtual void Init();
-            virtual void Activate();
-            virtual void Deactivate();
+            void Init() override;
+            void Activate() override;
+            void Deactivate() override;
 
-            virtual PropertyHandlerBase* ResolvePropertyHandler(AZ::u32 handlerName, const AZ::Uuid& handlerType) override;
+            PropertyHandlerBase* ResolvePropertyHandler(AZ::u32 handlerName, const AZ::Uuid& handlerType) override;
 
             //////////////////////////////////////////////////////////////////////////
         private:
@@ -57,8 +57,8 @@ namespace AzToolsFramework
 
             //////////////////////////////////////////////////////////////////////////
             // PropertyTypeRegistrationMessages::Bus::Handler
-            virtual void RegisterPropertyType(PropertyHandlerBase* pHandler) override;
-            virtual void UnregisterPropertyType(PropertyHandlerBase* pHandler) override;
+            void RegisterPropertyType(PropertyHandlerBase* pHandler) override;
+            void UnregisterPropertyType(PropertyHandlerBase* pHandler) override;
             //////////////////////////////////////////////////////////////////////////
 
             typedef AZStd::unordered_multimap<AZ::u32, PropertyHandlerBase*> HandlerMap;

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Slice/SlicePushWidget.hxx

@@ -235,7 +235,7 @@ namespace AzToolsFramework
         void PopulateFieldTreeRemovedEntities();
 
         /// Event filter for key presses.
-        bool eventFilter(QObject* target, QEvent *event);
+        bool eventFilter(QObject* target, QEvent *event) override;
 
         /// Conduct the push operation for all selected fields.
         bool PushSelectedFields();

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportUi/ViewportUiManager.h

@@ -40,7 +40,7 @@ namespace AzToolsFramework::ViewportUi
         void RegisterSwitcherEventHandler(SwitcherId switcherId, AZ::Event<ButtonId>::Handler& handler) override;
         void RemoveCluster(ClusterId clusterId) override;
         void RemoveSwitcher(SwitcherId switcherId) override;
-        void SetClusterVisible(ClusterId clusterId, bool visible);
+        void SetClusterVisible(ClusterId clusterId, bool visible) override;
         void SetSwitcherVisible(SwitcherId switcherId, bool visible);
         void SetClusterGroupVisible(const AZStd::vector<ClusterId>& clusterGroup, bool visible) override;
         const TextFieldId CreateTextField(

Code/Framework/AzToolsFramework/Tests/Prefab/Benchmark/PrefabBenchmarkFixture.cpp

@@ -50,7 +50,7 @@ namespace Benchmark
         SetupPrefabSystem();
     }
 
-    void BM_Prefab::SetUp(::benchmark::State & state)
+    void BM_Prefab::internalSetUp(const benchmark::State& state)
     {
         AZ::Debug::TraceMessageBus::Handler::BusConnect();
 
@@ -59,7 +59,7 @@ namespace Benchmark
         SetupPrefabSystem();
     }
 
-    void BM_Prefab::TearDown(::benchmark::State & state)
+    void BM_Prefab::internalTearDown(const benchmark::State& state)
     {
         m_paths = {};
 

Code/Framework/AzToolsFramework/Tests/Prefab/Benchmark/PrefabBenchmarkFixture.h

@@ -24,12 +24,27 @@ namespace Benchmark
         : public UnitTest::AllocatorsBenchmarkFixture
         , public UnitTest::TraceBusRedirector
     {
-    protected:
-        using ::benchmark::Fixture::SetUp;
-        using ::benchmark::Fixture::TearDown;
+        void internalSetUp(const benchmark::State& state);
+        void internalTearDown(const benchmark::State& state);
 
-        void SetUp(::benchmark::State& state) override;
-        void TearDown(::benchmark::State& state) override;
+    protected:
+        void SetUp(const benchmark::State& state) override
+        {
+            internalSetUp(state);
+        }
+        void SetUp(benchmark::State& state) override
+        {
+            internalSetUp(state);
+        }
+
+        void TearDown(const benchmark::State& state) override
+        {
+            internalTearDown(state);
+        }
+        void TearDown(benchmark::State& state) override
+        {
+            internalTearDown(state);
+        }
 
         AZ::Entity* CreateEntity(
             const char* entityName,

Code/Framework/AzToolsFramework/Tests/SliceStabilityTests/SliceStabilityTestFramework.h

@@ -137,7 +137,7 @@ namespace UnitTest
         void CreateEditorRepresentation(AZ::Entity* entity) override;
         void BrowseForAssets(AzToolsFramework::AssetBrowser::AssetSelectionModel& selection) override { AZ_UNUSED(selection); }
         int GetIconTextureIdFromEntityIconPath(const AZStd::string& entityIconPath) override { AZ_UNUSED(entityIconPath);  return 0; }
-        bool DisplayHelpersVisible() { return false; }
+        bool DisplayHelpersVisible() override { return false; }
 
         /*
         * AssetSystemRequestBus