From 9becbd7d728fc2002c176dfd9d1d1aae86f86b12 Mon Sep 17 00:00:00 2001
From: TSRBerry <20988865+TSRBerry@users.noreply.github.com>
Date: Wed, 28 Jun 2023 08:59:13 +0200
Subject: [Ryujinx.Graphics.Shader] Address dotnet-format issues (#5373)

* dotnet format style --severity info

Some changes were manually reverted.

* Restore a few unused methods and variables

* Silence dotnet format IDE0060 warnings

* Silence dotnet format IDE0052 warnings

* Silence dotnet format IDE0059 warnings

* Address or silence dotnet format CA1069 warnings

* Address or silence dotnet format CA2211 warnings

* Address review comments

* Fix formatting for switch expressions

* Address most dotnet format whitespace warnings

* Apply dotnet format whitespace formatting

A few of them have been manually reverted and the corresponding warning was silenced

* Format if-blocks correctly

* Run dotnet format whitespace after rebase

* Run dotnet format style after rebase

* Run dotnet format whitespace after rebase

* Run dotnet format style after rebase

* Run dotnet format after rebase and remove unused usings

- analyzers
- style
- whitespace

* Disable 'prefer switch expression' rule

* Add comments to disabled warnings

* Fix naming rule violation, Convert shader properties to auto-property and convert values to const

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Run dotnet format after rebase

* Address IDE0251 warnings

* Address a few disabled IDE0060 warnings

* Silence IDE0060 in .editorconfig

* Run dotnet format after rebase

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* First dotnet format pass

* Fix naming rule violations

* Add trailing commas

* Remove unused members and most unnecessary value assignments

* Remove more unnecessary assignments

* Remove NRE suppressor
---
 .../Instructions/InstEmit.cs                       | 102 ++++++++++-----------
 1 file changed, 51 insertions(+), 51 deletions(-)

(limited to 'src/Ryujinx.Graphics.Shader/Instructions/InstEmit.cs')

diff --git a/src/Ryujinx.Graphics.Shader/Instructions/InstEmit.cs b/src/Ryujinx.Graphics.Shader/Instructions/InstEmit.cs
index 963a5c65..f105505d 100644
--- a/src/Ryujinx.Graphics.Shader/Instructions/InstEmit.cs
+++ b/src/Ryujinx.Graphics.Shader/Instructions/InstEmit.cs
@@ -7,352 +7,352 @@ namespace Ryujinx.Graphics.Shader.Instructions
     {
         public static void AtomCas(EmitterContext context)
         {
-            InstAtomCas op = context.GetOp<InstAtomCas>();
+            context.GetOp<InstAtomCas>();
 
             context.Config.GpuAccessor.Log("Shader instruction AtomCas is not implemented.");
         }
 
         public static void AtomsCas(EmitterContext context)
         {
-            InstAtomsCas op = context.GetOp<InstAtomsCas>();
+            context.GetOp<InstAtomsCas>();
 
             context.Config.GpuAccessor.Log("Shader instruction AtomsCas is not implemented.");
         }
 
         public static void B2r(EmitterContext context)
         {
-            InstB2r op = context.GetOp<InstB2r>();
+            context.GetOp<InstB2r>();
 
             context.Config.GpuAccessor.Log("Shader instruction B2r is not implemented.");
         }
 
         public static void Bpt(EmitterContext context)
         {
-            InstBpt op = context.GetOp<InstBpt>();
+            context.GetOp<InstBpt>();
 
             context.Config.GpuAccessor.Log("Shader instruction Bpt is not implemented.");
         }
 
         public static void Cctl(EmitterContext context)
         {
-            InstCctl op = context.GetOp<InstCctl>();
+            context.GetOp<InstCctl>();
 
             context.Config.GpuAccessor.Log("Shader instruction Cctl is not implemented.");
         }
 
         public static void Cctll(EmitterContext context)
         {
-            InstCctll op = context.GetOp<InstCctll>();
+            context.GetOp<InstCctll>();
 
             context.Config.GpuAccessor.Log("Shader instruction Cctll is not implemented.");
         }
 
         public static void Cctlt(EmitterContext context)
         {
-            InstCctlt op = context.GetOp<InstCctlt>();
+            context.GetOp<InstCctlt>();
 
             context.Config.GpuAccessor.Log("Shader instruction Cctlt is not implemented.");
         }
 
         public static void Cs2r(EmitterContext context)
         {
-            InstCs2r op = context.GetOp<InstCs2r>();
+            context.GetOp<InstCs2r>();
 
             context.Config.GpuAccessor.Log("Shader instruction Cs2r is not implemented.");
         }
 
         public static void FchkR(EmitterContext context)
         {
-            InstFchkR op = context.GetOp<InstFchkR>();
+            context.GetOp<InstFchkR>();
 
             context.Config.GpuAccessor.Log("Shader instruction FchkR is not implemented.");
         }
 
         public static void FchkI(EmitterContext context)
         {
-            InstFchkI op = context.GetOp<InstFchkI>();
+            context.GetOp<InstFchkI>();
 
             context.Config.GpuAccessor.Log("Shader instruction FchkI is not implemented.");
         }
 
         public static void FchkC(EmitterContext context)
         {
-            InstFchkC op = context.GetOp<InstFchkC>();
+            context.GetOp<InstFchkC>();
 
             context.Config.GpuAccessor.Log("Shader instruction FchkC is not implemented.");
         }
 
         public static void Getcrsptr(EmitterContext context)
         {
-            InstGetcrsptr op = context.GetOp<InstGetcrsptr>();
+            context.GetOp<InstGetcrsptr>();
 
             context.Config.GpuAccessor.Log("Shader instruction Getcrsptr is not implemented.");
         }
 
         public static void Getlmembase(EmitterContext context)
         {
-            InstGetlmembase op = context.GetOp<InstGetlmembase>();
+            context.GetOp<InstGetlmembase>();
 
             context.Config.GpuAccessor.Log("Shader instruction Getlmembase is not implemented.");
         }
 
         public static void Ide(EmitterContext context)
         {
-            InstIde op = context.GetOp<InstIde>();
+            context.GetOp<InstIde>();
 
             context.Config.GpuAccessor.Log("Shader instruction Ide is not implemented.");
         }
 
         public static void IdpR(EmitterContext context)
         {
-            InstIdpR op = context.GetOp<InstIdpR>();
+            context.GetOp<InstIdpR>();
 
             context.Config.GpuAccessor.Log("Shader instruction IdpR is not implemented.");
         }
 
         public static void IdpC(EmitterContext context)
         {
-            InstIdpC op = context.GetOp<InstIdpC>();
+            context.GetOp<InstIdpC>();
 
             context.Config.GpuAccessor.Log("Shader instruction IdpC is not implemented.");
         }
 
         public static void ImadspR(EmitterContext context)
         {
-            InstImadspR op = context.GetOp<InstImadspR>();
+            context.GetOp<InstImadspR>();
 
             context.Config.GpuAccessor.Log("Shader instruction ImadspR is not implemented.");
         }
 
         public static void ImadspI(EmitterContext context)
         {
-            InstImadspI op = context.GetOp<InstImadspI>();
+            context.GetOp<InstImadspI>();
 
             context.Config.GpuAccessor.Log("Shader instruction ImadspI is not implemented.");
         }
 
         public static void ImadspC(EmitterContext context)
         {
-            InstImadspC op = context.GetOp<InstImadspC>();
+            context.GetOp<InstImadspC>();
 
             context.Config.GpuAccessor.Log("Shader instruction ImadspC is not implemented.");
         }
 
         public static void ImadspRc(EmitterContext context)
         {
-            InstImadspRc op = context.GetOp<InstImadspRc>();
+            context.GetOp<InstImadspRc>();
 
             context.Config.GpuAccessor.Log("Shader instruction ImadspRc is not implemented.");
         }
 
         public static void Jcal(EmitterContext context)
         {
-            InstJcal op = context.GetOp<InstJcal>();
+            context.GetOp<InstJcal>();
 
             context.Config.GpuAccessor.Log("Shader instruction Jcal is not implemented.");
         }
 
         public static void Jmp(EmitterContext context)
         {
-            InstJmp op = context.GetOp<InstJmp>();
+            context.GetOp<InstJmp>();
 
             context.Config.GpuAccessor.Log("Shader instruction Jmp is not implemented.");
         }
 
         public static void Jmx(EmitterContext context)
         {
-            InstJmx op = context.GetOp<InstJmx>();
+            context.GetOp<InstJmx>();
 
             context.Config.GpuAccessor.Log("Shader instruction Jmx is not implemented.");
         }
 
         public static void Ld(EmitterContext context)
         {
-            InstLd op = context.GetOp<InstLd>();
+            context.GetOp<InstLd>();
 
             context.Config.GpuAccessor.Log("Shader instruction Ld is not implemented.");
         }
 
         public static void Lepc(EmitterContext context)
         {
-            InstLepc op = context.GetOp<InstLepc>();
+            context.GetOp<InstLepc>();
 
             context.Config.GpuAccessor.Log("Shader instruction Lepc is not implemented.");
         }
 
         public static void Longjmp(EmitterContext context)
         {
-            InstLongjmp op = context.GetOp<InstLongjmp>();
+            context.GetOp<InstLongjmp>();
 
             context.Config.GpuAccessor.Log("Shader instruction Longjmp is not implemented.");
         }
 
         public static void Pexit(EmitterContext context)
         {
-            InstPexit op = context.GetOp<InstPexit>();
+            context.GetOp<InstPexit>();
 
             context.Config.GpuAccessor.Log("Shader instruction Pexit is not implemented.");
         }
 
         public static void Pixld(EmitterContext context)
         {
-            InstPixld op = context.GetOp<InstPixld>();
+            context.GetOp<InstPixld>();
 
             context.Config.GpuAccessor.Log("Shader instruction Pixld is not implemented.");
         }
 
         public static void Plongjmp(EmitterContext context)
         {
-            InstPlongjmp op = context.GetOp<InstPlongjmp>();
+            context.GetOp<InstPlongjmp>();
 
             context.Config.GpuAccessor.Log("Shader instruction Plongjmp is not implemented.");
         }
 
         public static void Pret(EmitterContext context)
         {
-            InstPret op = context.GetOp<InstPret>();
+            context.GetOp<InstPret>();
 
             context.Config.GpuAccessor.Log("Shader instruction Pret is not implemented.");
         }
 
         public static void PrmtR(EmitterContext context)
         {
-            InstPrmtR op = context.GetOp<InstPrmtR>();
+            context.GetOp<InstPrmtR>();
 
             context.Config.GpuAccessor.Log("Shader instruction PrmtR is not implemented.");
         }
 
         public static void PrmtI(EmitterContext context)
         {
-            InstPrmtI op = context.GetOp<InstPrmtI>();
+            context.GetOp<InstPrmtI>();
 
             context.Config.GpuAccessor.Log("Shader instruction PrmtI is not implemented.");
         }
 
         public static void PrmtC(EmitterContext context)
         {
-            InstPrmtC op = context.GetOp<InstPrmtC>();
+            context.GetOp<InstPrmtC>();
 
             context.Config.GpuAccessor.Log("Shader instruction PrmtC is not implemented.");
         }
 
         public static void PrmtRc(EmitterContext context)
         {
-            InstPrmtRc op = context.GetOp<InstPrmtRc>();
+            context.GetOp<InstPrmtRc>();
 
             context.Config.GpuAccessor.Log("Shader instruction PrmtRc is not implemented.");
         }
 
         public static void R2b(EmitterContext context)
         {
-            InstR2b op = context.GetOp<InstR2b>();
+            context.GetOp<InstR2b>();
 
             context.Config.GpuAccessor.Log("Shader instruction R2b is not implemented.");
         }
 
         public static void Ram(EmitterContext context)
         {
-            InstRam op = context.GetOp<InstRam>();
+            context.GetOp<InstRam>();
 
             context.Config.GpuAccessor.Log("Shader instruction Ram is not implemented.");
         }
 
         public static void Rtt(EmitterContext context)
         {
-            InstRtt op = context.GetOp<InstRtt>();
+            context.GetOp<InstRtt>();
 
             context.Config.GpuAccessor.Log("Shader instruction Rtt is not implemented.");
         }
 
         public static void Sam(EmitterContext context)
         {
-            InstSam op = context.GetOp<InstSam>();
+            context.GetOp<InstSam>();
 
             context.Config.GpuAccessor.Log("Shader instruction Sam is not implemented.");
         }
 
         public static void Setcrsptr(EmitterContext context)
         {
-            InstSetcrsptr op = context.GetOp<InstSetcrsptr>();
+            context.GetOp<InstSetcrsptr>();
 
             context.Config.GpuAccessor.Log("Shader instruction Setcrsptr is not implemented.");
         }
 
         public static void Setlmembase(EmitterContext context)
         {
-            InstSetlmembase op = context.GetOp<InstSetlmembase>();
+            context.GetOp<InstSetlmembase>();
 
             context.Config.GpuAccessor.Log("Shader instruction Setlmembase is not implemented.");
         }
 
         public static void St(EmitterContext context)
         {
-            InstSt op = context.GetOp<InstSt>();
+            context.GetOp<InstSt>();
 
             context.Config.GpuAccessor.Log("Shader instruction St is not implemented.");
         }
 
         public static void Stp(EmitterContext context)
         {
-            InstStp op = context.GetOp<InstStp>();
+            context.GetOp<InstStp>();
 
             context.Config.GpuAccessor.Log("Shader instruction Stp is not implemented.");
         }
 
         public static void Txa(EmitterContext context)
         {
-            InstTxa op = context.GetOp<InstTxa>();
+            context.GetOp<InstTxa>();
 
             context.Config.GpuAccessor.Log("Shader instruction Txa is not implemented.");
         }
 
         public static void Vabsdiff(EmitterContext context)
         {
-            InstVabsdiff op = context.GetOp<InstVabsdiff>();
+            context.GetOp<InstVabsdiff>();
 
             context.Config.GpuAccessor.Log("Shader instruction Vabsdiff is not implemented.");
         }
 
         public static void Vabsdiff4(EmitterContext context)
         {
-            InstVabsdiff4 op = context.GetOp<InstVabsdiff4>();
+            context.GetOp<InstVabsdiff4>();
 
             context.Config.GpuAccessor.Log("Shader instruction Vabsdiff4 is not implemented.");
         }
 
         public static void Vadd(EmitterContext context)
         {
-            InstVadd op = context.GetOp<InstVadd>();
+            context.GetOp<InstVadd>();
 
             context.Config.GpuAccessor.Log("Shader instruction Vadd is not implemented.");
         }
 
         public static void Votevtg(EmitterContext context)
         {
-            InstVotevtg op = context.GetOp<InstVotevtg>();
+            context.GetOp<InstVotevtg>();
 
             context.Config.GpuAccessor.Log("Shader instruction Votevtg is not implemented.");
         }
 
         public static void Vset(EmitterContext context)
         {
-            InstVset op = context.GetOp<InstVset>();
+            context.GetOp<InstVset>();
 
             context.Config.GpuAccessor.Log("Shader instruction Vset is not implemented.");
         }
 
         public static void Vshl(EmitterContext context)
         {
-            InstVshl op = context.GetOp<InstVshl>();
+            context.GetOp<InstVshl>();
 
             context.Config.GpuAccessor.Log("Shader instruction Vshl is not implemented.");
         }
 
         public static void Vshr(EmitterContext context)
         {
-            InstVshr op = context.GetOp<InstVshr>();
+            context.GetOp<InstVshr>();
 
             context.Config.GpuAccessor.Log("Shader instruction Vshr is not implemented.");
         }
     }
-}
\ No newline at end of file
+}
-- 
cgit v1.2.3