format

* format

* Minor test fixes

* enable checking cpp format in ci

1 files changed, 249 insertions, 245 deletions

diff --git a/tools/gfx/d3d11/d3d11-helper-functions.cpp b/tools/gfx/d3d11/d3d11-helper-functions.cpp
index 6774b7d93..76b339880 100644
--- a/tools/gfx/d3d11/d3d11-helper-functions.cpp
+++ b/tools/gfx/d3d11/d3d11-helper-functions.cpp
@@ -10,345 +10,346 @@ using namespace Slang;
 
 namespace d3d11
 {
-    bool isSupportedNVAPIOp(IUnknown* dev, uint32_t op)
-    {
+bool isSupportedNVAPIOp(IUnknown* dev, uint32_t op)
+{
 #ifdef GFX_NVAPI
-        {
-            bool isSupported;
-            NvAPI_Status status = NvAPI_D3D11_IsNvShaderExtnOpCodeSupported(dev, NvU32(op), &isSupported);
-            return status == NVAPI_OK && isSupported;
-        }
+    {
+        bool isSupported;
+        NvAPI_Status status =
+            NvAPI_D3D11_IsNvShaderExtnOpCodeSupported(dev, NvU32(op), &isSupported);
+        return status == NVAPI_OK && isSupported;
+    }
 #else
-        return false;
+    return false;
 #endif
-    }
+}
 
-    D3D11_BIND_FLAG calcResourceFlag(ResourceState state)
+D3D11_BIND_FLAG calcResourceFlag(ResourceState state)
+{
+    switch (state)
     {
-        switch (state)
-        {
-        case ResourceState::VertexBuffer:
-            return D3D11_BIND_VERTEX_BUFFER;
-        case ResourceState::IndexBuffer:
-            return D3D11_BIND_INDEX_BUFFER;
-        case ResourceState::ConstantBuffer:
-            return D3D11_BIND_CONSTANT_BUFFER;
-        case ResourceState::StreamOutput:
-            return D3D11_BIND_STREAM_OUTPUT;
-        case ResourceState::RenderTarget:
-            return D3D11_BIND_RENDER_TARGET;
-        case ResourceState::DepthRead:
-        case ResourceState::DepthWrite:
-            return D3D11_BIND_DEPTH_STENCIL;
-        case ResourceState::UnorderedAccess:
-            return D3D11_BIND_UNORDERED_ACCESS;
-        case ResourceState::ShaderResource:
-        case ResourceState::PixelShaderResource:
-        case ResourceState::NonPixelShaderResource:
-            return D3D11_BIND_SHADER_RESOURCE;
-        default:
-            return D3D11_BIND_FLAG(0);
-        }
+    case ResourceState::VertexBuffer:           return D3D11_BIND_VERTEX_BUFFER;
+    case ResourceState::IndexBuffer:            return D3D11_BIND_INDEX_BUFFER;
+    case ResourceState::ConstantBuffer:         return D3D11_BIND_CONSTANT_BUFFER;
+    case ResourceState::StreamOutput:           return D3D11_BIND_STREAM_OUTPUT;
+    case ResourceState::RenderTarget:           return D3D11_BIND_RENDER_TARGET;
+    case ResourceState::DepthRead:
+    case ResourceState::DepthWrite:             return D3D11_BIND_DEPTH_STENCIL;
+    case ResourceState::UnorderedAccess:        return D3D11_BIND_UNORDERED_ACCESS;
+    case ResourceState::ShaderResource:
+    case ResourceState::PixelShaderResource:
+    case ResourceState::NonPixelShaderResource: return D3D11_BIND_SHADER_RESOURCE;
+    default:                                    return D3D11_BIND_FLAG(0);
     }
+}
 
-    int _calcResourceBindFlags(ResourceStateSet allowedStates)
+int _calcResourceBindFlags(ResourceStateSet allowedStates)
+{
+    int dstFlags = 0;
+    for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++)
     {
-        int dstFlags = 0;
-        for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++)
-        {
-            auto state = (ResourceState)i;
-            if (allowedStates.contains(state))
-                dstFlags |= calcResourceFlag(state);
-        }
-        return dstFlags;
+        auto state = (ResourceState)i;
+        if (allowedStates.contains(state))
+            dstFlags |= calcResourceFlag(state);
     }
