format

* format

* Minor test fixes

* enable checking cpp format in ci

1 files changed, 265 insertions, 201 deletions

diff --git a/source/slang/slang-ir-layout.cpp b/source/slang/slang-ir-layout.cpp
index 9662dc522..fb887ab73 100644
--- a/source/slang/slang-ir-layout.cpp
+++ b/source/slang/slang-ir-layout.cpp
@@ -1,9 +1,8 @@
 // slang-ir-layout.cpp
 #include "slang-ir-layout.h"
 
-#include "slang-ir-insts.h"
-
 #include "slang-ir-generics-lowering-context.h"
+#include "slang-ir-insts.h"
 
 // This file implements facilities for computing and caching layout
 // information on IR types.
@@ -96,19 +95,16 @@ static Result _calcSizeAndAlignment(
     case CodeGenTarget::HostCPPSource:
     case CodeGenTarget::HostHostCallable:
     case CodeGenTarget::HostExecutable:
-    case CodeGenTarget::HostSharedLibrary:
-        kPointerSize = (int)sizeof(void*);
-        break;
+    case CodeGenTarget::HostSharedLibrary: kPointerSize = (int)sizeof(void*); break;
     }
 
     switch (type->getOp())
     {
 
 #define CASE(TYPE, SIZE, ALIGNMENT)                                 \
-case kIROp_##TYPE##Type:                                        \
-    *outSizeAndAlignment = IRSizeAndAlignment(SIZE, ALIGNMENT); \
-    return SLANG_OK                                             \
-    /* end */
+    case kIROp_##TYPE##Type:                                        \
+        *outSizeAndAlignment = IRSizeAndAlignment(SIZE, ALIGNMENT); \
+        return SLANG_OK /* end */
 
         // Most base types are "naturally aligned" (meaning alignment and size are the same)
 #define BASE(TYPE, SIZE) CASE(TYPE, SIZE, SIZE)
@@ -149,167 +145,190 @@ case kIROp_##TYPE##Type:                                        \
 #undef CASE
 
     case kIROp_StructType:
-    {
-        auto structType = cast<IRStructType>(type);
-        IRSizeAndAlignment structLayout;
-        IRIntegerValue offset = 0;
-        bool seenFinalUnsizedArrayField = false;
-        for (auto field : structType->getFields())
         {
-            // If we failed to catch an unsized array earlier in the pipeline,
-            // this will pick it up before generating nonsense results for
-            // subsequent offsets
-            SLANG_ASSERT(!seenFinalUnsizedArrayField);
-
-            IRSizeAndAlignment fieldTypeLayout;
-            SLANG_RETURN_ON_FAIL(getSizeAndAlignment(optionSet, rules, field->getFieldType(), &fieldTypeLayout));
-            seenFinalUnsizedArrayField = fieldTypeLayout.size == IRSizeAndAlignment::kIndeterminateSize;
-
-            structLayout.size = align(offset, fieldTypeLayout.alignment);
-            structLayout.alignment = std::max(structLayout.alignment, fieldTypeLayout.alignment);
-
-            IRIntegerValue fieldOffset = structLayout.size;
-            if (auto module = type->getModule())
+            auto structType = cast<IRStructType>(type);
+            IRSizeAndAlignment structLayout;
+            IRIntegerValue offset = 0;
+            bool seenFinalUnsizedArrayField = false;
+            for (auto field : structType->getFields())
             {
-                // If we are in a situation where attaching new
-                // decorations is possible, then we want to
-                // cache the field offset on the IR field
-                // instruction.
-                //
-                IRBuilder builder(module);
-
-                auto intType = builder.getIntType();
-                builder.addDecoration(
-                    field,
-                    kIROp_OffsetDecoration,
-                    builder.getIntValue(intType, (IRIntegerValue)rules->ruleName),
-                    builder.getIntValue(intType, fieldOffset));
-            }
-
-            structLayout.size += fieldTypeLayout.size;
-            offset = structLayout.size;
-            if (as<IRMatrixType>(field->getFieldType()) || as<IRArrayTypeBase>(field->getFieldType()) || as<IRStructType>(field->getFieldType()))
-            {
-                offset = rules->adjustOffsetForNextAggregateMember(offset, fieldTypeLayout.alignment);
+                // If we failed to catch an unsized array earlier in the pipeline,
+                // this will pick it up before generating nonsense results for
+                // subsequent offsets
+                SLANG_ASSERT(!seenFinalUnsizedArrayField);
+
+                IRSizeAndAlignment fieldTypeLayout;
+                SLANG_RETURN_ON_FAIL(
+                    getSizeAndAlignment(optionSet, rules, field->getFieldType(), &fieldTypeLayout));
+                seenFinalUnsizedArrayField =
+                    fieldTypeLayout.size == IRSizeAndAlignment::kIndeterminateSize;
+
+                structLayout.size = align(offset, fieldTypeLayout.alignment);
+                structLayout.alignment =
+                    std::max(structLayout.alignment, fieldTypeLayout.alignment);
+
+                IRIntegerValue fieldOffset = structLayout.size;
+                if (auto module = type->getModule())
+                {
+                    // If we are in a situation where attaching new
+                    // decorations is possible, then we want to
+                    // cache the field offset on the IR field
+                    // instruction.
+                    //
+                    IRBuilder builder(module);
+
+                    auto intType = builder.getIntType();
+                    builder.addDecoration(
+                        field,
+                        kIROp_OffsetDecoration,
+                        builder.getIntValue(intType, (IRIntegerValue)rules->ruleName),
+                        builder.getIntValue(intType, fieldOffset));
+                }
+
+                structLayout.size += fieldTypeLayout.size;
+                offset = structLayout.size;
+                if (as<IRMatrixType>(field->getFieldType()) ||
+                    as<IRArrayTypeBase>(field->getFieldType()) ||
+                    as<IRStructType>(field->getFieldType()))
+                {
+                    offset = rules->adjustOffsetForNextAggregateMember(
+                        offset,
+                        fieldTypeLayout.alignment);
+                }
             }
+            *outSizeAndAlignment = rules->alignCompositeElement(structLayout);
+            return SLANG_OK;
         }
-        *outSizeAndAlignment = rules->alignCompositeElement(structLayout);
-        return SLANG_OK;
-    }
-    break;
+        break;
 
     case kIROp_ArrayType:
-    {
-        auto arrayType = cast<IRArrayType>(type);
-
-        return _calcArraySizeAndAlignment(
-            optionSet,
-            rules ,
-            arrayType->getElementType(),
-            arrayType->getElementCount(),
-            outSizeAndAlignment);
-    }
-    break;
+        {
+            auto arrayType = cast<IRArrayType>(type);
+
+            return _calcArraySizeAndAlignment(
+                optionSet,
+                rules,
+                arrayType->getElementType(),
+                arrayType->getElementCount(),
+                outSizeAndAlignment);
+        }
+        break;
 
     case kIROp_AtomicType:
-    {
-        auto atomicType = cast<IRAtomicType>(type);
-        _calcSizeAndAlignment(optionSet, rules, atomicType->getElementType(), outSizeAndAlignment);
-        return SLANG_OK;
-    }
-    break;
+        {
+            auto atomicType = cast<IRAtomicType>(type);
+            _calcSizeAndAlignment(
+                optionSet,
+                rules,
+                atomicType->getElementType(),
+                outSizeAndAlignment);
+            return SLANG_OK;
+        }
+        break;
 
     case kIROp_UnsizedArrayType:
-    {
-        auto unsizedArrayType = cast<IRUnsizedArrayType>(type);
-        getSizeAndAlignment(optionSet, rules, unsizedArrayType->getElementType(), outSizeAndAlignment);
-        outSizeAndAlignment->size = IRSizeAndAlignment::kIndeterminateSize;
-        return SLANG_OK;
-    }
-    break;
+        {
+            auto unsizedArrayType = cast<IRUnsizedArrayType>(type);
+            getSizeAndAlignment(
+                optionSet,
+                rules,
+                unsizedArrayType->getElementType(),
+                outSizeAndAlignment);
+            outSizeAndAlignment->size = IRSizeAndAlignment::kIndeterminateSize;
+            return SLANG_OK;
+        }
+        break;
 
     case kIROp_VectorType:
-    {
-        auto vecType = cast<IRVectorType>(type);
-        IRSizeAndAlignment elementTypeLayout;
-        getSizeAndAlignment(optionSet, rules, vecType->getElementType(), &elementTypeLayout);
-        *outSizeAndAlignment = rules->getVectorSizeAndAlignment(elementTypeLayout, getIntegerValueFromInst(vecType->getElementCount()));
-        return SLANG_OK;
-    }
-    break;
+        {
+            auto vecType = cast<IRVectorType>(type);
+            IRSizeAndAlignment elementTypeLayout;
+            getSizeAndAlignment(optionSet, rules, vecType->getElementType(), &elementTypeLayout);
+            *outSizeAndAlignment = rules->getVectorSizeAndAlignment(
+                elementTypeLayout,
+                getIntegerValueFromInst(vecType->getElementCount()));
+            return SLANG_OK;
+        }
+        break;
     case kIROp_AnyValueType:
-    {
-        auto anyValType = cast<IRAnyValueType>(type);
-        outSizeAndAlignment->size = getIntVal(anyValType->getSize());
-        outSizeAndAlignment->alignment = 4;
-        *outSizeAndAlignment = rules->alignCompositeElement(*outSizeAndAlignment);
-        return SLANG_OK;
-    }
-    break;
+        {
+            auto anyValType = cast<IRAnyValueType>(type);
+            outSizeAndAlignment->size = getIntVal(anyValType->getSize());
+            outSizeAndAlignment->alignment = 4;
+            *outSizeAndAlignment = rules->alignCompositeElement(*outSizeAndAlignment);
+            return SLANG_OK;
+        }
+        break;
     case kIROp_TupleType:
-    {
-        auto tupleType = cast<IRTupleType>(type);
-        IRSizeAndAlignment resultLayout;
-        for (UInt i = 0; i < tupleType->getOperandCount(); i++)
         {
-            auto elementType = tupleType->getOperand(i);
-            IRSizeAndAlignment fieldTypeLayout;
-            SLANG_RETURN_ON_FAIL(getSizeAndAlignment(optionSet, rules, (IRType*)elementType, &fieldTypeLayout));
-            resultLayout.size = align(resultLayout.size, fieldTypeLayout.alignment);
-            resultLayout.alignment = std::max(resultLayout.alignment, fieldTypeLayout.alignment);
+            auto tupleType = cast<IRTupleType>(type);
+            IRSizeAndAlignment resultLayout;
+            for (UInt i = 0; i < tupleType->getOperandCount(); i++)
+            {
+                auto elementType = tupleType->getOperand(i);
+                IRSizeAndAlignment fieldTypeLayout;
+                SLANG_RETURN_ON_FAIL(
+                    getSizeAndAlignment(optionSet, rules, (IRType*)elementType, &fieldTypeLayout));
+                resultLayout.size = align(resultLayout.size, fieldTypeLayout.alignment);
+                resultLayout.alignment =
+                    std::max(resultLayout.alignment, fieldTypeLayout.alignment);
+            }
+            *outSizeAndAlignment = rules->alignCompositeElement(resultLayout);
+            return SLANG_OK;
         }
-        *outSizeAndAlignment = rules->alignCompositeElement(resultLayout);
-        return SLANG_OK;
-    }
-    break;
+        break;
     case kIROp_WitnessTableType:
     case kIROp_WitnessTableIDType:
     case kIROp_RTTIHandleType:
-    {
-        outSizeAndAlignment->size = kRTTIHandleSize;
-        outSizeAndAlignment->alignment = 4;
-        return SLANG_OK;
-    }
-    break;
+        {
+            outSizeAndAlignment->size = kRTTIHandleSize;
+            outSizeAndAlignment->alignment = 4;
+            return SLANG_OK;
+        }
+        break;
     case kIROp_InterfaceType:
-    {
-        auto interfaceType = cast<IRInterfaceType>(type);
-        auto size = SharedGenericsLoweringContext::getInterfaceAnyValueSize(interfaceType, interfaceType->sourceLoc);
-        size += kRTTIHeaderSize;
-        size = align(size, 4);
-        IRSizeAndAlignment resultLayout;
-        resultLayout.size = size;
-        resultLayout.alignment = 4;
-        *outSizeAndAlignment = rules->alignCompositeElement(resultLayout);
-        return SLANG_OK;
-    }
-    break;
-    case kIROp_MatrixType:
-    {
-        auto matType = cast<IRMatrixType>(type);
-        IRBuilder builder(type->getModule());
-        if (getIntegerValueFromInst(matType->getLayout()) == SLANG_MATRIX_LAYOUT_COLUMN_MAJOR)
         {
-            auto colVector = builder.getVectorType(matType->getElementType(), matType->getRowCount());
-            return _calcArraySizeAndAlignment(
-                optionSet,
-                rules,
-                colVector,
-                matType->getColumnCount(),
-                outSizeAndAlignment);
+            auto interfaceType = cast<IRInterfaceType>(type);
+            auto size = SharedGenericsLoweringContext::getInterfaceAnyValueSize(
+                interfaceType,
+                interfaceType->sourceLoc);
+            size += kRTTIHeaderSize;
+            size = align(size, 4);
+            IRSizeAndAlignment resultLayout;
+            resultLayout.size = size;
+            resultLayout.alignment = 4;
+            *outSizeAndAlignment = rules->alignCompositeElement(resultLayout);
+            return SLANG_OK;
         }
-        else
+        break;
+    case kIROp_MatrixType:
         {
-            auto rowVector = builder.getVectorType(matType->getElementType(), matType->getColumnCount());
-            return _calcArraySizeAndAlignment(
-                optionSet,
-                rules,
-                rowVector,
-                matType->getRowCount(),
-                outSizeAndAlignment);
+            auto matType = cast<IRMatrixType>(type);
+            IRBuilder builder(type->getModule());
+            if (getIntegerValueFromInst(matType->getLayout()) == SLANG_MATRIX_LAYOUT_COLUMN_MAJOR)
+            {
+                auto colVector =
+                    builder.getVectorType(matType->getElementType(), matType->getRowCount());
+                return _calcArraySizeAndAlignment(
+                    optionSet,
+                    rules,
+                    colVector,
+                    matType->getColumnCount(),
+                    outSizeAndAlignment);
+            }
+            else
+            {
+                auto rowVector =
+                    builder.getVectorType(matType->getElementType(), matType->getColumnCount());
+                return _calcArraySizeAndAlignment(
+                    optionSet,
+                    rules,
+                    rowVector,
+                    matType->getRowCount(),
+                    outSizeAndAlignment);
+            }
         }
-    }
-    break;
+        break;
     case kIROp_OutType:
     case kIROp_InOutType:
     case kIROp_RefType:
@@ -320,11 +339,11 @@ case kIROp_##TYPE##Type:                                        \
     case kIROp_ComPtrType:
     case kIROp_NativeStringType:
     case kIROp_HLSLConstBufferPointerType:
-    {
-        *outSizeAndAlignment = IRSizeAndAlignment(kPointerSize, kPointerSize);
-        return SLANG_OK;
-    }
-    break;
+        {
+            *outSizeAndAlignment = IRSizeAndAlignment(kPointerSize, kPointerSize);
+            return SLANG_OK;
+        }
+        break;
     case kIROp_ScalarBufferLayoutType:
     case kIROp_Std140BufferLayoutType:
     case kIROp_Std430BufferLayoutType:
@@ -332,13 +351,16 @@ case kIROp_##TYPE##Type:                                        \
         *outSizeAndAlignment = IRSizeAndAlignment(0, 4);
         return SLANG_OK;
     case kIROp_AttributedType:
-    {
-        auto attributedType = cast<IRAttributedType>(type);
-        SLANG_ASSERT(attributedType->getAttr()->getOp() == kIROp_NoDiffAttr); 
-        return getSizeAndAlignment(optionSet, rules, attributedType->getBaseType(), outSizeAndAlignment);
-    }
-    default:
-        break;
+        {
+            auto attributedType = cast<IRAttributedType>(type);
+            SLANG_ASSERT(attributedType->getAttr()->getOp() == kIROp_NoDiffAttr);
+            return getSizeAndAlignment(
+                optionSet,
+                rules,
+                attributedType->getBaseType(),
+                outSizeAndAlignment);
+        }
+    default: break;
     }
     if (as<IRResourceTypeBase>(type) || as<IRSamplerStateTypeBase>(type))
     {
@@ -349,7 +371,9 @@ case kIROp_##TYPE##Type:                                        \
     return SLANG_FAIL;
 }
 
