Move switch statement bodies to their own lines (#5493)

* Move switch statement bodies to their own lines

* format

---------

Co-authored-by: Yong He <yonghe@outlook.com>

1 files changed, 271 insertions, 112 deletions

diff --git a/source/slang/slang-ir-util.cpp b/source/slang/slang-ir-util.cpp
index eb6b8a7aa..c7b40da8b 100644
--- a/source/slang/slang-ir-util.cpp
+++ b/source/slang/slang-ir-util.cpp
@@ -116,7 +116,8 @@ IROp getTypeStyle(IROp op)
             // All float like
             return kIROp_FloatType;
         }
-    default: return kIROp_Invalid;
+    default:
+        return kIROp_Invalid;
     }
 }
 
@@ -124,8 +125,10 @@ IROp getTypeStyle(BaseType op)
 {
     switch (op)
     {
-    case BaseType::Void:    return kIROp_VoidType;
-    case BaseType::Bool:    return kIROp_BoolType;
+    case BaseType::Void:
+        return kIROp_VoidType;
+    case BaseType::Bool:
+        return kIROp_BoolType;
     case BaseType::Char:
     case BaseType::Int8:
     case BaseType::Int16:
@@ -136,11 +139,14 @@ IROp getTypeStyle(BaseType op)
     case BaseType::UInt16:
     case BaseType::UInt:
     case BaseType::UInt64:
-    case BaseType::UIntPtr: return kIROp_IntType;
+    case BaseType::UIntPtr:
+        return kIROp_IntType;
     case BaseType::Half:
     case BaseType::Float:
-    case BaseType::Double:  return kIROp_FloatType;
-    default:                return kIROp_Invalid;
+    case BaseType::Double:
+        return kIROp_FloatType;
+    default:
+        return kIROp_Invalid;
     }
 }
 
@@ -199,7 +205,8 @@ bool isValueType(IRInst* dataType)
     case kIROp_ArrayType:
     case kIROp_FuncType:
     case kIROp_RaytracingAccelerationStructureType:
-    case kIROp_GLSLAtomicUintType:                  return true;
+    case kIROp_GLSLAtomicUintType:
+        return true;
     default:
         // Read-only resource handles are considered as Value type.
         if (auto resType = as<IRResourceTypeBase>(dataType))
@@ -237,10 +244,13 @@ bool isSimpleDataType(IRType* type)
     case kIROp_MatrixType:
     case kIROp_InterfaceType:
     case kIROp_AnyValueType:
-    case kIROp_PtrType:          return true;
+    case kIROp_PtrType:
+        return true;
     case kIROp_ArrayType:
-    case kIROp_UnsizedArrayType: return isSimpleDataType((IRType*)type->getOperand(0));
-    default:                     return false;
+    case kIROp_UnsizedArrayType:
+        return isSimpleDataType((IRType*)type->getOperand(0));
+    default:
+        return false;
     }
 }
 
@@ -352,10 +362,16 @@ void copyNameHintAndDebugDecorations(IRInst* dest, IRInst* src)
     {
         switch (decor->getOp())
         {
-        case kIROp_NameHintDecoration:      nameHintDecoration = decor; break;
+        case kIROp_NameHintDecoration:
+            nameHintDecoration = decor;
+            break;
         case kIROp_ImportDecoration:
-        case kIROp_ExportDecoration:        linkageDecoration = decor; break;
-        case kIROp_DebugLocationDecoration: debugLocationDecoration = decor; break;
+        case kIROp_ExportDecoration:
+            linkageDecoration = decor;
+            break;
+        case kIROp_DebugLocationDecoration:
+            debugLocationDecoration = decor;
+            break;
         }
     }
     if (nameHintDecoration)