+    return dstFlags;
+}
 
-    int _calcResourceAccessFlags(MemoryType memType)
+int _calcResourceAccessFlags(MemoryType memType)
+{
+    switch (memType)
     {
-        switch (memType)
-        {
-        case MemoryType::DeviceLocal:
-            return 0;
-        case MemoryType::ReadBack:
-            return D3D11_CPU_ACCESS_READ;
-        case MemoryType::Upload:
-            return D3D11_CPU_ACCESS_WRITE;
-        default:
-            assert(!"Invalid flags");
-            return 0;
-        }
+    case MemoryType::DeviceLocal: return 0;
+    case MemoryType::ReadBack:    return D3D11_CPU_ACCESS_READ;
+    case MemoryType::Upload:      return D3D11_CPU_ACCESS_WRITE;
+    default:                      assert(!"Invalid flags"); return 0;
     }
+}
 
-    D3D11_FILTER_TYPE translateFilterMode(TextureFilteringMode mode)
+D3D11_FILTER_TYPE translateFilterMode(TextureFilteringMode mode)
+{
+    switch (mode)
     {
-        switch (mode)
-        {
-        default:
-            return D3D11_FILTER_TYPE(0);
+    default: return D3D11_FILTER_TYPE(0);
 
 #define CASE(SRC, DST) \
     case TextureFilteringMode::SRC: return D3D11_FILTER_TYPE_##DST
 
-            CASE(Point, POINT);
-            CASE(Linear, LINEAR);
+        CASE(Point, POINT);
+        CASE(Linear, LINEAR);
 
 #undef CASE
-        }
     }
+}
 
-    D3D11_FILTER_REDUCTION_TYPE translateFilterReduction(TextureReductionOp op)
+D3D11_FILTER_REDUCTION_TYPE translateFilterReduction(TextureReductionOp op)
+{
+    switch (op)
     {
-        switch (op)
-        {
-        default:
-            return D3D11_FILTER_REDUCTION_TYPE(0);
+    default: return D3D11_FILTER_REDUCTION_TYPE(0);
 
 #define CASE(SRC, DST) \
     case TextureReductionOp::SRC: return D3D11_FILTER_REDUCTION_TYPE_##DST
 
-            CASE(Average, STANDARD);
-            CASE(Comparison, COMPARISON);
-            CASE(Minimum, MINIMUM);
-            CASE(Maximum, MAXIMUM);
+        CASE(Average, STANDARD);
+        CASE(Comparison, COMPARISON);
+        CASE(Minimum, MINIMUM);
+        CASE(Maximum, MAXIMUM);
 
 #undef CASE
-        }
     }
+}
 
-    D3D11_TEXTURE_ADDRESS_MODE translateAddressingMode(TextureAddressingMode mode)
+D3D11_TEXTURE_ADDRESS_MODE translateAddressingMode(TextureAddressingMode mode)
+{
+    switch (mode)
     {
-        switch (mode)
-        {
-        default:
-            return D3D11_TEXTURE_ADDRESS_MODE(0);
+    default: return D3D11_TEXTURE_ADDRESS_MODE(0);
 
 #define CASE(SRC, DST) \
     case TextureAddressingMode::SRC: return D3D11_TEXTURE_ADDRESS_##DST
 
-            CASE(Wrap, WRAP);
-            CASE(ClampToEdge, CLAMP);
-            CASE(ClampToBorder, BORDER);
-            CASE(MirrorRepeat, MIRROR);
-            CASE(MirrorOnce, MIRROR_ONCE);
+        CASE(Wrap, WRAP);
+        CASE(ClampToEdge, CLAMP);
+        CASE(ClampToBorder, BORDER);
+        CASE(MirrorRepeat, MIRROR);
+        CASE(MirrorOnce, MIRROR_ONCE);
 
 #undef CASE
-        }
     }
+}
 
