Misc cleanup (#708)

* Fix typos

* Remove unneeded using statements

* Enforce var style more

* Remove redundant qualifiers

* Fix some indentation

* Disable naming warnings on files with external enum names

* Fix build

* Mass find & replace for comments with no spacing

* Standardize todo capitalization and for/if spacing

8 files changed, 50 insertions, 50 deletions

diff --git a/Ryujinx.Graphics/Shader/Translation/AttributeConsts.cs b/Ryujinx.Graphics/Shader/Translation/AttributeConsts.cs
index 0fd16ce8..f21a6252 100644
--- a/Ryujinx.Graphics/Shader/Translation/AttributeConsts.cs
+++ b/Ryujinx.Graphics/Shader/Translation/AttributeConsts.cs
@@ -29,8 +29,8 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
         public const int UserAttributeEnd    = UserAttributeBase + UserAttributesCount * 16;
 
 
-        //Note: Those attributes are used internally by the translator
-        //only, they don't exist on Maxwell.
+        // Note: Those attributes are used internally by the translator
+        // only, they don't exist on Maxwell.
         public const int FragmentOutputDepth     = 0x1000000;
         public const int FragmentOutputColorBase = 0x1000010;
         public const int FragmentOutputColorEnd  = FragmentOutputColorBase + 8 * 16;
diff --git a/Ryujinx.Graphics/Shader/Translation/Dominance.cs b/Ryujinx.Graphics/Shader/Translation/Dominance.cs
index b4b80e3e..6a3ff35f 100644
--- a/Ryujinx.Graphics/Shader/Translation/Dominance.cs
+++ b/Ryujinx.Graphics/Shader/Translation/Dominance.cs
@@ -5,8 +5,8 @@ namespace Ryujinx.Graphics.Shader.Translation
 {
     static class Dominance
     {
-        //Those methods are an implementation of the algorithms on "A Simple, Fast Dominance Algorithm".
-        //https://www.cs.rice.edu/~keith/EMBED/dom.pdf
+        // Those methods are an implementation of the algorithms on "A Simple, Fast Dominance Algorithm".
+        // https://www.cs.rice.edu/~keith/EMBED/dom.pdf
         public static void FindDominators(BasicBlock entry, int blocksCount)
         {
             HashSet<BasicBlock> visited = new HashSet<BasicBlock>();
diff --git a/Ryujinx.Graphics/Shader/Translation/Optimizations/BranchElimination.cs b/Ryujinx.Graphics/Shader/Translation/Optimizations/BranchElimination.cs
index 2b0f1905..070f07a4 100644
--- a/Ryujinx.Graphics/Shader/Translation/Optimizations/BranchElimination.cs
+++ b/Ryujinx.Graphics/Shader/Translation/Optimizations/BranchElimination.cs
@@ -19,13 +19,13 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
         private static bool IsRedundantBranch(Operation current, BasicBlock nextBlock)
         {
-            //Here we check that:
-            //- The current block ends with a branch.
-            //- The next block only contains a branch.
-            //- The branch on the next block is unconditional.
-            //- Both branches are jumping to the same location.
-            //In this case, the branch on the current block can be removed,
-            //as the next block is going to jump to the same place anyway.
+            // Here we check that:
+            // - The current block ends with a branch.
+            // - The next block only contains a branch.
+            // - The branch on the next block is unconditional.
+            // - Both branches are jumping to the same location.
+            // In this case, the branch on the current block can be removed,
+            // as the next block is going to jump to the same place anyway.
             if (nextBlock == null)
             {
                 return false;
diff --git a/Ryujinx.Graphics/Shader/Translation/Optimizations/HalfConversion.cs b/Ryujinx.Graphics/Shader/Translation/Optimizations/HalfConversion.cs
index 9ef35abc..96060272 100644
--- a/Ryujinx.Graphics/Shader/Translation/Optimizations/HalfConversion.cs
+++ b/Ryujinx.Graphics/Shader/Translation/Optimizations/HalfConversion.cs
@@ -12,7 +12,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
             if (exponent == 0x1f)
             {
-                //NaN or Infinity.
+                // NaN or Infinity.
                 mantissa <<= 13;
                 exponent   = 0xff;
             }
@@ -20,7 +20,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
             {
                 if (exponent == 0)
                 {
-                    //Denormal.
+                    // Denormal.
                     int e = -1;
                     int m = mantissa;
 
diff --git a/Ryujinx.Graphics/Shader/Translation/Optimizations/Optimizer.cs b/Ryujinx.Graphics/Shader/Translation/Optimizations/Optimizer.cs
index 88118e3a..8cce0e74 100644
--- a/Ryujinx.Graphics/Shader/Translation/Optimizations/Optimizer.cs
+++ b/Ryujinx.Graphics/Shader/Translation/Optimizations/Optimizer.cs
@@ -81,8 +81,8 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
         private static void PropagateCopy(Operation copyOp)
         {
-            //Propagate copy source operand to all uses of
-            //the destination operand.
+            // Propagate copy source operand to all uses of
+            // the destination operand.
             Operand dest = copyOp.Dest;
             Operand src  = copyOp.GetSource(0);
 
@@ -102,8 +102,8 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
         private static bool PropagatePack(Operation packOp)
         {
-            //Propagate pack source operands to uses by unpack
-            //instruction. The source depends on the unpack instruction.
+            // Propagate pack source operands to uses by unpack
+            // instruction. The source depends on the unpack instruction.
             bool modified = false;
 
             Operand dest = packOp.Dest;
@@ -132,8 +132,8 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
         private static void RemoveNode(BasicBlock block, LinkedListNode<INode> llNode)
         {
-            //Remove a node from the nodes list, and also remove itself
-            //from all the use lists on the operands that this node uses.
+            // Remove a node from the nodes list, and also remove itself
+            // from all the use lists on the operands that this node uses.
             block.Operations.Remove(llNode);
 
             Queue<INode> nodes = new Queue<INode>();
diff --git a/Ryujinx.Graphics/Shader/Translation/Optimizations/Simplification.cs b/Ryujinx.Graphics/Shader/Translation/Optimizations/Simplification.cs
index 56b1543f..d6366dfe 100644
--- a/Ryujinx.Graphics/Shader/Translation/Optimizations/Simplification.cs
+++ b/Ryujinx.Graphics/Shader/Translation/Optimizations/Simplification.cs
@@ -14,7 +14,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
             {
                 case Instruction.Add:
                 case Instruction.BitwiseExclusiveOr:
-                    TryEliminateBinaryOpComutative(operation, 0);
+                    TryEliminateBinaryOpCommutative(operation, 0);
                     break;
 
                 case Instruction.BitwiseAnd:
@@ -34,7 +34,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                     break;
 
                 case Instruction.Multiply:
-                    TryEliminateBinaryOpComutative(operation, 1);
+                    TryEliminateBinaryOpCommutative(operation, 1);
                     break;
 
                 case Instruction.ShiftLeft:
@@ -48,9 +48,9 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
         private static void TryEliminateBitwiseAnd(Operation operation)
         {
-            //Try to recognize and optimize those 3 patterns (in order):
-            //x & 0xFFFFFFFF == x,          0xFFFFFFFF & y == y,
-            //x & 0x00000000 == 0x00000000, 0x00000000 & y == 0x00000000
+            // Try to recognize and optimize those 3 patterns (in order):
+            // x & 0xFFFFFFFF == x,          0xFFFFFFFF & y == y,
+            // x & 0x00000000 == 0x00000000, 0x00000000 & y == 0x00000000
             Operand x = operation.GetSource(0);
             Operand y = operation.GetSource(1);
 
@@ -70,9 +70,9 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
         private static void TryEliminateBitwiseOr(Operation operation)
         {
-            //Try to recognize and optimize those 3 patterns (in order):
-            //x | 0x00000000 == x,          0x00000000 | y == y,
-            //x | 0xFFFFFFFF == 0xFFFFFFFF, 0xFFFFFFFF | y == 0xFFFFFFFF
+            // Try to recognize and optimize those 3 patterns (in order):
+            // x | 0x00000000 == x,          0x00000000 | y == y,
+            // x | 0xFFFFFFFF == 0xFFFFFFFF, 0xFFFFFFFF | y == 0xFFFFFFFF
             Operand x = operation.GetSource(0);
             Operand y = operation.GetSource(1);
 
@@ -101,7 +101,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
             }
         }
 
-        private static void TryEliminateBinaryOpComutative(Operation operation, int comparand)
+        private static void TryEliminateBinaryOpCommutative(Operation operation, int comparand)
         {
             Operand x = operation.GetSource(0);
             Operand y = operation.GetSource(1);
@@ -125,8 +125,8 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                 return;
             }
 
-            //The condition is constant, we can turn it into a copy, and select
-            //the source based on the condition value.
+            // The condition is constant, we can turn it into a copy, and select
+            // the source based on the condition value.
             int srcIndex = cond.Value != 0 ? 1 : 2;
 
             Operand source = operation.GetSource(srcIndex);
diff --git a/Ryujinx.Graphics/Shader/Translation/Ssa.cs b/Ryujinx.Graphics/Shader/Translation/Ssa.cs
index b612649c..a4d763be 100644
--- a/Ryujinx.Graphics/Shader/Translation/Ssa.cs
+++ b/Ryujinx.Graphics/Shader/Translation/Ssa.cs
@@ -86,7 +86,7 @@ namespace Ryujinx.Graphics.Shader.Translation
 
             Queue<BasicBlock> dfPhiBlocks = new Queue<BasicBlock>();
 
-            //First pass, get all defs and locals uses.
+            // First pass, get all defs and locals uses.
             for (int blkIndex = 0; blkIndex < blocks.Length; blkIndex++)
             {
                 Operand[] localDefs = new Operand[RegisterConsts.TotalCount];
@@ -157,7 +157,7 @@ namespace Ryujinx.Graphics.Shader.Translation
                 }
             }
 
-            //Second pass, rename variables with definitions on different blocks.
+            // Second pass, rename variables with definitions on different blocks.
             for (int blkIndex = 0; blkIndex < blocks.Length; blkIndex++)
             {
                 Operand[] localDefs = new Operand[RegisterConsts.TotalCount];
@@ -251,10 +251,10 @@ namespace Ryujinx.Graphics.Shader.Translation
 
         private static Operand InsertPhi(DefMap[] globalDefs, BasicBlock block, Register reg)
         {
-            //This block has a Phi that has not been materialized yet, but that
-            //would define a new version of the variable we're looking for. We need
-            //to materialize the Phi, add all the block/operand pairs into the Phi, and
-            //then use the definition from that Phi.
+            // This block has a Phi that has not been materialized yet, but that
+            // would define a new version of the variable we're looking for. We need
+            // to materialize the Phi, add all the block/operand pairs into the Phi, and
+            // then use the definition from that Phi.
             Operand local = Local();
 
             PhiNode phi = new PhiNode(local);
diff --git a/Ryujinx.Graphics/Shader/Translation/Translator.cs b/Ryujinx.Graphics/Shader/Translation/Translator.cs
index 706f3cfa..fcebe913 100644
--- a/Ryujinx.Graphics/Shader/Translation/Translator.cs
+++ b/Ryujinx.Graphics/Shader/Translation/Translator.cs
@@ -28,7 +28,7 @@ namespace Ryujinx.Graphics.Shader.Translation
 
             if (addressB != 0)
             {
-                //Dual vertex shader.
+                // Dual vertex shader.
                 Operation[] shaderOpsB = DecodeShader(memory, addressB, config.Type);
 
                 shaderOps = Combine(shaderOps, shaderOpsB);
@@ -86,10 +86,10 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                     if (op is OpCodeSync opSync)
                     {
-                        //If the instruction is a SYNC instruction with only one
-                        //possible target address, then the instruction is basically
-                        //just a simple branch, we can generate code similar to branch
-                        //instructions, with the condition check on the branch itself.
+                        // If the instruction is a SYNC instruction with only one
+                        // possible target address, then the instruction is basically
+                        // just a simple branch, we can generate code similar to branch
+                        // instructions, with the condition check on the branch itself.
                         skipPredicateCheck |= opSync.Targets.Count < 2;
                     }
 
@@ -136,15 +136,15 @@ namespace Ryujinx.Graphics.Shader.Translation
 
         private static Operation[] Combine(Operation[] a, Operation[] b)
         {
-            //Here we combine two shaders.
-            //For shader A:
-            //- All user attribute stores on shader A are turned into copies to a
-            //temporary variable. It's assumed that shader B will consume them.
-            //- All return instructions are turned into branch instructions, the
-            //branch target being the start of the shader B code.
-            //For shader B:
-            //- All user attribute loads on shader B are turned into copies from a
-            //temporary variable, as long that attribute is written by shader A.
+            // Here we combine two shaders.
+            // For shader A:
+            // - All user attribute stores on shader A are turned into copies to a
+            // temporary variable. It's assumed that shader B will consume them.
+            // - All return instructions are turned into branch instructions, the
+            // branch target being the start of the shader B code.
+            // For shader B:
+            // - All user attribute loads on shader B are turned into copies from a
+            // temporary variable, as long that attribute is written by shader A.
             List<Operation> output = new List<Operation>(a.Length + b.Length);
 
             Operand[] temps = new Operand[AttributeConsts.UserAttributesCount * 4];