@@ -379,21 +395,51 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type)
 
     switch (type->getOp())
     {
-    case kIROp_FloatType:   sb << "float"; break;
-    case kIROp_HalfType:    sb << "half"; break;
-    case kIROp_DoubleType:  sb << "double"; break;
-    case kIROp_IntType:     sb << "int"; break;
-    case kIROp_Int8Type:    sb << "int8"; break;
-    case kIROp_Int16Type:   sb << "int16"; break;
-    case kIROp_Int64Type:   sb << "int64"; break;
-    case kIROp_IntPtrType:  sb << "intptr"; break;
-    case kIROp_UIntType:    sb << "uint"; break;
-    case kIROp_UInt8Type:   sb << "uint8"; break;
-    case kIROp_UInt16Type:  sb << "uint16"; break;
-    case kIROp_UInt64Type:  sb << "uint64"; break;
-    case kIROp_UIntPtrType: sb << "uintptr"; break;
-    case kIROp_CharType:    sb << "char"; break;
-    case kIROp_StringType:  sb << "string"; break;
+    case kIROp_FloatType:
+        sb << "float";
+        break;
+    case kIROp_HalfType:
+        sb << "half";
+        break;
+    case kIROp_DoubleType:
+        sb << "double";
+        break;
+    case kIROp_IntType:
+        sb << "int";
+        break;
+    case kIROp_Int8Type:
+        sb << "int8";
+        break;
+    case kIROp_Int16Type:
+        sb << "int16";
+        break;
+    case kIROp_Int64Type:
+        sb << "int64";
+        break;
+    case kIROp_IntPtrType:
+        sb << "intptr";
+        break;
+    case kIROp_UIntType:
+        sb << "uint";
+        break;
+    case kIROp_UInt8Type:
+        sb << "uint8";
+        break;
+    case kIROp_UInt16Type:
+        sb << "uint16";
+        break;
+    case kIROp_UInt64Type:
+        sb << "uint64";
+        break;
+    case kIROp_UIntPtrType:
+        sb << "uintptr";
+        break;
+    case kIROp_CharType:
+        sb << "char";
+        break;
+    case kIROp_StringType:
+        sb << "string";
+        break;
     case kIROp_ArrayType:
         sb << "array<";
         getTypeNameHint(sb, type->getOperand(0));
@@ -420,33 +466,64 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type)
             auto textureType = as<IRResourceTypeBase>(type);
             switch (textureType->getAccess())
             {
-            case SLANG_RESOURCE_ACCESS_APPEND:         sb << "Append"; break;
-            case SLANG_RESOURCE_ACCESS_CONSUME:        sb << "Consume"; break;
-            case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: sb << "RasterizerOrdered"; break;
-            case SLANG_RESOURCE_ACCESS_WRITE:          sb << "RW"; break;
-            case SLANG_RESOURCE_ACCESS_FEEDBACK:       sb << "Feedback"; break;
-            case SLANG_RESOURCE_ACCESS_READ:           break;
+            case SLANG_RESOURCE_ACCESS_APPEND:
+                sb << "Append";
+                break;
+            case SLANG_RESOURCE_ACCESS_CONSUME:
+                sb << "Consume";
+                break;
+            case SLANG_RESOURCE_ACCESS_RASTER_ORDERED:
+                sb << "RasterizerOrdered";
+                break;
+            case SLANG_RESOURCE_ACCESS_WRITE:
+                sb << "RW";
+                break;
+            case SLANG_RESOURCE_ACCESS_FEEDBACK:
+                sb << "Feedback";
+                break;
+            case SLANG_RESOURCE_ACCESS_READ:
+                break;
             }
             if (textureType->isCombined())
             {
                 switch (textureType->GetBaseShape())
                 {
-                case SLANG_TEXTURE_1D:     sb << "Sampler1D"; break;
-                case SLANG_TEXTURE_2D:     sb << "Sampler2D"; break;
-                case SLANG_TEXTURE_3D:     sb << "Sampler3D"; break;
-                case SLANG_TEXTURE_CUBE:   sb << "SamplerCube"; break;
-                case SLANG_TEXTURE_BUFFER: sb << "SamplerBuffer"; break;
+                case SLANG_TEXTURE_1D:
+                    sb << "Sampler1D";
+                    break;
+                case SLANG_TEXTURE_2D:
+                    sb << "Sampler2D";
+                    break;
+                case SLANG_TEXTURE_3D:
+                    sb << "Sampler3D";
+                    break;
+                case SLANG_TEXTURE_CUBE:
+                    sb << "SamplerCube";
+                    break;
+                case SLANG_TEXTURE_BUFFER:
+                    sb << "SamplerBuffer";
+                    break;
                 }
             }
             else
             {
                 switch (textureType->GetBaseShape())
                 {
-                case SLANG_TEXTURE_1D:     sb << "Texture1D"; break;
-                case SLANG_TEXTURE_2D:     sb << "Texture2D"; break;
-                case SLANG_TEXTURE_3D:     sb << "Texture3D"; break;
-                case SLANG_TEXTURE_CUBE:   sb << "TextureCube"; break;
-                case SLANG_TEXTURE_BUFFER: sb << "Buffer"; break;
+                case SLANG_TEXTURE_1D:
+                    sb << "Texture1D";
+                    break;
+                case SLANG_TEXTURE_2D:
+                    sb << "Texture2D";
+                    break;
+                case SLANG_TEXTURE_3D:
+                    sb << "Texture3D";
+                    break;
+                case SLANG_TEXTURE_CUBE:
+                    sb << "TextureCube";
+                    break;
+                case SLANG_TEXTURE_BUFFER:
+                    sb << "Buffer";
+                    break;
                 }
             }
             if (textureType->isMultisample())