-    D3D11_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func)
+D3D11_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func)
+{
+    switch (func)
     {
-        switch (func)
-        {
-        default:
-            // TODO: need to report failures
-            return D3D11_COMPARISON_ALWAYS;
+    default:
+        // TODO: need to report failures
+        return D3D11_COMPARISON_ALWAYS;
 
 #define CASE(FROM, TO) \
     case ComparisonFunc::FROM: return D3D11_COMPARISON_##TO
 
-            CASE(Never, NEVER);
-            CASE(Less, LESS);
-            CASE(Equal, EQUAL);
-            CASE(LessEqual, LESS_EQUAL);
-            CASE(Greater, GREATER);
-            CASE(NotEqual, NOT_EQUAL);
-            CASE(GreaterEqual, GREATER_EQUAL);
-            CASE(Always, ALWAYS);
+        CASE(Never, NEVER);
+        CASE(Less, LESS);
+        CASE(Equal, EQUAL);
+        CASE(LessEqual, LESS_EQUAL);
+        CASE(Greater, GREATER);
+        CASE(NotEqual, NOT_EQUAL);
+        CASE(GreaterEqual, GREATER_EQUAL);
+        CASE(Always, ALWAYS);
 #undef CASE
-        }
     }
+}
 
-    D3D11_STENCIL_OP translateStencilOp(StencilOp op)
+D3D11_STENCIL_OP translateStencilOp(StencilOp op)
+{
+    switch (op)
     {
-        switch (op)
-        {
-        default:
-            // TODO: need to report failures
-            return D3D11_STENCIL_OP_KEEP;
+    default:
+        // TODO: need to report failures
+        return D3D11_STENCIL_OP_KEEP;
 
 #define CASE(FROM, TO) \
     case StencilOp::FROM: return D3D11_STENCIL_OP_##TO
 
-            CASE(Keep, KEEP);
-            CASE(Zero, ZERO);
-            CASE(Replace, REPLACE);
-            CASE(IncrementSaturate, INCR_SAT);
-            CASE(DecrementSaturate, DECR_SAT);
-            CASE(Invert, INVERT);
-            CASE(IncrementWrap, INCR);
-            CASE(DecrementWrap, DECR);
+        CASE(Keep, KEEP);
+        CASE(Zero, ZERO);
+        CASE(Replace, REPLACE);
+        CASE(IncrementSaturate, INCR_SAT);
+        CASE(DecrementSaturate, DECR_SAT);
+        CASE(Invert, INVERT);
+        CASE(IncrementWrap, INCR);
+        CASE(DecrementWrap, DECR);
 #undef CASE
-
-        }
     }
+}
 
-    D3D11_FILL_MODE translateFillMode(FillMode mode)
+D3D11_FILL_MODE translateFillMode(FillMode mode)
+{
+    switch (mode)
     {
-        switch (mode)
-        {
-        default:
-            // TODO: need to report failures
-            return D3D11_FILL_SOLID;
+    default:
+        // TODO: need to report failures
+        return D3D11_FILL_SOLID;
 
-        case FillMode::Solid:       return D3D11_FILL_SOLID;
-        case FillMode::Wireframe:   return D3D11_FILL_WIREFRAME;
-        }
+    case FillMode::Solid:     return D3D11_FILL_SOLID;
+    case FillMode::Wireframe: return D3D11_FILL_WIREFRAME;
     }
+}
 
-    D3D11_CULL_MODE translateCullMode(CullMode mode)
+D3D11_CULL_MODE translateCullMode(CullMode mode)
+{
+    switch (mode)
     {
-        switch (mode)
-        {
-        default:
-            // TODO: need to report failures
-            return D3D11_CULL_NONE;
+    default:
+        // TODO: need to report failures
+        return D3D11_CULL_NONE;
 
-        case CullMode::None:    return D3D11_CULL_NONE;
-        case CullMode::Back:    return D3D11_CULL_BACK;
-        case CullMode::Front:   return D3D11_CULL_FRONT;
-        }
+    case CullMode::None:  return D3D11_CULL_NONE;
+    case CullMode::Back:  return D3D11_CULL_BACK;
+    case CullMode::Front: return D3D11_CULL_FRONT;
     }
+}
 
