clang fmt github action (#13724)

.github/workflows/run-format.yml

@@ -21,14 +21,15 @@ jobs:
           sparse-checkout: |
             .prettierrc-ci
             .github
+            .vscode
             src
             scripts
             packages
             test
             bench
             package.json
             bun.lockb
-            .vscode
+            .clang-format
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
@@ -46,6 +47,9 @@ jobs:
       - name: Format Zig
         run: |
           bun fmt:zig
+      - name: Format Cpp
+        run: |
+          bun fmt:cpp
       - name: Commit
         uses: stefanzweifel/git-auto-commit-action@v5
         with:

.vscode/settings.json

@@ -61,6 +61,7 @@
   "[h]": {
     "editor.defaultFormatter": "xaver.clang-format",
   },
+  "clangd.arguments": ["-header-insertion=never"],
 
   // JavaScript
   "prettier.enable": true,

package.json

@@ -42,6 +42,7 @@
     "typecheck": "tsc --noEmit && cd test && bun run typecheck",
     "fmt": "prettier --config=.prettierrc-ci --write --cache './{.vscode,src,test,bench,packages/{bun-types,bun-inspector-*,bun-vscode,bun-debug-adapter-protocol}}/**/*.{mjs,ts,tsx,js,jsx}'",
     "fmt:zig": "zig fmt src/*.zig src/*/*.zig src/*/*/*.zig src/*/*/*/*.zig",
+    "fmt:cpp": "clang-format -i src/bun.js/bindings/**/*.{cpp,h} --verbose",
     "lint": "eslint './**/*.d.ts' --cache",
     "lint:fix": "eslint './**/*.d.ts' --cache --fix",
     "test": "node scripts/runner.node.mjs ./build/bun-debug",

src/bun.js/bindings/.clang-format-ignore

@@ -0,0 +1,2 @@
+*.lut.h
+sqlite/sqlite3_local.h

src/bun.js/bindings/webcore/CallbackResult.h

@@ -58,7 +58,6 @@ template<> class CallbackResult<void> {
     CallbackResultType m_type = CallbackResultType::Success;
 };
 
-
 template<typename ReturnType> inline CallbackResult<ReturnType>::CallbackResult(CallbackResultType type)
     : m_value(makeUnexpected(type))
 {
@@ -80,7 +79,6 @@ template<typename ReturnType> inline auto CallbackResult<ReturnType>::releaseRet
     return WTFMove(m_value.value());
 }
 
-
 // Void specialization
 
 inline CallbackResult<void>::CallbackResult(CallbackResultType type)

src/bun.js/bindings/webcore/CommonAtomStrings.cpp

@@ -28,12 +28,14 @@
 
 namespace WebCore {
 
+// clang-format off
 #define DEFINE_COMMON_ATOM(atomName, atomValue) \
     MainThreadLazyNeverDestroyed<const AtomString> atomName ## AtomData;
 #define INITIALIZE_COMMON_ATOM(atomName, atomValue) \
     atomName ## AtomData.constructWithoutAccessCheck(atomValue ## _s);
 
 WEBCORE_COMMON_ATOM_STRINGS_FOR_EACH_KEYWORD(DEFINE_COMMON_ATOM)
+// clang-format on
 
 void initializeCommonAtomStrings()
 {

src/bun.js/bindings/webcore/CommonAtomStrings.h

@@ -30,6 +30,7 @@
 
 namespace WebCore {
 
+// clang-format off
 #define WEBCORE_COMMON_ATOM_STRINGS_FOR_EACH_KEYWORD(macro) \
     macro(alternative, "alternative") \
     macro(auto, "auto") \
@@ -66,6 +67,7 @@ namespace WebCore {
 WEBCORE_COMMON_ATOM_STRINGS_FOR_EACH_KEYWORD(DECLARE_COMMON_ATOM)
 
 #undef DECLARE_COMMON_ATOM
+// clang-format on
 
 WEBCORE_EXPORT void initializeCommonAtomStrings();
 

src/bun.js/bindings/webcore/DOMJITIDLConvert.h

@@ -27,7 +27,8 @@
 
 #include "IDLTypes.h"
 
-namespace WebCore { namespace DOMJIT {
+namespace WebCore {
+namespace DOMJIT {
 
 template<typename IDLType>
 struct DirectConverter;
@@ -56,4 +57,5 @@ struct DirectConverter<IDLRequiresExistingAtomStringAdaptor<IDLDOMString>> {
     }
 };
 
-} }
+}
+}

src/bun.js/bindings/webcore/DOMJITIDLTypeFilter.h

@@ -28,53 +28,116 @@
 #include "IDLTypes.h"
 #include <JavaScriptCore/SpeculatedType.h>
 
-namespace WebCore { namespace DOMJIT {
+namespace WebCore {
+namespace DOMJIT {
 
 template<typename IDLType>
 struct IDLArgumentTypeFilter;
 
-template<> struct IDLArgumentTypeFilter<IDLBoolean> { static const constexpr JSC::SpeculatedType value = JSC::SpecBoolean; };
-template<> struct IDLArgumentTypeFilter<IDLByte> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLArgumentTypeFilter<IDLOctet> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLArgumentTypeFilter<IDLShort> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLArgumentTypeFilter<IDLUnsignedShort> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLArgumentTypeFilter<IDLLong> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLArgumentTypeFilter<IDLDOMString> { static const constexpr JSC::SpeculatedType value = JSC::SpecString; };
-template<> struct IDLArgumentTypeFilter<IDLAtomStringAdaptor<IDLDOMString>> { static const constexpr JSC::SpeculatedType value = JSC::SpecString; };
-template<> struct IDLArgumentTypeFilter<IDLRequiresExistingAtomStringAdaptor<IDLDOMString>> { static const constexpr JSC::SpeculatedType value = JSC::SpecString; };
-template<> struct IDLArgumentTypeFilter<IDLUint8Array> { static const constexpr JSC::SpeculatedType value = JSC::SpecUint8Array; };
+template<> struct IDLArgumentTypeFilter<IDLBoolean> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBoolean;
+};
+template<> struct IDLArgumentTypeFilter<IDLByte> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLArgumentTypeFilter<IDLOctet> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLArgumentTypeFilter<IDLShort> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLArgumentTypeFilter<IDLUnsignedShort> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLArgumentTypeFilter<IDLLong> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLArgumentTypeFilter<IDLDOMString> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecString;
+};
+template<> struct IDLArgumentTypeFilter<IDLAtomStringAdaptor<IDLDOMString>> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecString;
+};
+template<> struct IDLArgumentTypeFilter<IDLRequiresExistingAtomStringAdaptor<IDLDOMString>> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecString;
+};
+template<> struct IDLArgumentTypeFilter<IDLUint8Array> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecUint8Array;
+};
 
 template<typename IDLType>
 struct IDLResultTypeFilter {
     static const constexpr JSC::SpeculatedType value = JSC::SpecFullTop;
 };
 
-template<> struct IDLResultTypeFilter<IDLAny> { static const constexpr JSC::SpeculatedType value = JSC::SpecHeapTop; };
-template<> struct IDLResultTypeFilter<IDLBoolean> { static const constexpr JSC::SpeculatedType value = JSC::SpecBoolean; };
-template<> struct IDLResultTypeFilter<IDLByte> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLResultTypeFilter<IDLOctet> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLResultTypeFilter<IDLShort> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLResultTypeFilter<IDLUnsignedShort> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLResultTypeFilter<IDLLong> { static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only; };
-template<> struct IDLResultTypeFilter<IDLUnsignedLong> { static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber; };
-template<> struct IDLResultTypeFilter<IDLLongLong> { static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber; };
-template<> struct IDLResultTypeFilter<IDLUnsignedLongLong> { static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber; };
-template<> struct IDLResultTypeFilter<IDLFloat> { static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber; };
-template<> struct IDLResultTypeFilter<IDLUnrestrictedFloat> { static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber; };
-template<> struct IDLResultTypeFilter<IDLDouble> { static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber; };
-template<> struct IDLResultTypeFilter<IDLUnrestrictedDouble> { static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber; };
-template<> struct IDLResultTypeFilter<IDLDOMString> { static const constexpr JSC::SpeculatedType value = JSC::SpecString; };
-template<> struct IDLResultTypeFilter<IDLByteString> { static const constexpr JSC::SpeculatedType value = JSC::SpecString; };
-template<> struct IDLResultTypeFilter<IDLUSVString> { static const constexpr JSC::SpeculatedType value = JSC::SpecString; };
-template<> struct IDLResultTypeFilter<IDLAtomStringAdaptor<IDLDOMString>> { static const constexpr JSC::SpeculatedType value = JSC::SpecString; };
-template<> struct IDLResultTypeFilter<IDLRequiresExistingAtomStringAdaptor<IDLDOMString>> { static const constexpr JSC::SpeculatedType value = JSC::SpecString; };
-template<> struct IDLResultTypeFilter<IDLUint8Array> { static const constexpr JSC::SpeculatedType value = JSC::SpecUint8Array; };
-template<> struct IDLResultTypeFilter<IDLObject> { static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeTop; };
-
+template<> struct IDLResultTypeFilter<IDLAny> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecHeapTop;
+};
+template<> struct IDLResultTypeFilter<IDLBoolean> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBoolean;
+};
+template<> struct IDLResultTypeFilter<IDLByte> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLResultTypeFilter<IDLOctet> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLResultTypeFilter<IDLShort> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLResultTypeFilter<IDLUnsignedShort> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLResultTypeFilter<IDLLong> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecInt32Only;
+};
+template<> struct IDLResultTypeFilter<IDLUnsignedLong> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber;
+};
+template<> struct IDLResultTypeFilter<IDLLongLong> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber;
+};
+template<> struct IDLResultTypeFilter<IDLUnsignedLongLong> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber;
+};
+template<> struct IDLResultTypeFilter<IDLFloat> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber;
+};
+template<> struct IDLResultTypeFilter<IDLUnrestrictedFloat> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber;
+};
+template<> struct IDLResultTypeFilter<IDLDouble> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber;
+};
+template<> struct IDLResultTypeFilter<IDLUnrestrictedDouble> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeNumber;
+};
+template<> struct IDLResultTypeFilter<IDLDOMString> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecString;
+};
+template<> struct IDLResultTypeFilter<IDLByteString> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecString;
+};
+template<> struct IDLResultTypeFilter<IDLUSVString> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecString;
+};
+template<> struct IDLResultTypeFilter<IDLAtomStringAdaptor<IDLDOMString>> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecString;
+};
+template<> struct IDLResultTypeFilter<IDLRequiresExistingAtomStringAdaptor<IDLDOMString>> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecString;
+};
+template<> struct IDLResultTypeFilter<IDLUint8Array> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecUint8Array;
+};
+template<> struct IDLResultTypeFilter<IDLObject> {
+    static const constexpr JSC::SpeculatedType value = JSC::SpecBytecodeTop;
+};
 
 template<typename T>
 struct IDLResultTypeFilter<IDLNullable<T>> {
     static const constexpr JSC::SpeculatedType value = JSC::SpecOther | IDLResultTypeFilter<T>::value;
 };
 