@@ -483,14 +560,24 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type)
         getTypeNameHint(sb, as<IRGLSLShaderStorageBufferType>(type)->getElementType());
         sb << ">";
         break;
-    case kIROp_HLSLByteAddressBufferType:   sb << "ByteAddressBuffer"; break;
-    case kIROp_HLSLRWByteAddressBufferType: sb << "RWByteAddressBuffer"; break;
+    case kIROp_HLSLByteAddressBufferType:
+        sb << "ByteAddressBuffer";
+        break;
+    case kIROp_HLSLRWByteAddressBufferType:
+        sb << "RWByteAddressBuffer";
+        break;
     case kIROp_HLSLRasterizerOrderedByteAddressBufferType:
         sb << "RasterizerOrderedByteAddressBuffer";
         break;
-    case kIROp_GLSLAtomicUintType:                  sb << "AtomicCounter"; break;
-    case kIROp_RaytracingAccelerationStructureType: sb << "RayTracingAccelerationStructure"; break;
-    case kIROp_HitObjectType:                       sb << "HitObject"; break;
+    case kIROp_GLSLAtomicUintType:
+        sb << "AtomicCounter";
+        break;
+    case kIROp_RaytracingAccelerationStructureType:
+        sb << "RayTracingAccelerationStructure";
+        break;
+    case kIROp_HitObjectType:
+        sb << "HitObject";
+        break;
     case kIROp_HLSLConstBufferPointerType:
         sb << "ConstantBufferPointer<";
         getTypeNameHint(sb, as<IRHLSLConstBufferPointerType>(type)->getValueType());
@@ -521,9 +608,15 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type)
         getTypeNameHint(sb, as<IRHLSLStructuredBufferTypeBase>(type)->getElementType());
         sb << ">";
         break;
-    case kIROp_SamplerStateType:           sb << "SamplerState"; break;
-    case kIROp_SamplerComparisonStateType: sb << "SamplerComparisonState"; break;
-    case kIROp_TextureFootprintType:       sb << "TextureFootprint"; break;
+    case kIROp_SamplerStateType:
+        sb << "SamplerState";
+        break;
+    case kIROp_SamplerComparisonStateType:
+        sb << "SamplerComparisonState";
+        break;
+    case kIROp_TextureFootprintType:
+        sb << "TextureFootprint";
+        break;
     case kIROp_Specialize:
         {
             auto specialize = as<IRSpecialize>(type);
@@ -567,7 +660,9 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type)
         getTypeNameHint(sb, as<IRMatrixType>(type)->getColumnCount());
         sb << ">";
         break;
-    case kIROp_IntLit: sb << as<IRIntLit>(type)->getValue(); break;
+    case kIROp_IntLit:
+        sb << as<IRIntLit>(type)->getValue();
+        break;
     default:
         if (auto decor = type->findDecoration<IRNameHintDecoration>())
             sb << decor->getName();
@@ -582,8 +677,11 @@ IRInst* getRootAddr(IRInst* addr)
         switch (addr->getOp())
         {
         case kIROp_GetElementPtr:
-        case kIROp_FieldAddress:  addr = addr->getOperand(0); continue;
-        default:                  break;
+        case kIROp_FieldAddress:
+            addr = addr->getOperand(0);
+            continue;
+        default:
+            break;
         }
         break;
     }
