Merge pull request #5124 from lioncash/video-shadow

video_core: Resolve more variable shadowing scenarios

11 files changed, 88 insertions, 85 deletions

diff --git a/src/video_core/renderer_opengl/gl_arb_decompiler.cpp b/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
index d6120c23e..5378c398e 100644
--- a/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_arb_decompiler.cpp
@@ -187,8 +187,8 @@ std::string TextureType(const MetaTexture& meta) {
 
 class ARBDecompiler final {
 public:
-    explicit ARBDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
-                           ShaderType stage, std::string_view identifier);
+    explicit ARBDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
+                           ShaderType stage_, std::string_view identifier);
 
     std::string Code() const {
         return shader_source;
@@ -802,9 +802,9 @@ private:
     };
 };
 
-ARBDecompiler::ARBDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
-                             ShaderType stage, std::string_view identifier)
-    : device{device}, ir{ir}, registry{registry}, stage{stage} {
+ARBDecompiler::ARBDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
+                             ShaderType stage_, std::string_view identifier)
+    : device{device_}, ir{ir_}, registry{registry_}, stage{stage_} {
     DefineGlobalMemory();
 
     AddLine("TEMP RC;");
@@ -1134,44 +1134,44 @@ void ARBDecompiler::VisitAST(const ASTNode& node) {
         for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
             VisitAST(current);
         }
-    } else if (const auto ast = std::get_if<ASTIfThen>(&*node->GetInnerData())) {
-        const std::string condition = VisitExpression(ast->condition);
+    } else if (const auto if_then = std::get_if<ASTIfThen>(&*node->GetInnerData())) {
+        const std::string condition = VisitExpression(if_then->condition);
         ResetTemporaries();
 
         AddLine("MOVC.U RC.x, {};", condition);
         AddLine("IF NE.x;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = if_then->nodes.GetFirst(); current; current = current->GetNext()) {
             VisitAST(current);
         }
         AddLine("ENDIF;");
-    } else if (const auto ast = std::get_if<ASTIfElse>(&*node->GetInnerData())) {
+    } else if (const auto if_else = std::get_if<ASTIfElse>(&*node->GetInnerData())) {
         AddLine("ELSE;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = if_else->nodes.GetFirst(); current; current = current->GetNext()) {
             VisitAST(current);
         }
-    } else if (const auto ast = std::get_if<ASTBlockDecoded>(&*node->GetInnerData())) {
-        VisitBlock(ast->nodes);
-    } else if (const auto ast = std::get_if<ASTVarSet>(&*node->GetInnerData())) {
-        AddLine("MOV.U F{}, {};", ast->index, VisitExpression(ast->condition));
+    } else if (const auto decoded = std::get_if<ASTBlockDecoded>(&*node->GetInnerData())) {
+        VisitBlock(decoded->nodes);
+    } else if (const auto var_set = std::get_if<ASTVarSet>(&*node->GetInnerData())) {
+        AddLine("MOV.U F{}, {};", var_set->index, VisitExpression(var_set->condition));
         ResetTemporaries();
-    } else if (const auto ast = std::get_if<ASTDoWhile>(&*node->GetInnerData())) {
-        const std::string condition = VisitExpression(ast->condition);
+    } else if (const auto do_while = std::get_if<ASTDoWhile>(&*node->GetInnerData())) {
+        const std::string condition = VisitExpression(do_while->condition);
         ResetTemporaries();
         AddLine("REP;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = do_while->nodes.GetFirst(); current; current = current->GetNext()) {
             VisitAST(current);
         }
         AddLine("MOVC.U RC.x, {};", condition);
         AddLine("BRK (NE.x);");
         AddLine("ENDREP;");
-    } else if (const auto ast = std::get_if<ASTReturn>(&*node->GetInnerData())) {
-        const bool is_true = ExprIsTrue(ast->condition);
+    } else if (const auto ast_return = std::get_if<ASTReturn>(&*node->GetInnerData())) {
+        const bool is_true = ExprIsTrue(ast_return->condition);
         if (!is_true) {
-            AddLine("MOVC.U RC.x, {};", VisitExpression(ast->condition));
+            AddLine("MOVC.U RC.x, {};", VisitExpression(ast_return->condition));
             AddLine("IF NE.x;");
             ResetTemporaries();
         }
-        if (ast->kills) {
+        if (ast_return->kills) {
             AddLine("KIL TR;");
         } else {
             Exit();
@@ -1179,11 +1179,11 @@ void ARBDecompiler::VisitAST(const ASTNode& node) {
         if (!is_true) {
             AddLine("ENDIF;");
         }
-    } else if (const auto ast = std::get_if<ASTBreak>(&*node->GetInnerData())) {
-        if (ExprIsTrue(ast->condition)) {
+    } else if (const auto ast_break = std::get_if<ASTBreak>(&*node->GetInnerData())) {
+        if (ExprIsTrue(ast_break->condition)) {
             AddLine("BRK;");
         } else {
-            AddLine("MOVC.U RC.x, {};", VisitExpression(ast->condition));
+            AddLine("MOVC.U RC.x, {};", VisitExpression(ast_break->condition));
             AddLine("BRK (NE.x);");
             ResetTemporaries();
         }
diff --git a/src/video_core/renderer_opengl/gl_fence_manager.cpp b/src/video_core/renderer_opengl/gl_fence_manager.cpp
index b532fdcc2..6040646cb 100644
--- a/src/video_core/renderer_opengl/gl_fence_manager.cpp
+++ b/src/video_core/renderer_opengl/gl_fence_manager.cpp
@@ -11,10 +11,10 @@
 
 namespace OpenGL {
 
-GLInnerFence::GLInnerFence(u32 payload, bool is_stubbed) : FenceBase(payload, is_stubbed) {}
+GLInnerFence::GLInnerFence(u32 payload_, bool is_stubbed_) : FenceBase{payload_, is_stubbed_} {}
 
-GLInnerFence::GLInnerFence(GPUVAddr address, u32 payload, bool is_stubbed)
-    : FenceBase(address, payload, is_stubbed) {}
+GLInnerFence::GLInnerFence(GPUVAddr address_, u32 payload_, bool is_stubbed_)
+    : FenceBase{address_, payload_, is_stubbed_} {}
 
 GLInnerFence::~GLInnerFence() = default;
 
@@ -45,10 +45,10 @@ void GLInnerFence::Wait() {
     glClientWaitSync(sync_object.handle, 0, GL_TIMEOUT_IGNORED);
 }
 
-FenceManagerOpenGL::FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
-                                       TextureCacheOpenGL& texture_cache,
-                                       OGLBufferCache& buffer_cache, QueryCache& query_cache)
-    : GenericFenceManager{rasterizer, gpu, texture_cache, buffer_cache, query_cache} {}
+FenceManagerOpenGL::FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer_,
+                                       Tegra::GPU& gpu_, TextureCacheOpenGL& texture_cache_,
+                                       OGLBufferCache& buffer_cache_, QueryCache& query_cache_)
+    : GenericFenceManager{rasterizer_, gpu_, texture_cache_, buffer_cache_, query_cache_} {}
 
 Fence FenceManagerOpenGL::CreateFence(u32 value, bool is_stubbed) {
     return std::make_shared<GLInnerFence>(value, is_stubbed);
diff --git a/src/video_core/renderer_opengl/gl_fence_manager.h b/src/video_core/renderer_opengl/gl_fence_manager.h
index da1dcdace..39ca6125b 100644
--- a/src/video_core/renderer_opengl/gl_fence_manager.h
+++ b/src/video_core/renderer_opengl/gl_fence_manager.h
@@ -17,8 +17,8 @@ namespace OpenGL {
 
 class GLInnerFence : public VideoCommon::FenceBase {
 public:
-    GLInnerFence(u32 payload, bool is_stubbed);
-    GLInnerFence(GPUVAddr address, u32 payload, bool is_stubbed);
+    explicit GLInnerFence(u32 payload_, bool is_stubbed_);
+    explicit GLInnerFence(GPUVAddr address_, u32 payload_, bool is_stubbed_);
     ~GLInnerFence();
 
     void Queue();
@@ -37,9 +37,9 @@ using GenericFenceManager =
 
 class FenceManagerOpenGL final : public GenericFenceManager {
 public:
-    explicit FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
-                                TextureCacheOpenGL& texture_cache, OGLBufferCache& buffer_cache,
-                                QueryCache& query_cache);
+    explicit FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
+                                TextureCacheOpenGL& texture_cache_, OGLBufferCache& buffer_cache_,
+                                QueryCache& query_cache_);
 
 protected:
     Fence CreateFence(u32 value, bool is_stubbed) override;
diff --git a/src/video_core/renderer_opengl/gl_query_cache.cpp b/src/video_core/renderer_opengl/gl_query_cache.cpp
index 1a3d9720e..bcc37471f 100644
--- a/src/video_core/renderer_opengl/gl_query_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_query_cache.cpp
@@ -59,10 +59,10 @@ bool QueryCache::AnyCommandQueued() const noexcept {
     return gl_rasterizer.AnyCommandQueued();
 }
 
-HostCounter::HostCounter(QueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type)
-    : VideoCommon::HostCounterBase<QueryCache, HostCounter>{std::move(dependency)}, cache{cache},
-      type{type}, query{cache.AllocateQuery(type)} {
+HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency,
+                         VideoCore::QueryType type_)
+    : HostCounterBase<QueryCache, HostCounter>{std::move(dependency)}, cache{cache_}, type{type_},
+      query{cache.AllocateQuery(type)} {
     glBeginQuery(GetTarget(type), query.handle);
 }
 
@@ -86,13 +86,14 @@ u64 HostCounter::BlockingQuery() const {
     return static_cast<u64>(value);
 }
 
-CachedQuery::CachedQuery(QueryCache& cache, VideoCore::QueryType type, VAddr cpu_addr, u8* host_ptr)
-    : VideoCommon::CachedQueryBase<HostCounter>{cpu_addr, host_ptr}, cache{&cache}, type{type} {}
+CachedQuery::CachedQuery(QueryCache& cache_, VideoCore::QueryType type_, VAddr cpu_addr,
+                         u8* host_ptr)
+    : CachedQueryBase<HostCounter>{cpu_addr, host_ptr}, cache{&cache_}, type{type_} {}
 
 CachedQuery::~CachedQuery() = default;
 
 CachedQuery::CachedQuery(CachedQuery&& rhs) noexcept
-    : VideoCommon::CachedQueryBase<HostCounter>(std::move(rhs)), cache{rhs.cache}, type{rhs.type} {}
+    : CachedQueryBase<HostCounter>(std::move(rhs)), cache{rhs.cache}, type{rhs.type} {}
 
 CachedQuery& CachedQuery::operator=(CachedQuery&& rhs) noexcept {
     cache = rhs.cache;
diff --git a/src/video_core/renderer_opengl/gl_query_cache.h b/src/video_core/renderer_opengl/gl_query_cache.h
index 82cac51ee..d9851e880 100644
--- a/src/video_core/renderer_opengl/gl_query_cache.h
+++ b/src/video_core/renderer_opengl/gl_query_cache.h
@@ -46,8 +46,8 @@ private:
 
 class HostCounter final : public VideoCommon::HostCounterBase<QueryCache, HostCounter> {
 public:
-    explicit HostCounter(QueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type);
+    explicit HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency,
+                         VideoCore::QueryType type_);
     ~HostCounter();
 
     void EndQuery();
@@ -62,7 +62,7 @@ private:
 
 class CachedQuery final : public VideoCommon::CachedQueryBase<HostCounter> {
 public:
-    explicit CachedQuery(QueryCache& cache, VideoCore::QueryType type, VAddr cpu_addr,
+    explicit CachedQuery(QueryCache& cache_, VideoCore::QueryType type_, VAddr cpu_addr,
                          u8* host_ptr);
     ~CachedQuery() override;
 
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index bd56bed0c..9f2c0a222 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -198,10 +198,10 @@ ProgramSharedPtr BuildShader(const Device& device, ShaderType shader_type, u64 u
     return program;
 }
 
-Shader::Shader(std::shared_ptr<VideoCommon::Shader::Registry> registry_, ShaderEntries entries_,
-               ProgramSharedPtr program_, bool is_built)
+Shader::Shader(std::shared_ptr<Registry> registry_, ShaderEntries entries_,
+               ProgramSharedPtr program_, bool is_built_)
     : registry{std::move(registry_)}, entries{std::move(entries_)}, program{std::move(program_)},
-      is_built(is_built) {
+      is_built{is_built_} {
     handle = program->assembly_program.handle;
     if (handle == 0) {
         handle = program->source_program.handle;
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.h b/src/video_core/renderer_opengl/gl_shader_cache.h
index 1708af06a..ab5374fac 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.h
+++ b/src/video_core/renderer_opengl/gl_shader_cache.h
@@ -108,7 +108,7 @@ public:
 
 private:
     explicit Shader(std::shared_ptr<VideoCommon::Shader::Registry> registry, ShaderEntries entries,
-                    ProgramSharedPtr program, bool is_built = true);
+                    ProgramSharedPtr program, bool is_built_ = true);
 
     std::shared_ptr<VideoCommon::Shader::Registry> registry;
     ShaderEntries entries;
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index 95ca96c8e..0940969ba 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -131,7 +131,7 @@ private:
 
 class Expression final {
 public:
-    Expression(std::string code, Type type) : code{std::move(code)}, type{type} {
+    Expression(std::string code_, Type type_) : code{std::move(code_)}, type{type_} {
         ASSERT(type != Type::Void);
     }
     Expression() : type{Type::Void} {}
@@ -148,8 +148,8 @@ public:
         ASSERT(type == Type::Void);
     }
 
-    std::string As(Type type) const {
-        switch (type) {
+    std::string As(Type type_) const {
+        switch (type_) {
         case Type::Bool:
             return AsBool();
         case Type::Bool2:
@@ -418,11 +418,12 @@ struct GenericVaryingDescription {
 
 class GLSLDecompiler final {
 public:
-    explicit GLSLDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
-                            ShaderType stage, std::string_view identifier, std::string_view suffix)
-        : device{device}, ir{ir}, registry{registry}, stage{stage}, identifier{identifier},
-          suffix{suffix}, header{ir.GetHeader()}, use_unified_uniforms{
-                                                      UseUnifiedUniforms(device, ir, stage)} {
+    explicit GLSLDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
+                            ShaderType stage_, std::string_view identifier_,
+                            std::string_view suffix_)
+        : device{device_}, ir{ir_}, registry{registry_}, stage{stage_}, identifier{identifier_},
+          suffix{suffix_}, header{ir.GetHeader()}, use_unified_uniforms{
+                                                       UseUnifiedUniforms(device_, ir_, stage_)} {
         if (stage != ShaderType::Compute) {
             transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo());
         }
@@ -777,16 +778,16 @@ private:
             name = "gs_" + name + "[]";
         }
 
-        std::string suffix;
+        std::string suffix_;
         if (stage == ShaderType::Fragment) {
             const auto input_mode{header.ps.GetPixelImap(location)};
             if (input_mode == PixelImap::Unused) {
                 return;
             }
-            suffix = GetInputFlags(input_mode);
+            suffix_ = GetInputFlags(input_mode);
         }
 
-        code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix, name);
+        code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix_, name);
     }
 
     void DeclareOutputAttributes() {
@@ -2100,13 +2101,13 @@ private:
         const auto type = meta.sampler.is_shadow ? Type::Float : Type::Int;
         const bool separate_dc = meta.sampler.is_shadow;
 
-        std::vector<TextureIR> ir;
+        std::vector<TextureIR> ir_;
         if (meta.sampler.is_shadow) {
-            ir = {TextureOffset{}};
+            ir_ = {TextureOffset{}};
         } else {
-            ir = {TextureOffset{}, TextureArgument{type, meta.component}};
+            ir_ = {TextureOffset{}, TextureArgument{type, meta.component}};
         }
-        return {GenerateTexture(operation, "Gather", ir, separate_dc) + GetSwizzle(meta.element),
+        return {GenerateTexture(operation, "Gather", ir_, separate_dc) + GetSwizzle(meta.element),
                 Type::Float};
     }
 
@@ -2801,7 +2802,7 @@ std::string GetFlowVariable(u32 index) {
 
 class ExprDecompiler {
 public:
-    explicit ExprDecompiler(GLSLDecompiler& decomp) : decomp{decomp} {}
+    explicit ExprDecompiler(GLSLDecompiler& decomp_) : decomp{decomp_} {}
 
     void operator()(const ExprAnd& expr) {
         inner += '(';
@@ -2856,7 +2857,7 @@ private:
 
 class ASTDecompiler {
 public:
-    explicit ASTDecompiler(GLSLDecompiler& decomp) : decomp{decomp} {}
+    explicit ASTDecompiler(GLSLDecompiler& decomp_) : decomp{decomp_} {}
 
     void operator()(const ASTProgram& ast) {
         ASTNode current = ast.nodes.GetFirst();
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.h b/src/video_core/renderer_opengl/gl_shader_decompiler.h
index 451c9689a..f5a5249f2 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.h
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.h
@@ -25,8 +25,8 @@ using ImageEntry = VideoCommon::Shader::Image;
 
 class ConstBufferEntry : public VideoCommon::Shader::ConstBuffer {
 public:
-    explicit ConstBufferEntry(u32 max_offset, bool is_indirect, u32 index)
-        : VideoCommon::Shader::ConstBuffer{max_offset, is_indirect}, index{index} {}
+    explicit ConstBufferEntry(u32 max_offset, bool is_indirect, u32 index_)
+        : ConstBuffer{max_offset, is_indirect}, index{index_} {}
 
     u32 GetIndex() const {
         return index;
@@ -37,10 +37,10 @@ private:
 };
 
 struct GlobalMemoryEntry {
-    constexpr explicit GlobalMemoryEntry(u32 cbuf_index, u32 cbuf_offset, bool is_read,
-                                         bool is_written)
-        : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_read{is_read}, is_written{
-                                                                                  is_written} {}
+    constexpr explicit GlobalMemoryEntry(u32 cbuf_index_, u32 cbuf_offset_, bool is_read_,
+                                         bool is_written_)
+        : cbuf_index{cbuf_index_}, cbuf_offset{cbuf_offset_}, is_read{is_read_}, is_written{
+                                                                                     is_written_} {}
 
     u32 cbuf_index = 0;
     u32 cbuf_offset = 0;
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.cpp b/src/video_core/renderer_opengl/gl_texture_cache.cpp
index a863ef218..a59fe853e 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp
@@ -258,9 +258,9 @@ constexpr u32 EncodeSwizzle(SwizzleSource x_source, SwizzleSource y_source, Swiz
 
 } // Anonymous namespace
 
-CachedSurface::CachedSurface(const GPUVAddr gpu_addr, const SurfaceParams& params,
-                             bool is_astc_supported)
-    : VideoCommon::SurfaceBase<View>(gpu_addr, params, is_astc_supported) {
+CachedSurface::CachedSurface(const GPUVAddr gpu_addr_, const SurfaceParams& params_,
+                             bool is_astc_supported_)
+    : SurfaceBase<View>{gpu_addr_, params_, is_astc_supported_} {
     if (is_converted) {
         internal_format = params.srgb_conversion ? GL_SRGB8_ALPHA8 : GL_RGBA8;
         format = GL_RGBA;
@@ -419,11 +419,11 @@ View CachedSurface::CreateViewInner(const ViewParams& view_key, const bool is_pr
     return view;
 }
 
-CachedSurfaceView::CachedSurfaceView(CachedSurface& surface, const ViewParams& params,
-                                     bool is_proxy)
-    : VideoCommon::ViewBase(params), surface{surface}, format{surface.internal_format},
-      target{GetTextureTarget(params.target)}, is_proxy{is_proxy} {
-    if (!is_proxy) {
+CachedSurfaceView::CachedSurfaceView(CachedSurface& surface_, const ViewParams& params_,
+                                     bool is_proxy_)
+    : ViewBase{params_}, surface{surface_}, format{surface_.internal_format},
+      target{GetTextureTarget(params_.target)}, is_proxy{is_proxy_} {
+    if (!is_proxy_) {
         main_view = CreateTextureView();
     }
 }
@@ -493,13 +493,13 @@ GLuint CachedSurfaceView::GetTexture(SwizzleSource x_source, SwizzleSource y_sou
 
     std::array swizzle{x_source, y_source, z_source, w_source};
 
-    switch (const PixelFormat format = GetSurfaceParams().pixel_format) {
+    switch (const PixelFormat pixel_format = GetSurfaceParams().pixel_format) {
     case PixelFormat::D24_UNORM_S8_UINT:
     case PixelFormat::D32_FLOAT_S8_UINT:
     case PixelFormat::S8_UINT_D24_UNORM:
         UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G);
         glTextureParameteri(view.handle, GL_DEPTH_STENCIL_TEXTURE_MODE,
-                            GetComponent(format, x_source == SwizzleSource::R));
+                            GetComponent(pixel_format, x_source == SwizzleSource::R));
 
         // Make sure we sample the first component
         std::transform(swizzle.begin(), swizzle.end(), swizzle.begin(), [](SwizzleSource value) {
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.h b/src/video_core/renderer_opengl/gl_texture_cache.h
index 7787134fc..76a7b2316 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -37,7 +37,8 @@ class CachedSurface final : public VideoCommon::SurfaceBase<View> {
     friend CachedSurfaceView;
 
 public:
-    explicit CachedSurface(GPUVAddr gpu_addr, const SurfaceParams& params, bool is_astc_supported);
+    explicit CachedSurface(GPUVAddr gpu_addr_, const SurfaceParams& params_,
+                           bool is_astc_supported_);
     ~CachedSurface();
 
     void UploadTexture(const std::vector<u8>& staging_buffer) override;
@@ -77,7 +78,7 @@ private:
 
 class CachedSurfaceView final : public VideoCommon::ViewBase {
 public:
-    explicit CachedSurfaceView(CachedSurface& surface, const ViewParams& params, bool is_proxy);
+    explicit CachedSurfaceView(CachedSurface& surface_, const ViewParams& params_, bool is_proxy_);
     ~CachedSurfaceView();
 
     /// @brief Attaches this texture view to the currently bound fb_target framebuffer