format

* format

* Minor test fixes

* enable checking cpp format in ci

3 files changed, 486 insertions, 491 deletions

diff --git a/source/slang-wasm/slang-wasm-bindings.cpp b/source/slang-wasm/slang-wasm-bindings.cpp
index 56a472482..151211a67 100644
--- a/source/slang-wasm/slang-wasm-bindings.cpp
+++ b/source/slang-wasm/slang-wasm-bindings.cpp
@@ -1,6 +1,7 @@
+#include "slang-wasm.h"
+
 #include <emscripten/bind.h>
 #include <slang-com-ptr.h>
-#include "slang-wasm.h"
 
 using namespace emscripten;
 
@@ -13,9 +14,7 @@ EMSCRIPTEN_BINDINGS(slang)
         &slang::wgsl::createGlobalSession,
         return_value_policy::take_ownership());
 
-    function(
-        "getLastError",
-        &slang::wgsl::getLastError);
+    function("getLastError", &slang::wgsl::getLastError);
 
     function(
         "getCompileTargets",
@@ -39,22 +38,11 @@ EMSCRIPTEN_BINDINGS(slang)
             return_value_policy::take_ownership());
 
     class_<slang::wgsl::ComponentType>("ComponentType")
-        .function(
-            "link",
-            &slang::wgsl::ComponentType::link,
-            return_value_policy::take_ownership())
-        .function(
-            "getEntryPointCode",
-            &slang::wgsl::ComponentType::getEntryPointCode)
-        .function(
-            "getEntryPointCodeBlob",
-            &slang::wgsl::ComponentType::getEntryPointCodeBlob)
-        .function(
-            "getTargetCodeBlob",
-            &slang::wgsl::ComponentType::getTargetCodeBlob)
-        .function(
-            "getTargetCode",
-            &slang::wgsl::ComponentType::getTargetCode);
+        .function("link", &slang::wgsl::ComponentType::link, return_value_policy::take_ownership())
+        .function("getEntryPointCode", &slang::wgsl::ComponentType::getEntryPointCode)
+        .function("getEntryPointCodeBlob", &slang::wgsl::ComponentType::getEntryPointCodeBlob)
+        .function("getTargetCodeBlob", &slang::wgsl::ComponentType::getTargetCodeBlob)
+        .function("getTargetCode", &slang::wgsl::ComponentType::getTargetCode);
 
     class_<slang::wgsl::Module, base<slang::wgsl::ComponentType>>("Module")
         .function(
@@ -69,9 +57,7 @@ EMSCRIPTEN_BINDINGS(slang)
             "getDefinedEntryPoint",
             &slang::wgsl::Module::getDefinedEntryPoint,
             return_value_policy::take_ownership())
-        .function(
-            "getDefinedEntryPointCount",
-            &slang::wgsl::Module::getDefinedEntryPointCount);
+        .function("getDefinedEntryPointCount", &slang::wgsl::Module::getDefinedEntryPointCount);
 
     value_object<slang::wgsl::Error>("Error")
         .field("type", &slang::wgsl::Error::type)
@@ -79,10 +65,7 @@ EMSCRIPTEN_BINDINGS(slang)
         .field("message", &slang::wgsl::Error::message);
 
     class_<slang::wgsl::EntryPoint, base<slang::wgsl::ComponentType>>("EntryPoint")
-        .function(
-            "getName",
-            &slang::wgsl::EntryPoint::getName,
-            allow_raw_pointers());
+        .function("getName", &slang::wgsl::EntryPoint::getName, allow_raw_pointers());
 
     class_<slang::wgsl::CompileTargets>("CompileTargets")
         .function(
@@ -98,7 +81,7 @@ EMSCRIPTEN_BINDINGS(slang)
     value_object<slang::wgsl::lsp::Position>("Position")
         .field("line", &slang::wgsl::lsp::Position::line)
         .field("character", &slang::wgsl::lsp::Position::character);
-    
+
     value_object<slang::wgsl::lsp::Range>("Range")
         .field("start", &slang::wgsl::lsp::Range::start)
         .field("end", &slang::wgsl::lsp::Range::end);
@@ -141,7 +124,7 @@ EMSCRIPTEN_BINDINGS(slang)
     value_object<slang::wgsl::lsp::CompletionContext>("CompletionContext")
         .field("triggerKind", &slang::wgsl::lsp::CompletionContext::triggerKind)
         .field("triggerCharacter", &slang::wgsl::lsp::CompletionContext::triggerCharacter);
-    
+
     value_array<std::array<uint32_t, 2>>("array_uint_2")
         .element(emscripten::index<0>())
         .element(emscripten::index<1>());
@@ -172,7 +155,7 @@ EMSCRIPTEN_BINDINGS(slang)
         .field("range", &slang::wgsl::lsp::DocumentSymbol::range)
         .field("selectionRange", &slang::wgsl::lsp::DocumentSymbol::selectionRange)
         .field("children", &slang::wgsl::lsp::DocumentSymbol::children);
-    
+
     register_vector<slang::wgsl::lsp::DocumentSymbol>("DocumentSymbolList");
     register_optional<std::vector<slang::wgsl::lsp::DocumentSymbol>>();
 
@@ -200,18 +183,12 @@ EMSCRIPTEN_BINDINGS(slang)
             "didChangeTextDocument",
             &slang::wgsl::lsp::LanguageServer::didChangeTextDocument,
             allow_raw_pointers())
-        .function(
-            "hover",
-            &slang::wgsl::lsp::LanguageServer::hover,
-            allow_raw_pointers())
+        .function("hover", &slang::wgsl::lsp::LanguageServer::hover, allow_raw_pointers())
         .function(
             "gotoDefinition",
             &slang::wgsl::lsp::LanguageServer::gotoDefinition,
             allow_raw_pointers())
-        .function(
-            "completion",
-            &slang::wgsl::lsp::LanguageServer::completion,
-            allow_raw_pointers())
+        .function("completion", &slang::wgsl::lsp::LanguageServer::completion, allow_raw_pointers())
         .function(
             "completionResolve",
             &slang::wgsl::lsp::LanguageServer::completionResolve,
@@ -232,7 +209,7 @@ EMSCRIPTEN_BINDINGS(slang)
             "getDiagnostics",
             &slang::wgsl::lsp::LanguageServer::getDiagnostics,
             allow_raw_pointers());