@@ -603,7 +701,8 @@ IRInst* getRootAddr(IRInst* addr, List<IRInst*>& outAccessChain, List<IRInst*>*
                 outTypes->add(addr->getFullType());
             addr = addr->getOperand(0);
             continue;
-        default: break;
+        default:
+            break;
         }
         break;
     }
@@ -662,7 +761,8 @@ bool isPtrLikeOrHandleType(IRInst* type)
     case kIROp_PtrType:
     case kIROp_RefType:
     case kIROp_ConstRefType:
-    case kIROp_GLSLShaderStorageBufferType: return true;
+    case kIROp_GLSLShaderStorageBufferType:
+        return true;
     }
     return false;
 }
@@ -789,13 +889,20 @@ IROp getSwapSideComparisonOp(IROp op)
 {
     switch (op)
     {
-    case kIROp_Eql:     return kIROp_Eql;
-    case kIROp_Neq:     return kIROp_Neq;
-    case kIROp_Leq:     return kIROp_Geq;
-    case kIROp_Geq:     return kIROp_Leq;
-    case kIROp_Less:    return kIROp_Greater;
-    case kIROp_Greater: return kIROp_Less;
-    default:            return kIROp_Nop;
+    case kIROp_Eql:
+        return kIROp_Eql;
+    case kIROp_Neq:
+        return kIROp_Neq;
+    case kIROp_Leq:
+        return kIROp_Geq;
+    case kIROp_Geq:
+        return kIROp_Leq;
+    case kIROp_Less:
+        return kIROp_Greater;
+    case kIROp_Greater:
+        return kIROp_Less;
+    default:
+        return kIROp_Nop;
     }
 }
 
@@ -852,8 +959,11 @@ void removeLinkageDecorations(IRGlobalValueWithCode* func)
         case kIROp_DllImportDecoration:
         case kIROp_CudaDeviceExportDecoration:
         case kIROp_DllExportDecoration:
-        case kIROp_HLSLExportDecoration:       toRemove.add(inst); break;
-        default:                               break;
+        case kIROp_HLSLExportDecoration:
+            toRemove.add(inst);
+            break;
+        default:
+            break;
         }
     }
     for (auto inst : toRemove)
@@ -893,12 +1003,16 @@ IRInst* tryFindBasePtr(IRInst* inst, IRInst* parentFunc)
     // Keep going up the tree until we find a variable.
     switch (inst->getOp())
     {
-    case kIROp_Var:   return getParentFunc(inst) == parentFunc ? inst : nullptr;
-    case kIROp_Param: return getParentFunc(inst) == parentFunc ? inst : nullptr;
+    case kIROp_Var:
+        return getParentFunc(inst) == parentFunc ? inst : nullptr;
+    case kIROp_Param:
+        return getParentFunc(inst) == parentFunc ? inst : nullptr;
     case kIROp_GetElementPtr:
         return tryFindBasePtr(as<IRGetElementPtr>(inst)->getBase(), parentFunc);
-    case kIROp_FieldAddress: return tryFindBasePtr(as<IRFieldAddress>(inst)->getBase(), parentFunc);
-    default:                 return nullptr;
+    case kIROp_FieldAddress:
+        return tryFindBasePtr(as<IRFieldAddress>(inst)->getBase(), parentFunc);
+    default:
+        return nullptr;
     }
 }
 
@@ -1061,7 +1175,8 @@ bool doesCalleeHaveSideEffect(IRInst* callee)
         {
         case kIROp_NoSideEffectDecoration:
         case kIROp_ReadNoneDecoration:
-        case kIROp_IgnoreSideEffectsDecoration: return false;
+        case kIROp_IgnoreSideEffectsDecoration:
+            return false;
         }
     }
     return true;
@@ -1101,8 +1216,10 @@ IRInst* getVulkanPayloadLocation(IRInst* payloadGlobalVar)
         case kIROp_VulkanRayPayloadInDecoration:
         case kIROp_VulkanCallablePayloadDecoration:
         case kIROp_VulkanCallablePayloadInDecoration:
-        case kIROp_VulkanHitObjectAttributesDecoration: return decor->getOperand(0);
-        default:                                        continue;
+        case kIROp_VulkanHitObjectAttributesDecoration:
+            return decor->getOperand(0);
+        default:
+            continue;
         }
     }
     return location;