-IRSizeAndAlignmentDecoration* findSizeAndAlignmentDecorationForLayout(IRType* type, IRTypeLayoutRuleName layoutName)
+IRSizeAndAlignmentDecoration* findSizeAndAlignmentDecorationForLayout(
+    IRType* type,
+    IRTypeLayoutRuleName layoutName)
 {
     for (auto decorInst : type->getDecorations())
     {
@@ -362,7 +386,11 @@ IRSizeAndAlignmentDecoration* findSizeAndAlignmentDecorationForLayout(IRType* ty
     return nullptr;
 }
 
-Result getSizeAndAlignment(CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRType* type, IRSizeAndAlignment* outSizeAndAlignment)
+Result getSizeAndAlignment(
+    CompilerOptionSet& optionSet,
+    IRTypeLayoutRules* rules,
+    IRType* type,
+    IRSizeAndAlignment* outSizeAndAlignment)
 {
     if (auto decor = findSizeAndAlignmentDecorationForLayout(type, rules->ruleName))
     {
@@ -390,7 +418,9 @@ Result getSizeAndAlignment(CompilerOptionSet& optionSet, IRTypeLayoutRules* rule
     *outSizeAndAlignment = sizeAndAlignment;
     return SLANG_OK;
 }
-IROffsetDecoration* findOffsetDecorationForLayout(IRStructField* field, IRTypeLayoutRuleName layoutName)
+IROffsetDecoration* findOffsetDecorationForLayout(
+    IRStructField* field,
+    IRTypeLayoutRuleName layoutName)
 {
     for (auto decorInst : field->getDecorations())
     {
@@ -403,7 +433,11 @@ IROffsetDecoration* findOffsetDecorationForLayout(IRStructField* field, IRTypeLa
     return nullptr;
 }
 
-Result getOffset(CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRStructField* field, IRIntegerValue* outOffset)
+Result getOffset(
+    CompilerOptionSet& optionSet,
+    IRTypeLayoutRules* rules,
+    IRStructField* field,
+    IRIntegerValue* outOffset)
 {
     if (auto decor = findOffsetDecorationForLayout(field, rules->ruleName))
     {
@@ -438,11 +472,10 @@ Result getOffset(CompilerOptionSet& optionSet, IRTypeLayoutRules* rules, IRStruc
 
 struct NaturalLayoutRules : IRTypeLayoutRules
 {
-    NaturalLayoutRules()
-    {
-        ruleName = IRTypeLayoutRuleName::Natural;
-    }
-    virtual IRIntegerValue adjustOffsetForNextAggregateMember(IRIntegerValue currentSize, IRIntegerValue lastElementAlignment)
+    NaturalLayoutRules() { ruleName = IRTypeLayoutRuleName::Natural; }
+    virtual IRIntegerValue adjustOffsetForNextAggregateMember(
+        IRIntegerValue currentSize,
+        IRIntegerValue lastElementAlignment)
     {
         SLANG_UNUSED(lastElementAlignment);
         return currentSize;
@@ -451,7 +484,9 @@ struct NaturalLayoutRules : IRTypeLayoutRules
     {
         return elementSize;
     }
-    virtual IRSizeAndAlignment getVectorSizeAndAlignment(IRSizeAndAlignment element, IRIntegerValue count)
+    virtual IRSizeAndAlignment getVectorSizeAndAlignment(
+        IRSizeAndAlignment element,
+        IRIntegerValue count)
     {
         return IRSizeAndAlignment(element.size * count, element.alignment);
     }
@@ -459,10 +494,7 @@ struct NaturalLayoutRules : IRTypeLayoutRules
 
 struct ConstantBufferLayoutRules : IRTypeLayoutRules
 {
-    ConstantBufferLayoutRules()
-    {
-        ruleName = IRTypeLayoutRuleName::D3DConstantBuffer;
-    }
+    ConstantBufferLayoutRules() { ruleName = IRTypeLayoutRuleName::D3DConstantBuffer; }
 
     /// Next member only aligns to 16 if the next member is an array/matrix/struct
     virtual IRSizeAndAlignment alignCompositeElement(IRSizeAndAlignment currentSize)
@@ -471,52 +503,60 @@ struct ConstantBufferLayoutRules : IRTypeLayoutRules
         return IRSizeAndAlignment(currentSize.size, 16);
     }
 
-    virtual IRIntegerValue adjustOffsetForNextAggregateMember(IRIntegerValue currentSize, IRIntegerValue lastElementAlignment)
+    virtual IRIntegerValue adjustOffsetForNextAggregateMember(
+        IRIntegerValue currentSize,
+        IRIntegerValue lastElementAlignment)
     {
         SLANG_UNUSED(lastElementAlignment);
         return currentSize;
     }
 
-    virtual IRSizeAndAlignment getVectorSizeAndAlignment(IRSizeAndAlignment element, IRIntegerValue count)
+    virtual IRSizeAndAlignment getVectorSizeAndAlignment(
+        IRSizeAndAlignment element,
+        IRIntegerValue count)
     {
         IRIntegerValue countForAlignment = count;
-        return IRSizeAndAlignment((int)(element.size * count), (int)(element.size * countForAlignment));
+        return IRSizeAndAlignment(
+            (int)(element.size * count),
+            (int)(element.size * countForAlignment));
     }
 };
 
 struct Std430LayoutRules : IRTypeLayoutRules
 {
-    Std430LayoutRules()
-    {
-        ruleName = IRTypeLayoutRuleName::Std430;
-    }
+    Std430LayoutRules() { ruleName = IRTypeLayoutRuleName::Std430; }
 
     virtual IRSizeAndAlignment alignCompositeElement(IRSizeAndAlignment elementSize)
     {
         return elementSize;
     }
-    virtual IRIntegerValue adjustOffsetForNextAggregateMember(IRIntegerValue currentSize, IRIntegerValue lastElementAlignment)
+    virtual IRIntegerValue adjustOffsetForNextAggregateMember(
+        IRIntegerValue currentSize,
+        IRIntegerValue lastElementAlignment)
     {
         return align(currentSize, (int)lastElementAlignment);
     }
 
-    virtual IRSizeAndAlignment getVectorSizeAndAlignment(IRSizeAndAlignment element, IRIntegerValue count)
+    virtual IRSizeAndAlignment getVectorSizeAndAlignment(
+        IRSizeAndAlignment element,
+        IRIntegerValue count)
     {
         IRIntegerValue countForAlignment = count;
         if (count == 3)
             countForAlignment = 4;
-        return IRSizeAndAlignment((int)(element.size * count), (int)(element.size * countForAlignment));
+        return IRSizeAndAlignment(
+            (int)(element.size * count),
+            (int)(element.size * countForAlignment));
     }
 };
 
 struct Std140LayoutRules : IRTypeLayoutRules
 {
-    Std140LayoutRules()
-    {
-        ruleName = IRTypeLayoutRuleName::Std140;
-    }
+    Std140LayoutRules() { ruleName = IRTypeLayoutRuleName::Std140; }
 
-    virtual IRIntegerValue adjustOffsetForNextAggregateMember(IRIntegerValue currentSize, IRIntegerValue lastElementAlignment)
+    virtual IRIntegerValue adjustOffsetForNextAggregateMember(
+        IRIntegerValue currentSize,
+        IRIntegerValue lastElementAlignment)
     {
         return align(currentSize, (int)lastElementAlignment);
     }
@@ -526,21 +566,35 @@ struct Std140LayoutRules : IRTypeLayoutRules
         elementSize.size = align(elementSize.size, elementSize.alignment);
         return elementSize;
     }
-    virtual IRSizeAndAlignment getVectorSizeAndAlignment(IRSizeAndAlignment element, IRIntegerValue count)
+    virtual IRSizeAndAlignment getVectorSizeAndAlignment(
+        IRSizeAndAlignment element,
+        IRIntegerValue count)
     {
         IRIntegerValue alignmentCount = count;
         if (count == 3)
             alignmentCount = 4;
-        return IRSizeAndAlignment((int)(element.size * count), (int)(element.size * alignmentCount));
+        return IRSizeAndAlignment(
+            (int)(element.size * count),
+            (int)(element.size * alignmentCount));
     }
 };
 
-Result getNaturalSizeAndAlignment(CompilerOptionSet& optionSet, IRType* type, IRSizeAndAlignment* outSizeAndAlignment)
+Result getNaturalSizeAndAlignment(
+    CompilerOptionSet& optionSet,
+    IRType* type,
+    IRSizeAndAlignment* outSizeAndAlignment)
 {
-    return getSizeAndAlignment(optionSet, IRTypeLayoutRules::getNatural(), type, outSizeAndAlignment);
+    return getSizeAndAlignment(
+        optionSet,
+        IRTypeLayoutRules::getNatural(),
+        type,
+        outSizeAndAlignment);
 }
 
-Result getNaturalOffset(CompilerOptionSet& optionSet, IRStructField* field, IRIntegerValue* outOffset)
+Result getNaturalOffset(
+    CompilerOptionSet& optionSet,
+    IRStructField* field,
+    IRIntegerValue* outOffset)
 {
     return getOffset(optionSet, IRTypeLayoutRules::getNatural(), field, outOffset);
 }
@@ -550,12 +604,22 @@ Result getNaturalOffset(CompilerOptionSet& optionSet, IRStructField* field, IRIn
 // Std430 Layout
 //////////////////////////
 
-Result getStd430SizeAndAlignment(CompilerOptionSet& optionSet, IRType* type, IRSizeAndAlignment* outSizeAndAlignment)
+Result getStd430SizeAndAlignment(
+    CompilerOptionSet& optionSet,
+    IRType* type,
+    IRSizeAndAlignment* outSizeAndAlignment)
 {
-    return getSizeAndAlignment(optionSet, IRTypeLayoutRules::getStd430(), type, outSizeAndAlignment);
+    return getSizeAndAlignment(
+        optionSet,
+        IRTypeLayoutRules::getStd430(),
+        type,
+        outSizeAndAlignment);
 }
 
-Result getStd430Offset(CompilerOptionSet& optionSet, IRStructField* field, IRIntegerValue* outOffset)
+Result getStd430Offset(
+    CompilerOptionSet& optionSet,
+    IRStructField* field,
+    IRIntegerValue* outOffset)
 {
     return getOffset(optionSet, IRTypeLayoutRules::getStd430(), field, outOffset);
 }
@@ -586,12 +650,12 @@ IRTypeLayoutRules* IRTypeLayoutRules::get(IRTypeLayoutRuleName name)
 {
     switch (name)
     {
-        case IRTypeLayoutRuleName::Std430: return getStd430();
-        case IRTypeLayoutRuleName::Std140: return getStd140();
-        case IRTypeLayoutRuleName::Natural: return getNatural();
-        case IRTypeLayoutRuleName::D3DConstantBuffer: return getConstantBuffer();
-        default: return nullptr;
+    case IRTypeLayoutRuleName::Std430:            return getStd430();
+    case IRTypeLayoutRuleName::Std140:            return getStd140();
+    case IRTypeLayoutRuleName::Natural:           return getNatural();
+    case IRTypeLayoutRuleName::D3DConstantBuffer: return getConstantBuffer();
+    default:                                      return nullptr;
     }
 }
 
-}
+} // namespace Slang