-} }
+}
+}

src/bun.js/bindings/webcore/DOMPromiseProxy.h

@@ -36,6 +36,7 @@ namespace WebCore {
 template<typename IDLType>
 class DOMPromiseProxy {
     WTF_MAKE_FAST_ALLOCATED;
+
 public:
     using Value = typename IDLType::StorageType;
 
@@ -51,7 +52,7 @@ class DOMPromiseProxy {
     void resolve(typename IDLType::StorageType);
     void resolveWithNewlyCreated(typename IDLType::StorageType);
     void reject(Exception, RejectAsHandled = RejectAsHandled::No);
-    
+
 private:
     JSC::JSValue resolvePromise(JSC::JSGlobalObject&, JSDOMGlobalObject&, const Function<void(DeferredPromise&)>&);
 
@@ -62,6 +63,7 @@ class DOMPromiseProxy {
 template<>
 class DOMPromiseProxy<IDLUndefined> {
     WTF_MAKE_FAST_ALLOCATED;
+
 public:
     DOMPromiseProxy() = default;
     ~DOMPromiseProxy() = default;
@@ -87,10 +89,11 @@ class DOMPromiseProxy<IDLUndefined> {
 template<typename IDLType>
 class DOMPromiseProxyWithResolveCallback {
     WTF_MAKE_FAST_ALLOCATED;
+
 public:
     using ResolveCallback = Function<typename IDLType::ParameterType()>;
 
-    template <typename Class, typename BaseClass>
+    template<typename Class, typename BaseClass>
     DOMPromiseProxyWithResolveCallback(Class&, typename IDLType::ParameterType (BaseClass::*)());
     DOMPromiseProxyWithResolveCallback(ResolveCallback&&);
     ~DOMPromiseProxyWithResolveCallback() = default;
@@ -104,7 +107,7 @@ class DOMPromiseProxyWithResolveCallback {
     void resolve(typename IDLType::ParameterType);
     void resolveWithNewlyCreated(typename IDLType::ParameterType);
     void reject(Exception, RejectAsHandled = RejectAsHandled::No);
-    
+
 private:
     ResolveCallback m_resolveCallback;
     std::optional<ExceptionOr<void>> m_valueOrException;
@@ -208,7 +211,6 @@ inline void DOMPromiseProxy<IDLType>::reject(Exception exception, RejectAsHandle
         deferredPromise->reject(m_valueOrException->exception(), rejectAsHandled);
 }
 
-
 // MARK: - DOMPromiseProxy<IDLUndefined> specialization
 
 inline JSC::JSValue DOMPromiseProxy<IDLUndefined>::promise(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject)
@@ -250,7 +252,7 @@ inline bool DOMPromiseProxy<IDLUndefined>::isFulfilled() const
 inline void DOMPromiseProxy<IDLUndefined>::resolve()
 {
     ASSERT(!m_valueOrException);
-    m_valueOrException = ExceptionOr<void> { };
+    m_valueOrException = ExceptionOr<void> {};
     for (auto& deferredPromise : m_deferredPromises)
         deferredPromise->resolve();
 }
@@ -266,7 +268,7 @@ inline void DOMPromiseProxy<IDLUndefined>::reject(Exception exception, RejectAsH
 // MARK: - DOMPromiseProxyWithResolveCallback<IDLType> implementation
 
 template<typename IDLType>
-template <typename Class, typename BaseClass>
+template<typename Class, typename BaseClass>
 inline DOMPromiseProxyWithResolveCallback<IDLType>::DOMPromiseProxyWithResolveCallback(Class& object, typename IDLType::ParameterType (BaseClass::*function)())
     : m_resolveCallback(std::bind(function, &object))
 {
@@ -322,7 +324,7 @@ inline void DOMPromiseProxyWithResolveCallback<IDLType>::resolve(typename IDLTyp
 {
     ASSERT(!m_valueOrException);
 
-    m_valueOrException = ExceptionOr<void> { };
+    m_valueOrException = ExceptionOr<void> {};
     for (auto& deferredPromise : m_deferredPromises)
         deferredPromise->template resolve<IDLType>(value);
 }
@@ -332,7 +334,7 @@ inline void DOMPromiseProxyWithResolveCallback<IDLType>::resolveWithNewlyCreated
 {
     ASSERT(!m_valueOrException);
 
-    m_valueOrException = ExceptionOr<void> { };
+    m_valueOrException = ExceptionOr<void> {};
     for (auto& deferredPromise : m_deferredPromises)
         deferredPromise->template resolveWithNewlyCreated<IDLType>(value);
 }

src/bun.js/bindings/webcore/ErrorCallback.cpp

@@ -33,7 +33,7 @@ namespace WebCore {
 
 void ErrorCallback::scheduleCallback(ScriptExecutionContext& context, Ref<DOMException>&& exception)
 {
-    context.postTask([protectedThis = Ref { *this }, exception = WTFMove(exception)] (ScriptExecutionContext&) {
+    context.postTask([protectedThis = Ref { *this }, exception = WTFMove(exception)](ScriptExecutionContext&) {
         protectedThis->handleEvent(exception);
     });
 }

src/bun.js/bindings/webcore/EventListener.h

@@ -53,14 +53,14 @@ class EventListener : public RefCounted<EventListener>, public CanMakeWeakPtr<Ev
     virtual bool operator==(const EventListener&) const = 0;
     virtual void handleEvent(ScriptExecutionContext&, Event&) = 0;
 
-    virtual void visitJSFunction(JSC::AbstractSlotVisitor&) { }
-    virtual void visitJSFunction(JSC::SlotVisitor&) { }
+    virtual void visitJSFunction(JSC::AbstractSlotVisitor&) {}
+    virtual void visitJSFunction(JSC::SlotVisitor&) {}
 
     virtual bool isAttribute() const { return false; }
     Type type() const { return m_type; }
 
 #if ASSERT_ENABLED
-    virtual void checkValidityForEventTarget(EventTarget&) { }
+    virtual void checkValidityForEventTarget(EventTarget&) {}
 #endif
 
     virtual JSC::JSObject* jsFunction() const { return nullptr; }

src/bun.js/bindings/webcore/EventListenerOptions.h

@@ -30,7 +30,8 @@ namespace WebCore {
 struct EventListenerOptions {
     EventListenerOptions(bool capture = false)
         : capture(capture)
-    { }
+    {
+    }
 
     bool capture { false };
 };