@@ -1203,9 +1320,12 @@ bool isGlobalOrUnknownMutableAddress(IRGlobalValueWithCode* parentFunc, IRInst*
     case kIROp_GlobalParam:
     case kIROp_GlobalConstant:
     case kIROp_Var:
-    case kIROp_Param:          break;
-    case kIROp_Call:           return true;
-    default:                   return true;
+    case kIROp_Param:
+        break;
+    case kIROp_Call:
+        return true;
+    default:
+        return true;
     }
 
     auto addrInstParent = getParentFunc(root);
@@ -1216,9 +1336,12 @@ bool isZero(IRInst* inst)
 {
     switch (inst->getOp())
     {
-    case kIROp_IntLit:   return as<IRIntLit>(inst)->getValue() == 0;
-    case kIROp_FloatLit: return as<IRFloatLit>(inst)->getValue() == 0.0;
-    case kIROp_BoolLit:  return as<IRBoolLit>(inst)->getValue() == false;
+    case kIROp_IntLit:
+        return as<IRIntLit>(inst)->getValue() == 0;
+    case kIROp_FloatLit:
+        return as<IRFloatLit>(inst)->getValue() == 0.0;
+    case kIROp_BoolLit:
+        return as<IRBoolLit>(inst)->getValue() == false;
     case kIROp_MakeVector:
     case kIROp_MakeVectorFromScalar:
     case kIROp_MakeMatrix:
@@ -1236,8 +1359,10 @@ bool isZero(IRInst* inst)
             return true;
         }
     case kIROp_CastIntToFloat:
-    case kIROp_CastFloatToInt: return isZero(inst->getOperand(0));
-    default:                   return false;
+    case kIROp_CastFloatToInt:
+        return isZero(inst->getOperand(0));
+    default:
+        return false;
     }
 }
 
@@ -1245,9 +1370,12 @@ bool isOne(IRInst* inst)
 {
     switch (inst->getOp())
     {
-    case kIROp_IntLit:   return as<IRIntLit>(inst)->getValue() == 1;
-    case kIROp_FloatLit: return as<IRFloatLit>(inst)->getValue() == 1.0;
-    case kIROp_BoolLit:  return as<IRBoolLit>(inst)->getValue();
+    case kIROp_IntLit:
+        return as<IRIntLit>(inst)->getValue() == 1;
+    case kIROp_FloatLit:
+        return as<IRFloatLit>(inst)->getValue() == 1.0;
+    case kIROp_BoolLit:
+        return as<IRBoolLit>(inst)->getValue();
     case kIROp_MakeVector:
     case kIROp_MakeVectorFromScalar:
     case kIROp_MakeMatrix:
@@ -1265,8 +1393,10 @@ bool isOne(IRInst* inst)
             return true;
         }
     case kIROp_CastIntToFloat:
-    case kIROp_CastFloatToInt: return isOne(inst->getOperand(0));
-    default:                   return false;
+    case kIROp_CastFloatToInt:
+        return isOne(inst->getOperand(0));
+    default:
+        return false;
     }
 }
 
@@ -1274,8 +1404,10 @@ IRPtrTypeBase* isMutablePointerType(IRInst* inst)
 {
     switch (inst->getOp())
     {
-    case kIROp_ConstRefType: return nullptr;
-    default:                 return as<IRPtrTypeBase>(inst);
+    case kIROp_ConstRefType:
+        return nullptr;
+    default:
+        return as<IRPtrTypeBase>(inst);
     }
 }
 
@@ -1527,13 +1659,20 @@ IRType* getSPIRVSampledElementType(IRInst* sampledType)
     IRBuilder builder(sampledType);
     switch (sampledElementType->getOp())
     {
-    case kIROp_HalfType:   sampledElementType = builder.getBasicType(BaseType::Float); break;
+    case kIROp_HalfType:
+        sampledElementType = builder.getBasicType(BaseType::Float);
+        break;
     case kIROp_UInt16Type:
     case kIROp_UInt8Type:
-    case kIROp_CharType:   sampledElementType = builder.getBasicType(BaseType::UInt); break;
+    case kIROp_CharType:
+        sampledElementType = builder.getBasicType(BaseType::UInt);
+        break;
     case kIROp_Int8Type:
-    case kIROp_Int16Type:  sampledElementType = builder.getBasicType(BaseType::Int); break;
-    default:               break;
+    case kIROp_Int16Type:
+        sampledElementType = builder.getBasicType(BaseType::Int);
+        break;
+    default:
+        break;
     }
     return sampledElementType;
 }