-    bool isBlendDisabled(AspectBlendDesc const& desc)
-    {
-        return desc.op == BlendOp::Add
-            && desc.srcFactor == BlendFactor::One
-            && desc.dstFactor == BlendFactor::Zero;
-    }
+bool isBlendDisabled(AspectBlendDesc const& desc)
+{
+    return desc.op == BlendOp::Add && desc.srcFactor == BlendFactor::One &&
+           desc.dstFactor == BlendFactor::Zero;
+}
 
 
-    bool isBlendDisabled(TargetBlendDesc const& desc)
-    {
-        return isBlendDisabled(desc.color)
-            && isBlendDisabled(desc.alpha);
-    }
+bool isBlendDisabled(TargetBlendDesc const& desc)
+{
+    return isBlendDisabled(desc.color) && isBlendDisabled(desc.alpha);
+}
 
-    D3D11_BLEND_OP translateBlendOp(BlendOp op)
+D3D11_BLEND_OP translateBlendOp(BlendOp op)
+{
+    switch (op)
     {
-        switch (op)
-        {
-        default:
-            assert(!"unimplemented");
-            return (D3D11_BLEND_OP)-1;
-
-#define CASE(FROM, TO) case BlendOp::FROM: return D3D11_BLEND_OP_##TO
-            CASE(Add, ADD);
-            CASE(Subtract, SUBTRACT);
-            CASE(ReverseSubtract, REV_SUBTRACT);
-            CASE(Min, MIN);
-            CASE(Max, MAX);
+    default: assert(!"unimplemented"); return (D3D11_BLEND_OP)-1;
+
+#define CASE(FROM, TO) \
+    case BlendOp::FROM: return D3D11_BLEND_OP_##TO
+        CASE(Add, ADD);
+        CASE(Subtract, SUBTRACT);
+        CASE(ReverseSubtract, REV_SUBTRACT);
+        CASE(Min, MIN);
+        CASE(Max, MAX);
 #undef CASE
-        }
     }
+}
 
-    D3D11_BLEND translateBlendFactor(BlendFactor factor)
+D3D11_BLEND translateBlendFactor(BlendFactor factor)
+{
+    switch (factor)
     {
-        switch (factor)
-        {
-        default:
-            assert(!"unimplemented");
-            return (D3D11_BLEND)-1;
-
-#define CASE(FROM, TO) case BlendFactor::FROM: return D3D11_BLEND_##TO
-            CASE(Zero, ZERO);
-            CASE(One, ONE);
-            CASE(SrcColor, SRC_COLOR);
-            CASE(InvSrcColor, INV_SRC_COLOR);
-            CASE(SrcAlpha, SRC_ALPHA);
-            CASE(InvSrcAlpha, INV_SRC_ALPHA);
-            CASE(DestAlpha, DEST_ALPHA);
-            CASE(InvDestAlpha, INV_DEST_ALPHA);
-            CASE(DestColor, DEST_COLOR);
-            CASE(InvDestColor, INV_DEST_ALPHA);
-            CASE(SrcAlphaSaturate, SRC_ALPHA_SAT);
-            CASE(BlendColor, BLEND_FACTOR);
-            CASE(InvBlendColor, INV_BLEND_FACTOR);
-            CASE(SecondarySrcColor, SRC1_COLOR);
-            CASE(InvSecondarySrcColor, INV_SRC1_COLOR);
-            CASE(SecondarySrcAlpha, SRC1_ALPHA);
-            CASE(InvSecondarySrcAlpha, INV_SRC1_ALPHA);
+    default: assert(!"unimplemented"); return (D3D11_BLEND)-1;
+
+#define CASE(FROM, TO) \
+    case BlendFactor::FROM: return D3D11_BLEND_##TO
+        CASE(Zero, ZERO);
+        CASE(One, ONE);
+        CASE(SrcColor, SRC_COLOR);
+        CASE(InvSrcColor, INV_SRC_COLOR);
+        CASE(SrcAlpha, SRC_ALPHA);
+        CASE(InvSrcAlpha, INV_SRC_ALPHA);
+        CASE(DestAlpha, DEST_ALPHA);
+        CASE(InvDestAlpha, INV_DEST_ALPHA);
+        CASE(DestColor, DEST_COLOR);
+        CASE(InvDestColor, INV_DEST_ALPHA);
+        CASE(SrcAlphaSaturate, SRC_ALPHA_SAT);
+        CASE(BlendColor, BLEND_FACTOR);
+        CASE(InvBlendColor, INV_BLEND_FACTOR);
+        CASE(SecondarySrcColor, SRC1_COLOR);
+        CASE(InvSecondarySrcColor, INV_SRC1_COLOR);
+        CASE(SecondarySrcAlpha, SRC1_ALPHA);
+        CASE(InvSecondarySrcAlpha, INV_SRC1_ALPHA);
 #undef CASE
-        }
     }
+}
 