-    
+
     function(
         "createLanguageServer",
         &slang::wgsl::lsp::createLanguageServer,
diff --git a/source/slang-wasm/slang-wasm.cpp b/source/slang-wasm/slang-wasm.cpp
index 8948c1075..50afde38b 100644
--- a/source/slang-wasm/slang-wasm.cpp
+++ b/source/slang-wasm/slang-wasm.cpp
@@ -1,12 +1,14 @@
-#include <vector>
-#include <string>
-#include <slang.h>
-#include <slang-com-ptr.h>
 #include "slang-wasm.h"
+
 #include "../core/slang-blob.h"
 #include "../core/slang-exception.h"
 #include "../slang/slang-language-server.h"
 
+#include <slang-com-ptr.h>
+#include <slang.h>
+#include <string>
+#include <vector>
+
 using namespace slang;
 
 namespace slang
@@ -47,7 +49,7 @@ GlobalSession* createGlobalSession()
 
 CompileTargets::CompileTargets()
 {
-#define MAKE_PAIR(x) { #x, SLANG_##x }
+#define MAKE_PAIR(x) {#x, SLANG_##x}
 
     m_compileTargetMap = {
         MAKE_PAIR(GLSL),
@@ -61,7 +63,7 @@ CompileTargets::CompileTargets()
 int CompileTargets::findCompileTarget(const std::string& name)
 {
     auto res = m_compileTargetMap.find(name);
-    if ( res != m_compileTargetMap.end())
+    if (res != m_compileTargetMap.end())
     {
         return res->second;
     }
@@ -94,22 +96,27 @@ Session* GlobalSession::createSession(int compileTarget)
     return new Session(session);
 }
 
-Module* Session::loadModuleFromSource(const std::string& slangCode, const std::string& name, const std::string& path)
+Module* Session::loadModuleFromSource(
+    const std::string& slangCode,
+    const std::string& name,
+    const std::string& path)
 {
     Slang::ComPtr<IModule> module;
     {
         Slang::ComPtr<slang::IBlob> diagnosticsBlob;
-        Slang::ComPtr<ISlangBlob> slangCodeBlob = Slang::RawBlob::create(
-            slangCode.c_str(), slangCode.size());
+        Slang::ComPtr<ISlangBlob> slangCodeBlob =
+            Slang::RawBlob::create(slangCode.c_str(), slangCode.size());
         module = m_interface->loadModuleFromSource(
-            name.c_str(), path.c_str(), slangCodeBlob, diagnosticsBlob.writeRef());
+            name.c_str(),
+            path.c_str(),
+            slangCodeBlob,
+            diagnosticsBlob.writeRef());
         if (!module)
         {
             g_error.type = std::string("USER");
             g_error.message = std::string(
                 (char*)diagnosticsBlob->getBufferPointer(),
-                (char*)diagnosticsBlob->getBufferPointer() +
-                diagnosticsBlob->getBufferSize());
+                (char*)diagnosticsBlob->getBufferPointer() + diagnosticsBlob->getBufferSize());
             return nullptr;
         }
     }
@@ -121,8 +128,8 @@ EntryPoint* Module::findEntryPointByName(const std::string& name)
 {
     Slang::ComPtr<IEntryPoint> entryPoint;
     {
-        SlangResult result = moduleInterface()->findEntryPointByName(
-            name.c_str(), entryPoint.writeRef());
+        SlangResult result =
+            moduleInterface()->findEntryPointByName(name.c_str(), entryPoint.writeRef());
         if (result != SLANG_OK)
         {
             g_error.type = std::string("USER");
@@ -141,7 +148,10 @@ EntryPoint* Module::findAndCheckEntryPoint(const std::string& name, int stage)
     {
         Slang::ComPtr<slang::IBlob> diagnosticsBlob;
         SlangResult result = moduleInterface()->findAndCheckEntryPoint(
-            name.c_str(), (SlangStage)stage, entryPoint.writeRef(), diagnosticsBlob.writeRef());
+            name.c_str(),
+            (SlangStage)stage,
+            entryPoint.writeRef(),
+            diagnosticsBlob.writeRef());
         if (!SLANG_SUCCEEDED(result))
         {
             g_error.type = std::string("USER");
@@ -191,8 +201,7 @@ EntryPoint* Module::getDefinedEntryPoint(int index)
 }
 
 
-ComponentType* Session::createCompositeComponentType(
-    const std::vector<ComponentType*>& components)
+ComponentType* Session::createCompositeComponentType(const std::vector<ComponentType*>& components)
 {
     Slang::ComPtr<IComponentType> composite;
     {
@@ -219,16 +228,14 @@ ComponentType* ComponentType::link()
     Slang::ComPtr<IComponentType> linkedProgram;
     {
         Slang::ComPtr<ISlangBlob> diagnosticBlob;
-        SlangResult result = interface()->link(
-            linkedProgram.writeRef(), diagnosticBlob.writeRef());
+        SlangResult result = interface()->link(linkedProgram.writeRef(), diagnosticBlob.writeRef());
         if (result != SLANG_OK)
         {
             g_error.type = std::string("USER");
             g_error.result = result;
             g_error.message = std::string(
                 (char*)diagnosticBlob->getBufferPointer(),
-                (char*)diagnosticBlob->getBufferPointer() +
-                diagnosticBlob->getBufferSize());
+                (char*)diagnosticBlob->getBufferPointer() + diagnosticBlob->getBufferSize());
             return nullptr;
         }
     }
@@ -252,8 +259,7 @@ std::string ComponentType::getEntryPointCode(int entryPointIndex, int targetInde
             g_error.result = result;
             g_error.message = std::string(
                 (char*)diagnosticBlob->getBufferPointer(),
-                (char*)diagnosticBlob->getBufferPointer() +
-                diagnosticBlob->getBufferSize());
+                (char*)diagnosticBlob->getBufferPointer() + diagnosticBlob->getBufferSize());
             return "";
         }
         std::string wgslCode = std::string(
@@ -282,14 +288,12 @@ emscripten::val ComponentType::getEntryPointCodeBlob(int entryPointIndex, int ta
         g_error.result = result;
         g_error.message = std::string(
             (char*)diagnosticBlob->getBufferPointer(),
-            (char*)diagnosticBlob->getBufferPointer() +
-            diagnosticBlob->getBufferSize());
+            (char*)diagnosticBlob->getBufferPointer() + diagnosticBlob->getBufferSize());
         return {};
     }
 
     const uint8_t* ptr = (uint8_t*)kernelBlob->getBufferPointer();
-    return emscripten::val(emscripten::typed_memory_view(kernelBlob->getBufferSize(),
-            ptr));
+    return emscripten::val(emscripten::typed_memory_view(kernelBlob->getBufferSize(), ptr));
 }
 
 std::string ComponentType::getTargetCode(int targetIndex)
@@ -307,8 +311,7 @@ std::string ComponentType::getTargetCode(int targetIndex)
             g_error.result = result;
             g_error.message = std::string(
                 (char*)diagnosticBlob->getBufferPointer(),
-                (char*)diagnosticBlob->getBufferPointer() +
-                diagnosticBlob->getBufferSize());
+                (char*)diagnosticBlob->getBufferPointer() + diagnosticBlob->getBufferSize());
             return "";
         }
         std::string targetCode = std::string(
@@ -326,334 +329,338 @@ emscripten::val ComponentType::getTargetCodeBlob(int targetIndex)
 {
     Slang::ComPtr<IBlob> kernelBlob;
     Slang::ComPtr<ISlangBlob> diagnosticBlob;
-    SlangResult result = interface()->getTargetCode(
-        targetIndex,
-        kernelBlob.writeRef(),
-        diagnosticBlob.writeRef());
+    SlangResult result =
+        interface()->getTargetCode(targetIndex, kernelBlob.writeRef(), diagnosticBlob.writeRef());
     if (result != SLANG_OK)
     {
         g_error.type = std::string("USER");
         g_error.result = result;
         g_error.message = std::string(
             (char*)diagnosticBlob->getBufferPointer(),
-            (char*)diagnosticBlob->getBufferPointer() +
-            diagnosticBlob->getBufferSize());
+            (char*)diagnosticBlob->getBufferPointer() + diagnosticBlob->getBufferSize());
         return {};
     }
 
     const uint8_t* ptr = (uint8_t*)kernelBlob->getBufferPointer();
-    return emscripten::val(emscripten::typed_memory_view(kernelBlob->getBufferSize(),
-            ptr));
+    return emscripten::val(emscripten::typed_memory_view(kernelBlob->getBufferSize(), ptr));
 }
 
 namespace lsp
 {
-    Position translate(Slang::LanguageServerProtocol::Position p)
-    {
-        Position result;
-        result.line = p.line;
-        result.character = p.character;
-        return result;
-    }
-    Range translate(Slang::LanguageServerProtocol::Range r)
-    {
-        Range result;
-        result.start = translate(r.start);
-        result.end = translate(r.end);
-        return result;
-    }
-    Location translate(Slang::LanguageServerProtocol::Location l)
-    {
-        Location result;
-        result.uri = l.uri.getBuffer();
-        result.range = translate(l.range);
-        return result;
-    }
-    Slang::LanguageServerProtocol::Position translate(Position p)
-    {
-        Slang::LanguageServerProtocol::Position result;
-        result.line = p.line;
-        result.character = p.character;
-        return result;
-    }
-    Slang::LanguageServerProtocol::Range translate(Range r)
-    {
-        Slang::LanguageServerProtocol::Range result;
-        result.start = translate(r.start);
-        result.end = translate(r.end);
-        return result;
-    }
-    Slang::LanguageServerProtocol::Location translate(Location l)
-    {
-        Slang::LanguageServerProtocol::Location result;
-        result.uri = l.uri.c_str();
-        result.range = translate(l.range);
-        return result;
-    }
+Position translate(Slang::LanguageServerProtocol::Position p)
+{
+    Position result;
+    result.line = p.line;
+    result.character = p.character;
+    return result;
+}
+Range translate(Slang::LanguageServerProtocol::Range r)
+{
+    Range result;
+    result.start = translate(r.start);
+    result.end = translate(r.end);
+    return result;
+}
+Location translate(Slang::LanguageServerProtocol::Location l)
+{
+    Location result;
+    result.uri = l.uri.getBuffer();
+    result.range = translate(l.range);
+    return result;
+}
+Slang::LanguageServerProtocol::Position translate(Position p)
+{
+    Slang::LanguageServerProtocol::Position result;
+    result.line = p.line;
+    result.character = p.character;
+    return result;
+}
+Slang::LanguageServerProtocol::Range translate(Range r)
+{
+    Slang::LanguageServerProtocol::Range result;
+    result.start = translate(r.start);
+    result.end = translate(r.end);
+    return result;
+}
+Slang::LanguageServerProtocol::Location translate(Location l)
+{
+    Slang::LanguageServerProtocol::Location result;
+    result.uri = l.uri.c_str();
+    result.range = translate(l.range);
+    return result;
+}
 
-    LanguageServer::LanguageServer()
-    {
-        Slang::LanguageServerStartupOptions options = {};
-        m_core = new Slang::LanguageServerCore(options);
-        init();
-    }
+LanguageServer::LanguageServer()
+{
+    Slang::LanguageServerStartupOptions options = {};
+    m_core = new Slang::LanguageServerCore(options);
+    init();
+}
 
-    LanguageServer::~LanguageServer()
-    {
-        delete m_core;
-    }
+LanguageServer::~LanguageServer()
+{
+    delete m_core;
+}
 
-    void LanguageServer::init()
-    {
-        Slang::LanguageServerProtocol::InitializeParams args = {};
-        Slang::LanguageServerProtocol::WorkspaceFolder folder = {};
-        folder.uri = "file:///";
-        folder.name = "/";
-        args.workspaceFolders.add(folder);
-        m_core->init(args);
-    }
+void LanguageServer::init()
+{
+    Slang::LanguageServerProtocol::InitializeParams args = {};
+    Slang::LanguageServerProtocol::WorkspaceFolder folder = {};
+    folder.uri = "file:///";
+    folder.name = "/";
+    args.workspaceFolders.add(folder);
+    m_core->init(args);
+}
 
-    void LanguageServer::didOpenTextDocument(std::string uri, std::string text)
-    {
-        Slang::LanguageServerProtocol::DidOpenTextDocumentParams args = {};
-        args.textDocument.uri = uri.c_str();
-        args.textDocument.languageId = "slang";
-        args.textDocument.text = text.c_str();
-        m_core->didOpenTextDocument(args);
-    }
-    
-    void LanguageServer::didCloseTextDocument(std::string uri)
-    {
-        Slang::LanguageServerProtocol::DidCloseTextDocumentParams args = {};
-        args.textDocument.uri = uri.c_str();
-        m_core->didCloseTextDocument(args);
-    }
-    
-    void LanguageServer::didChangeTextDocument(std::string uri, const std::vector<lsp::TextEdit>& changes)
-    {
-        Slang::LanguageServerProtocol::DidChangeTextDocumentParams args = {};
-        args.textDocument.uri = uri.c_str();
-        for (auto change : changes)
-        {
-            Slang::LanguageServerProtocol::TextDocumentContentChangeEvent lspChange;
-            lspChange.text = change.text.c_str();
-            lspChange.range = translate(change.range);
-            args.contentChanges.add(lspChange);
-        }
-        m_core->didChangeTextDocument(args);
-    }
-    
-    std::optional<lsp::Hover> LanguageServer::hover(std::string uri, lsp::Position position)
-    {
-        Slang::LanguageServerProtocol::HoverParams args = {};
-        args.textDocument.uri = uri.c_str();
-        args.position = translate(position);
-        auto coreResult = m_core->hover(args);
-        if (coreResult.isNull)
-            return std::nullopt;
-        lsp::Hover result;
-        result.contents.kind = coreResult.result.contents.kind.getBuffer();
-        result.contents.value = coreResult.result.contents.value.getBuffer();
-        result.range = translate(coreResult.result.range);
-        return result;
-    }
-    
-    std::optional<std::vector<lsp::Location>> LanguageServer::gotoDefinition(std::string uri, lsp::Position position)
-    {
-        Slang::LanguageServerProtocol::DefinitionParams args = {};
-        args.textDocument.uri = uri.c_str();
-        args.position = translate(position);
-        auto coreResult = m_core->gotoDefinition(args);
-        if (coreResult.isNull)
-            return std::nullopt;
-        std::vector<lsp::Location> result;
-        for (auto location : coreResult.result)
-            result.push_back(translate(location));
-        return result;
-    }
-    
-    std::optional<std::vector<lsp::CompletionItem>> LanguageServer::completion(
-        std::string uri, lsp::Position position, CompletionContext context)
+void LanguageServer::didOpenTextDocument(std::string uri, std::string text)
+{
+    Slang::LanguageServerProtocol::DidOpenTextDocumentParams args = {};
+    args.textDocument.uri = uri.c_str();
+    args.textDocument.languageId = "slang";
+    args.textDocument.text = text.c_str();
+    m_core->didOpenTextDocument(args);
+}
+
+void LanguageServer::didCloseTextDocument(std::string uri)
+{
+    Slang::LanguageServerProtocol::DidCloseTextDocumentParams args = {};
+    args.textDocument.uri = uri.c_str();
+    m_core->didCloseTextDocument(args);
+}
+
+void LanguageServer::didChangeTextDocument(
+    std::string uri,
+    const std::vector<lsp::TextEdit>& changes)
+{
+    Slang::LanguageServerProtocol::DidChangeTextDocumentParams args = {};
+    args.textDocument.uri = uri.c_str();
+    for (auto change : changes)
     {
-        Slang::LanguageServerProtocol::CompletionParams args = {};
-        args.textDocument.uri = uri.c_str();
-        args.position = translate(position);
-        args.context.triggerKind = context.triggerKind;
-        args.context.triggerCharacter = context.triggerCharacter.c_str();
-        auto coreResult = m_core->completion(args);
-        if (coreResult.isNull)
-            return std::nullopt;
-        std::vector<lsp::CompletionItem> result;
-        for (auto item : coreResult.result.items)
-        {
-            lsp::CompletionItem completionItem;
-            completionItem.label = item.label.getBuffer();
-            completionItem.kind = item.kind;
-            completionItem.detail = item.detail.getBuffer();
-            MarkupContent documentation;
-            documentation.kind = item.documentation.kind.getBuffer();
-            documentation.value = item.documentation.value.getBuffer();
-            completionItem.documentation = documentation;
-            completionItem.textEdit = std::nullopt;
-            completionItem.data = item.data.getBuffer();
-            std::vector<std::string> commitCharacters;
-            for (auto character : item.commitCharacters)
-                commitCharacters.push_back(character.getBuffer());
-            completionItem.commitCharacters = commitCharacters;
-            result.push_back(completionItem);
-        }
-        return result;
+        Slang::LanguageServerProtocol::TextDocumentContentChangeEvent lspChange;
+        lspChange.text = change.text.c_str();
+        lspChange.range = translate(change.range);
+        args.contentChanges.add(lspChange);
     }
-    
-    std::optional<lsp::CompletionItem> LanguageServer::completionResolve(lsp::CompletionItem args)
-    {
-        Slang::LanguageServerProtocol::CompletionItem coreArgs = {};
-        coreArgs.label = args.label.c_str();
-        coreArgs.kind = args.kind;
-        coreArgs.detail = args.detail.c_str();
-        if (args.documentation.has_value())
-        {
-            coreArgs.documentation.kind = args.documentation.value().kind.c_str();
-            coreArgs.documentation.value = args.documentation.value().value.c_str();
-        }
-        coreArgs.data = args.data.c_str();
-        if (args.commitCharacters.has_value())
-        {
-            for (auto character : args.commitCharacters.value())
-                coreArgs.commitCharacters.add(character.c_str());
-        }
-        Slang::LanguageServerProtocol::TextEditCompletionItem editItem;
-        editItem.label = coreArgs.label;
-        editItem.kind = coreArgs.kind;
-        editItem.detail = coreArgs.detail;
-        editItem.documentation.kind = coreArgs.documentation.kind;
-        editItem.documentation.value = coreArgs.documentation.value;
-        editItem.data = coreArgs.data;
-        for (auto character : coreArgs.commitCharacters)
-            editItem.commitCharacters.add(character);
-        auto coreResult = m_core->completionResolve(coreArgs, editItem);
-        if (coreResult.isNull)
-            return std::nullopt;
-        lsp::CompletionItem result;
-        result.label = coreResult.result.label.getBuffer();
-        result.kind = coreResult.result.kind;
-        result.detail = coreResult.result.detail.getBuffer();
+    m_core->didChangeTextDocument(args);
+}
+
+std::optional<lsp::Hover> LanguageServer::hover(std::string uri, lsp::Position position)
+{
+    Slang::LanguageServerProtocol::HoverParams args = {};
+    args.textDocument.uri = uri.c_str();
+    args.position = translate(position);
+    auto coreResult = m_core->hover(args);
+    if (coreResult.isNull)
+        return std::nullopt;
+    lsp::Hover result;
+    result.contents.kind = coreResult.result.contents.kind.getBuffer();
+    result.contents.value = coreResult.result.contents.value.getBuffer();
+    result.range = translate(coreResult.result.range);
+    return result;
+}
+
+std::optional<std::vector<lsp::Location>> LanguageServer::gotoDefinition(
+    std::string uri,
+    lsp::Position position)
+{
+    Slang::LanguageServerProtocol::DefinitionParams args = {};
+    args.textDocument.uri = uri.c_str();
+    args.position = translate(position);
+    auto coreResult = m_core->gotoDefinition(args);
+    if (coreResult.isNull)
+        return std::nullopt;
+    std::vector<lsp::Location> result;
+    for (auto location : coreResult.result)
+        result.push_back(translate(location));
+    return result;
+}
+
+std::optional<std::vector<lsp::CompletionItem>> LanguageServer::completion(
+    std::string uri,
+    lsp::Position position,
+    CompletionContext context)
+{
+    Slang::LanguageServerProtocol::CompletionParams args = {};
+    args.textDocument.uri = uri.c_str();
+    args.position = translate(position);
+    args.context.triggerKind = context.triggerKind;
+    args.context.triggerCharacter = context.triggerCharacter.c_str();
+    auto coreResult = m_core->completion(args);
+    if (coreResult.isNull)
+        return std::nullopt;
+    std::vector<lsp::CompletionItem> result;
+    for (auto item : coreResult.result.items)
+    {
+        lsp::CompletionItem completionItem;
+        completionItem.label = item.label.getBuffer();
+        completionItem.kind = item.kind;
+        completionItem.detail = item.detail.getBuffer();
         MarkupContent documentation;
-        documentation.kind = coreResult.result.documentation.kind.getBuffer();
-        documentation.value = coreResult.result.documentation.value.getBuffer();
-        result.documentation = documentation;
-        result.textEdit = std::nullopt;
-        result.data = coreResult.result.data.getBuffer();
+        documentation.kind = item.documentation.kind.getBuffer();
+        documentation.value = item.documentation.value.getBuffer();
+        completionItem.documentation = documentation;
+        completionItem.textEdit = std::nullopt;
+        completionItem.data = item.data.getBuffer();
         std::vector<std::string> commitCharacters;
-        for (auto character : coreResult.result.commitCharacters)
+        for (auto character : item.commitCharacters)
             commitCharacters.push_back(character.getBuffer());
-        result.commitCharacters = commitCharacters;
-        return result;
-    }
-    
-    std::optional<std::vector<uint32_t>> LanguageServer::semanticTokens(std::string uri)
-    {
-        Slang::LanguageServerProtocol::SemanticTokensParams args = {};
-        args.textDocument.uri = uri.c_str();
-        auto coreResult = m_core->semanticTokens(args);
-        if (coreResult.isNull)
-            return std::nullopt;
-        std::vector<uint32_t> result;
-        result.reserve((size_t)coreResult.result.data.getCount());
-        for (auto token : coreResult.result.data)
-            result.push_back(token);
-        return result;
-    }
-    
-    std::optional<lsp::SignatureHelp> LanguageServer::signatureHelp(std::string uri, lsp::Position position)
-    {
-        Slang::LanguageServerProtocol::SignatureHelpParams args = {};
-        args.textDocument.uri = uri.c_str();
-        args.position = translate(position);
-        auto coreResult = m_core->signatureHelp(args);
-        if (coreResult.isNull)
-            return std::nullopt;
-        lsp::SignatureHelp result;
-        for (auto signature : coreResult.result.signatures)
-        {
-            lsp::SignatureInformation signatureInfo;
-            signatureInfo.label = signature.label.getBuffer();
-            signatureInfo.documentation.kind = signature.documentation.kind.getBuffer();
-            signatureInfo.documentation.value = signature.documentation.value.getBuffer();
-            for (auto parameter : signature.parameters)
-            {
-                lsp::ParameterInformation parameterInfo;
-                parameterInfo.label[0] = parameter.label[0];
-                parameterInfo.label[1] = parameter.label[1];
-                parameterInfo.documentation.kind = parameter.documentation.kind.getBuffer();
-                parameterInfo.documentation.value = parameter.documentation.value.getBuffer();
-                signatureInfo.parameters.push_back(parameterInfo);
-            }
-            result.signatures.push_back(signatureInfo);
-        }
-        result.activeSignature = coreResult.result.activeSignature;
-        result.activeParameter = coreResult.result.activeParameter;
-        return result;
-    }
-    
-    lsp::DocumentSymbol translate(Slang::LanguageServerProtocol::DocumentSymbol symbol)
-    {
-        lsp::DocumentSymbol result;
-        result.name = symbol.name.getBuffer();
-        result.detail = symbol.detail.getBuffer();
-        result.kind = symbol.kind;
-        result.range = translate(symbol.range);
-        result.selectionRange = translate(symbol.selectionRange);
-        for (auto child : symbol.children)
-            result.children.push_back(translate(child));
-        return result;
+        completionItem.commitCharacters = commitCharacters;
+        result.push_back(completionItem);
     }
+    return result;
+}
 
-    std::optional<std::vector<lsp::DocumentSymbol>> LanguageServer::documentSymbol(std::string uri)
-    {
-        Slang::LanguageServerProtocol::DocumentSymbolParams args = {};
-        args.textDocument.uri = uri.c_str();
-        auto coreResult = m_core->documentSymbol(args);
-        if (coreResult.isNull)
-            return std::nullopt;
-        std::vector<lsp::DocumentSymbol> result;
-        for (auto symbol : coreResult.result)
+std::optional<lsp::CompletionItem> LanguageServer::completionResolve(lsp::CompletionItem args)
+{
+    Slang::LanguageServerProtocol::CompletionItem coreArgs = {};
+    coreArgs.label = args.label.c_str();
+    coreArgs.kind = args.kind;
+    coreArgs.detail = args.detail.c_str();
+    if (args.documentation.has_value())
+    {
+        coreArgs.documentation.kind = args.documentation.value().kind.c_str();
+        coreArgs.documentation.value = args.documentation.value().value.c_str();
+    }
+    coreArgs.data = args.data.c_str();
+    if (args.commitCharacters.has_value())
+    {
+        for (auto character : args.commitCharacters.value())
+            coreArgs.commitCharacters.add(character.c_str());
+    }
+    Slang::LanguageServerProtocol::TextEditCompletionItem editItem;
+    editItem.label = coreArgs.label;
+    editItem.kind = coreArgs.kind;
+    editItem.detail = coreArgs.detail;
+    editItem.documentation.kind = coreArgs.documentation.kind;
+    editItem.documentation.value = coreArgs.documentation.value;
+    editItem.data = coreArgs.data;
+    for (auto character : coreArgs.commitCharacters)
+        editItem.commitCharacters.add(character);
+    auto coreResult = m_core->completionResolve(coreArgs, editItem);
+    if (coreResult.isNull)
+        return std::nullopt;
+    lsp::CompletionItem result;
+    result.label = coreResult.result.label.getBuffer();
+    result.kind = coreResult.result.kind;
+    result.detail = coreResult.result.detail.getBuffer();
+    MarkupContent documentation;
+    documentation.kind = coreResult.result.documentation.kind.getBuffer();
+    documentation.value = coreResult.result.documentation.value.getBuffer();
+    result.documentation = documentation;
+    result.textEdit = std::nullopt;
+    result.data = coreResult.result.data.getBuffer();
+    std::vector<std::string> commitCharacters;
+    for (auto character : coreResult.result.commitCharacters)
+        commitCharacters.push_back(character.getBuffer());
+    result.commitCharacters = commitCharacters;
+    return result;
+}
+
+std::optional<std::vector<uint32_t>> LanguageServer::semanticTokens(std::string uri)
+{
+    Slang::LanguageServerProtocol::SemanticTokensParams args = {};
+    args.textDocument.uri = uri.c_str();
+    auto coreResult = m_core->semanticTokens(args);
+    if (coreResult.isNull)
+        return std::nullopt;
+    std::vector<uint32_t> result;
+    result.reserve((size_t)coreResult.result.data.getCount());
+    for (auto token : coreResult.result.data)
+        result.push_back(token);
+    return result;
+}
+
+std::optional<lsp::SignatureHelp> LanguageServer::signatureHelp(
+    std::string uri,
+    lsp::Position position)
+{
+    Slang::LanguageServerProtocol::SignatureHelpParams args = {};
+    args.textDocument.uri = uri.c_str();
+    args.position = translate(position);
+    auto coreResult = m_core->signatureHelp(args);
+    if (coreResult.isNull)
+        return std::nullopt;
+    lsp::SignatureHelp result;
+    for (auto signature : coreResult.result.signatures)
+    {
+        lsp::SignatureInformation signatureInfo;
+        signatureInfo.label = signature.label.getBuffer();
+        signatureInfo.documentation.kind = signature.documentation.kind.getBuffer();
+        signatureInfo.documentation.value = signature.documentation.value.getBuffer();
+        for (auto parameter : signature.parameters)
         {
-            auto documentSymbol = translate(symbol);
-            result.push_back(documentSymbol);
+            lsp::ParameterInformation parameterInfo;
+            parameterInfo.label[0] = parameter.label[0];
+            parameterInfo.label[1] = parameter.label[1];
+            parameterInfo.documentation.kind = parameter.documentation.kind.getBuffer();
+            parameterInfo.documentation.value = parameter.documentation.value.getBuffer();
+            signatureInfo.parameters.push_back(parameterInfo);
         }
-        return result;
+        result.signatures.push_back(signatureInfo);
     }
+    result.activeSignature = coreResult.result.activeSignature;
+    result.activeParameter = coreResult.result.activeParameter;
+    return result;
+}
 
-    std::optional<std::vector<lsp::Diagnostics>> LanguageServer::getDiagnostics(std::string uri)
-    {
-        std::vector<lsp::Diagnostics> result;
-        auto module = m_core->m_workspace->getCurrentVersion()->getOrLoadModule(
-            Slang::URI::fromString(Slang::UnownedStringSlice(uri.c_str())).getPath());
-        if (!module)
-            return std::nullopt;
-        for (auto& docDiag: m_core->m_workspace->getCurrentVersion()->diagnostics)
+lsp::DocumentSymbol translate(Slang::LanguageServerProtocol::DocumentSymbol symbol)
+{
+    lsp::DocumentSymbol result;
+    result.name = symbol.name.getBuffer();
+    result.detail = symbol.detail.getBuffer();
+    result.kind = symbol.kind;
+    result.range = translate(symbol.range);
+    result.selectionRange = translate(symbol.selectionRange);
+    for (auto child : symbol.children)
+        result.children.push_back(translate(child));
+    return result;
+}
+
+std::optional<std::vector<lsp::DocumentSymbol>> LanguageServer::documentSymbol(std::string uri)
+{
+    Slang::LanguageServerProtocol::DocumentSymbolParams args = {};
+    args.textDocument.uri = uri.c_str();
+    auto coreResult = m_core->documentSymbol(args);
+    if (coreResult.isNull)
+        return std::nullopt;
+    std::vector<lsp::DocumentSymbol> result;
+    for (auto symbol : coreResult.result)
+    {
+        auto documentSymbol = translate(symbol);
+        result.push_back(documentSymbol);
+    }
+    return result;
+}
+
+std::optional<std::vector<lsp::Diagnostics>> LanguageServer::getDiagnostics(std::string uri)
+{
+    std::vector<lsp::Diagnostics> result;
+    auto module = m_core->m_workspace->getCurrentVersion()->getOrLoadModule(
+        Slang::URI::fromString(Slang::UnownedStringSlice(uri.c_str())).getPath());
+    if (!module)
+        return std::nullopt;
+    for (auto& docDiag : m_core->m_workspace->getCurrentVersion()->diagnostics)
+    {
+        for (auto& message : docDiag.second.messages)
         {
-            for (auto& message: docDiag.second.messages)
-            {
-                lsp::Diagnostics diag;
-                diag.code = Slang::String(message.code).getBuffer();
-                diag.range = translate(message.range);
-                diag.severity = (int)message.severity;
-                diag.message = message.message.getBuffer();
-                result.push_back(diag);
-            }
+            lsp::Diagnostics diag;
+            diag.code = Slang::String(message.code).getBuffer();
+            diag.range = translate(message.range);
+            diag.severity = (int)message.severity;
+            diag.message = message.message.getBuffer();
+            result.push_back(diag);
         }
-        return result;
     }
+    return result;
+}
 
 
-    LanguageServer* createLanguageServer()
-    {
-        return new LanguageServer();
-    }
-    
+LanguageServer* createLanguageServer()
+{
+    return new LanguageServer();
 }
 
+} // namespace lsp
+
 } // namespace wgsl
 } // namespace slang
diff --git a/source/slang-wasm/slang-wasm.h b/source/slang-wasm/slang-wasm.h
index eb302119b..675540ede 100644
--- a/source/slang-wasm/slang-wasm.h
+++ b/source/slang-wasm/slang-wasm.h
@@ -1,12 +1,12 @@
 #pragma once
 
+#include <emscripten/val.h>
 #include <slang.h>
 #include <unordered_map>
-#include <emscripten/val.h>
 
 namespace Slang
 {
-    class LanguageServerCore;
+class LanguageServerCore;
 }
 
 namespace slang
@@ -32,6 +32,7 @@ class CompileTargets
 public:
     CompileTargets();
     int findCompileTarget(const std::string& name);
+
 private:
     std::unordered_map<std::string, SlangCompileTarget> m_compileTargetMap;
 };
@@ -41,9 +42,10 @@ CompileTargets* getCompileTargets();
 class ComponentType
 {
 public:
-
-    ComponentType(slang::IComponentType* interface) :
-        m_interface(interface) {}
+    ComponentType(slang::IComponentType* interface)
+        : m_interface(interface)
+    {
+    }
 
     ComponentType* link();
 
@@ -52,26 +54,29 @@ public:
     std::string getTargetCode(int targetIndex);
     emscripten::val getTargetCodeBlob(int targetIndex);
 
-    slang::IComponentType* interface() const {return m_interface;}
+    slang::IComponentType* interface() const { return m_interface; }
 
     virtual ~ComponentType() = default;
 
 private:
-
     Slang::ComPtr<slang::IComponentType> m_interface;
 };
 
 class EntryPoint : public ComponentType
 {
 public:
-    EntryPoint(slang::IEntryPoint* interface) : ComponentType(interface) {}
+    EntryPoint(slang::IEntryPoint* interface)
+        : ComponentType(interface)
+    {
+    }
     std::string getName() const
     {
         return entryPointInterface()->getFunctionReflection()->getName();
     }
-private:
 
-    slang::IEntryPoint* entryPointInterface() const {
+private:
+    slang::IEntryPoint* entryPointInterface() const
+    {
         return static_cast<slang::IEntryPoint*>(interface());
     }
 };
@@ -79,52 +84,53 @@ private:
 class Module : public ComponentType
 {
 public:
-
-    Module(slang::IModule* interface) : ComponentType(interface) {}
+    Module(slang::IModule* interface)
+        : ComponentType(interface)
+    {
+    }
 
     EntryPoint* findEntryPointByName(const std::string& name);
     EntryPoint* findAndCheckEntryPoint(const std::string& name, int stage);
     EntryPoint* getDefinedEntryPoint(int index);
     int getDefinedEntryPointCount();
 
-    slang::IModule* moduleInterface() const {
-        return static_cast<slang::IModule*>(interface());
-    }
+    slang::IModule* moduleInterface() const { return static_cast<slang::IModule*>(interface()); }
 };
 
 class Session
 {
 public:
-
     Session(slang::ISession* interface)
-        : m_interface(interface) {}
+        : m_interface(interface)
+    {
+    }
 
     Module* loadModuleFromSource(
-        const std::string& slangCode, const std::string& name, const std::string& path);
+        const std::string& slangCode,
+        const std::string& name,
+        const std::string& path);
 
-    ComponentType* createCompositeComponentType(
-        const std::vector<ComponentType*>& components);
+    ComponentType* createCompositeComponentType(const std::vector<ComponentType*>& components);
 
-    slang::ISession* interface() const {return m_interface;}
+    slang::ISession* interface() const { return m_interface; }
 
 private:
-
     Slang::ComPtr<slang::ISession> m_interface;
 };
 
 class GlobalSession
 {
 public:
-
     GlobalSession(slang::IGlobalSession* interface)
-        : m_interface(interface) {}
+        : m_interface(interface)
+    {
+    }
 
     Session* createSession(int compileTarget);
 
-    slang::IGlobalSession* interface() const {return m_interface;}
+    slang::IGlobalSession* interface() const { return m_interface; }
 
 private:
-
     Slang::ComPtr<slang::IGlobalSession> m_interface;
 };
 
@@ -132,121 +138,126 @@ GlobalSession* createGlobalSession();
 
 namespace lsp
 {
-    struct Position
-    {
-        int line = -1;
-        int character = -1;
-    };
+struct Position
+{
+    int line = -1;
+    int character = -1;
+};
 
-    struct Range
-    {
-        Position start;
-        Position end;
-    };
+struct Range
+{
+    Position start;
+    Position end;
+};
 
-    struct Location
-    {
-        std::string uri;
-        Range range;
-    };
+struct Location
+{
+    std::string uri;
+    Range range;
+};
 
-    struct TextEdit
-    {
-        Range range;
-        std::string text;
-    };
+struct TextEdit
+{
+    Range range;
+    std::string text;
+};
 
-    struct MarkupContent
-    {
-        std::string kind;
-        std::string value;
-    };
+struct MarkupContent
+{
+    std::string kind;
+    std::string value;
+};
 
-    struct Hover
-    {
-        MarkupContent contents;
-        Range range;
-    };
+struct Hover
+{
+    MarkupContent contents;
+    Range range;
+};
 
-    struct CompletionItem
-    {
-        std::string label;
-        int kind;
-        std::string detail;
-        std::string data;
-        std::optional<MarkupContent> documentation;
-        std::optional<TextEdit> textEdit;
-        std::optional<std::vector<std::string>> commitCharacters;
-    };
-
-    struct CompletionContext
-    {
-        int triggerKind = 1;
-        std::string triggerCharacter;
-    };
+struct CompletionItem
+{
+    std::string label;
+    int kind;
+    std::string detail;
+    std::string data;
+    std::optional<MarkupContent> documentation;
+    std::optional<TextEdit> textEdit;
+    std::optional<std::vector<std::string>> commitCharacters;
+};
 
-    struct ParameterInformation
-    {
-        uint32_t label[2] = { 0, 0 };
-        MarkupContent documentation;
-    };
+struct CompletionContext
+{
+    int triggerKind = 1;
+    std::string triggerCharacter;
+};
 
-    struct SignatureInformation
-    {
-        std::string label;
-        MarkupContent documentation;
-        std::vector<ParameterInformation> parameters;
-    };
+struct ParameterInformation
+{
+    uint32_t label[2] = {0, 0};
+    MarkupContent documentation;
+};
 
-    struct SignatureHelp
-    {
-        std::vector<SignatureInformation> signatures;
-        uint32_t activeSignature = 0;
-        uint32_t activeParameter = 0;
-    };
+struct SignatureInformation
+{
+    std::string label;
+    MarkupContent documentation;
+    std::vector<ParameterInformation> parameters;
+};
 
-    struct DocumentSymbol
-    {
-        std::string name;
-        std::string detail;
-        int kind = 0;
-        Range range;
-        Range selectionRange;
-        std::vector<DocumentSymbol> children;
-    };
-
-    struct Diagnostics
-    {
-        std::string code;
-        Range range;
-        std::string message;
-        int severity;
-    };
+struct SignatureHelp
+{
+    std::vector<SignatureInformation> signatures;
+    uint32_t activeSignature = 0;
+    uint32_t activeParameter = 0;
+};
 
-    class LanguageServer
-    {
-    private:
-        Slang::LanguageServerCore* m_core = nullptr;
-        void init();
-    public:
-        LanguageServer();
-        ~LanguageServer();
-        void didOpenTextDocument(std::string uri, std::string text);
-        void didCloseTextDocument(std::string uri);
-        void didChangeTextDocument(std::string uri, const std::vector<lsp::TextEdit>& changes);
-        std::optional<lsp::Hover> hover(std::string uri, lsp::Position position);
-        std::optional<std::vector<lsp::Location>> gotoDefinition(std::string uri, lsp::Position position);
-        std::optional<std::vector<lsp::CompletionItem>> completion(
-            std::string uri, lsp::Position position, CompletionContext context);
-        std::optional<lsp::CompletionItem> completionResolve(lsp::CompletionItem args);
-        std::optional<std::vector<uint32_t>> semanticTokens(std::string uri);
-        std::optional<lsp::SignatureHelp> signatureHelp(std::string uri, lsp::Position position);
-        std::optional<std::vector<lsp::DocumentSymbol>> documentSymbol(std::string uri);
-        std::optional<std::vector<lsp::Diagnostics>> getDiagnostics(std::string uri);
-    };
-
-    LanguageServer* createLanguageServer();
-}
+struct DocumentSymbol
+{
+    std::string name;
+    std::string detail;
+    int kind = 0;
+    Range range;
+    Range selectionRange;
+    std::vector<DocumentSymbol> children;
+};
+
+struct Diagnostics
+{
+    std::string code;
+    Range range;
+    std::string message;
+    int severity;
+};
+
+class LanguageServer
+{
+private:
+    Slang::LanguageServerCore* m_core = nullptr;
+    void init();
+
+public:
+    LanguageServer();
+    ~LanguageServer();
+    void didOpenTextDocument(std::string uri, std::string text);
+    void didCloseTextDocument(std::string uri);
+    void didChangeTextDocument(std::string uri, const std::vector<lsp::TextEdit>& changes);
+    std::optional<lsp::Hover> hover(std::string uri, lsp::Position position);
+    std::optional<std::vector<lsp::Location>> gotoDefinition(
+        std::string uri,
+        lsp::Position position);
+    std::optional<std::vector<lsp::CompletionItem>> completion(
+        std::string uri,
+        lsp::Position position,
+        CompletionContext context);
+    std::optional<lsp::CompletionItem> completionResolve(lsp::CompletionItem args);
+    std::optional<std::vector<uint32_t>> semanticTokens(std::string uri);
+    std::optional<lsp::SignatureHelp> signatureHelp(std::string uri, lsp::Position position);
+    std::optional<std::vector<lsp::DocumentSymbol>> documentSymbol(std::string uri);
+    std::optional<std::vector<lsp::Diagnostics>> getDiagnostics(std::string uri);
+};
+
+LanguageServer* createLanguageServer();
+} // namespace lsp
 
 } // namespace wgsl
 } // namespace slang