@@ -1565,23 +1704,40 @@ UnownedStringSlice getBasicTypeNameHint(IRType* basicType)
 {
     switch (basicType->getOp())
     {
-    case kIROp_IntType:     return UnownedStringSlice::fromLiteral("int");
-    case kIROp_Int8Type:    return UnownedStringSlice::fromLiteral("int8");
-    case kIROp_Int16Type:   return UnownedStringSlice::fromLiteral("int16");
-    case kIROp_Int64Type:   return UnownedStringSlice::fromLiteral("int64");
-    case kIROp_IntPtrType:  return UnownedStringSlice::fromLiteral("intptr");
-    case kIROp_UIntType:    return UnownedStringSlice::fromLiteral("uint");
-    case kIROp_UInt8Type:   return UnownedStringSlice::fromLiteral("uint8");
-    case kIROp_UInt16Type:  return UnownedStringSlice::fromLiteral("uint16");
-    case kIROp_UInt64Type:  return UnownedStringSlice::fromLiteral("uint64");
-    case kIROp_UIntPtrType: return UnownedStringSlice::fromLiteral("uintptr");
-    case kIROp_FloatType:   return UnownedStringSlice::fromLiteral("float");
-    case kIROp_HalfType:    return UnownedStringSlice::fromLiteral("half");
-    case kIROp_DoubleType:  return UnownedStringSlice::fromLiteral("double");
-    case kIROp_BoolType:    return UnownedStringSlice::fromLiteral("bool");
-    case kIROp_VoidType:    return UnownedStringSlice::fromLiteral("void");
-    case kIROp_CharType:    return UnownedStringSlice::fromLiteral("char");
-    default:                return UnownedStringSlice();
+    case kIROp_IntType:
+        return UnownedStringSlice::fromLiteral("int");
+    case kIROp_Int8Type:
+        return UnownedStringSlice::fromLiteral("int8");
+    case kIROp_Int16Type:
+        return UnownedStringSlice::fromLiteral("int16");
+    case kIROp_Int64Type:
+        return UnownedStringSlice::fromLiteral("int64");
+    case kIROp_IntPtrType:
+        return UnownedStringSlice::fromLiteral("intptr");
+    case kIROp_UIntType:
+        return UnownedStringSlice::fromLiteral("uint");
+    case kIROp_UInt8Type:
+        return UnownedStringSlice::fromLiteral("uint8");
+    case kIROp_UInt16Type:
+        return UnownedStringSlice::fromLiteral("uint16");
+    case kIROp_UInt64Type:
+        return UnownedStringSlice::fromLiteral("uint64");
+    case kIROp_UIntPtrType:
+        return UnownedStringSlice::fromLiteral("uintptr");
+    case kIROp_FloatType:
+        return UnownedStringSlice::fromLiteral("float");
+    case kIROp_HalfType:
+        return UnownedStringSlice::fromLiteral("half");
+    case kIROp_DoubleType:
+        return UnownedStringSlice::fromLiteral("double");
+    case kIROp_BoolType:
+        return UnownedStringSlice::fromLiteral("bool");
+    case kIROp_VoidType:
+        return UnownedStringSlice::fromLiteral("void");
+    case kIROp_CharType:
+        return UnownedStringSlice::fromLiteral("char");
+    default:
+        return UnownedStringSlice();
     }
 }
 
@@ -1639,8 +1795,10 @@ struct GenericChildrenMigrationContextImpl
                 case kIROp_ClassType:
                 case kIROp_Func:
                 case kIROp_Generic:
-                case kIROp_Expand:        return false;
-                default:                  break;
+                case kIROp_Expand:
+                    return false;
+                default:
+                    break;
                 }
                 if (as<IRConstant>(inst))
                     return false;
@@ -1706,7 +1864,8 @@ IRType* dropNormAttributes(IRType* const t)
         switch (a->getAttr()->getOp())
         {
         case kIROp_UNormAttr:
-        case kIROp_SNormAttr: return dropNormAttributes(a->getBaseType());
+        case kIROp_SNormAttr:
+            return dropNormAttributes(a->getBaseType());
         }
     }
     return t;