-    D3D11_COLOR_WRITE_ENABLE translateRenderTargetWriteMask(RenderTargetWriteMaskT mask)
-    {
-        UINT result = 0;
-#define CASE(FROM, TO) if(mask & RenderTargetWriteMask::Enable##FROM) result |= D3D11_COLOR_WRITE_ENABLE_##TO
+D3D11_COLOR_WRITE_ENABLE translateRenderTargetWriteMask(RenderTargetWriteMaskT mask)
+{
+    UINT result = 0;
+#define CASE(FROM, TO)                              \
+    if (mask & RenderTargetWriteMask::Enable##FROM) \
+    result |= D3D11_COLOR_WRITE_ENABLE_##TO
 
-        CASE(Red, RED);
-        CASE(Green, GREEN);
-        CASE(Blue, BLUE);
-        CASE(Alpha, ALPHA);
+    CASE(Red, RED);
+    CASE(Green, GREEN);
+    CASE(Blue, BLUE);
+    CASE(Alpha, ALPHA);
 
 #undef CASE
-        return D3D11_COLOR_WRITE_ENABLE(result);
-    }
+    return D3D11_COLOR_WRITE_ENABLE(result);
+}
 
-    void initSrvDesc(IResource::Type resourceType, const ITextureResource::Desc& textureDesc, DXGI_FORMAT pixelFormat, D3D11_SHADER_RESOURCE_VIEW_DESC& descOut)
+void initSrvDesc(
+    IResource::Type resourceType,
+    const ITextureResource::Desc& textureDesc,
+    DXGI_FORMAT pixelFormat,
+    D3D11_SHADER_RESOURCE_VIEW_DESC& descOut)
+{
+    // create SRV
+    descOut = D3D11_SHADER_RESOURCE_VIEW_DESC();
+
+    descOut.Format =
+        (pixelFormat == DXGI_FORMAT_UNKNOWN)
+            ? D3DUtil::calcFormat(D3DUtil::USAGE_SRV, D3DUtil::getMapFormat(textureDesc.format))
+            : pixelFormat;
+    const int arraySize = calcEffectiveArraySize(textureDesc);
+    if (arraySize <= 1)
     {
-        // create SRV
-        descOut = D3D11_SHADER_RESOURCE_VIEW_DESC();
-
-        descOut.Format = (pixelFormat == DXGI_FORMAT_UNKNOWN) ? D3DUtil::calcFormat(D3DUtil::USAGE_SRV, D3DUtil::getMapFormat(textureDesc.format)) : pixelFormat;
-        const int arraySize = calcEffectiveArraySize(textureDesc);
-        if (arraySize <= 1)
+        switch (textureDesc.type)
         {
-            switch (textureDesc.type)
-            {
-            case IResource::Type::Texture1D:  descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D; break;
-            case IResource::Type::Texture2D:  descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; break;
-            case IResource::Type::Texture3D:  descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; break;
-            default: assert(!"Unknown dimension");
-            }
-
-            descOut.Texture2D.MipLevels = textureDesc.numMipLevels;
-            descOut.Texture2D.MostDetailedMip = 0;
+        case IResource::Type::Texture1D:
+            descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
+            break;
+        case IResource::Type::Texture2D:
+            descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+            break;
+        case IResource::Type::Texture3D:
+            descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
+            break;
+        default: assert(!"Unknown dimension");
         }
-        else if (resourceType == IResource::Type::TextureCube)
+
+        descOut.Texture2D.MipLevels = textureDesc.numMipLevels;
+        descOut.Texture2D.MostDetailedMip = 0;
+    }
+    else if (resourceType == IResource::Type::TextureCube)
+    {
+        if (textureDesc.arraySize > 1)
         {
-            if (textureDesc.arraySize > 1)
-            {
-                descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
-
-                descOut.TextureCubeArray.NumCubes = textureDesc.arraySize;
-                descOut.TextureCubeArray.First2DArrayFace = 0;
-                descOut.TextureCubeArray.MipLevels = textureDesc.numMipLevels;
-                descOut.TextureCubeArray.MostDetailedMip = 0;
-            }
-            else
-            {
-                descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
-
-                descOut.TextureCube.MipLevels = textureDesc.numMipLevels;
-                descOut.TextureCube.MostDetailedMip = 0;
-            }
+            descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
+
+            descOut.TextureCubeArray.NumCubes = textureDesc.arraySize;
+            descOut.TextureCubeArray.First2DArrayFace = 0;
+            descOut.TextureCubeArray.MipLevels = textureDesc.numMipLevels;
+            descOut.TextureCubeArray.MostDetailedMip = 0;
         }
         else
         {
-            assert(textureDesc.size.depth > 1 || arraySize > 1);
+            descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
 
-            switch (textureDesc.type)
-            {
-            case IResource::Type::Texture1D:  descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY; break;
-            case IResource::Type::Texture2D:  descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; break;
-            case IResource::Type::Texture3D:  descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; break;
-
-            default: assert(!"Unknown dimension");
-            }
+            descOut.TextureCube.MipLevels = textureDesc.numMipLevels;
+            descOut.TextureCube.MostDetailedMip = 0;
+        }
+    }
+    else
+    {
+        assert(textureDesc.size.depth > 1 || arraySize > 1);
 
-            descOut.Texture2DArray.ArraySize = std::max(textureDesc.size.depth, arraySize);
-            descOut.Texture2DArray.MostDetailedMip = 0;
-            descOut.Texture2DArray.MipLevels = textureDesc.numMipLevels;
-            descOut.Texture2DArray.FirstArraySlice = 0;
+        switch (textureDesc.type)
+        {
+        case IResource::Type::Texture1D:
+            descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY;
+            break;
+        case IResource::Type::Texture2D:
+            descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
+            break;
+        case IResource::Type::Texture3D:
+            descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
+            break;
+
+        default: assert(!"Unknown dimension");
         }
+
+        descOut.Texture2DArray.ArraySize = std::max(textureDesc.size.depth, arraySize);
+        descOut.Texture2DArray.MostDetailedMip = 0;
+        descOut.Texture2DArray.MipLevels = textureDesc.numMipLevels;
+        descOut.Texture2DArray.FirstArraySlice = 0;
     }
+}
 } // namespace d3d11
 
 Result SLANG_MCALL getD3D11Adapters(List<AdapterInfo>& outAdapters)
 {
     List<ComPtr<IDXGIAdapter>> dxgiAdapters;
-    SLANG_RETURN_ON_FAIL(D3DUtil::findAdapters(DeviceCheckFlag::UseHardwareDevice, nullptr, dxgiAdapters));
+    SLANG_RETURN_ON_FAIL(
+        D3DUtil::findAdapters(DeviceCheckFlag::UseHardwareDevice, nullptr, dxgiAdapters));
 
     outAdapters.clear();
     for (const auto& dxgiAdapter : dxgiAdapters)
@@ -357,7 +358,10 @@ Result SLANG_MCALL getD3D11Adapters(List<AdapterInfo>& outAdapters)
         dxgiAdapter->GetDesc(&desc);
         AdapterInfo info = {};
         auto name = String::fromWString(desc.Description);
-        memcpy(info.name, name.getBuffer(), Math::Min(name.getLength(), (Index)sizeof(AdapterInfo::name) - 1));
+        memcpy(
+            info.name,
+            name.getBuffer(),
+            Math::Min(name.getLength(), (Index)sizeof(AdapterInfo::name) - 1));
         info.vendorID = desc.VendorId;
         info.deviceID = desc.DeviceId;
         info.luid = D3DUtil::getAdapterLUID(dxgiAdapter);