Update from 1.87.1

Author: mtwebster

.clang-format

@@ -18,6 +18,10 @@ IndentPPDirectives: AfterHash
 IndentWidth: 4
 MacroBlockBegin: "^JSNATIVE_TEST_FUNC_BEGIN$"
 MacroBlockEnd: "^JSNATIVE_TEST_FUNC_END$"
+Macros:
+- GJS_ALWAYS_INLINE=[[always_inline]]  # COMPAT: switch in C++20
+- GJS_JSAPI_RETURN_CONVENTION=[[nodiscard]]
+- GJS_USE=[[nodiscard]]
 PointerAlignment: Left  # Google style allows both, but clang-format doesn't
 SpacesBeforeTrailingComments: 2
 ---

.clangd

@@ -3,4 +3,4 @@
 
 Diagnostics:
   ClangTidy:
-    Remove: bugprone-sizeof-expression  # Interferes with g_clear_pointer()
+    Remove: none*

cjs/atoms.cpp

@@ -39,16 +39,17 @@ bool GjsSymbolAtom::init(JSContext* cx, const char* str) {
  * tracing has been set up. */
 bool GjsAtoms::init_atoms(JSContext* cx) {
 #define INITIALIZE_ATOM(identifier, str) \
-    if (!identifier.init(cx, str))       \
+    if (!(identifier).init(cx, str))     \
         return false;
     FOR_EACH_ATOM(INITIALIZE_ATOM)
     FOR_EACH_SYMBOL_ATOM(INITIALIZE_ATOM)
     return true;
+#undef INITIALIZE_ATOM
 }
 
 void GjsAtoms::trace(JSTracer* trc) {
 #define TRACE_ATOM(identifier, str) \
-    JS::TraceEdge<jsid>(trc, identifier.id(), "Atom " str);
+    JS::TraceEdge<jsid>(trc, (identifier).id(), "Atom " str);
     FOR_EACH_ATOM(TRACE_ATOM)
     FOR_EACH_SYMBOL_ATOM(TRACE_ATOM)
 #undef TRACE_ATOM

cjs/atoms.h

@@ -3,8 +3,7 @@
 // SPDX-FileCopyrightText: 2018 Philip Chimento <philip.chimento@gmail.com>
 // SPDX-FileCopyrightText: 2018 Marco Trevisan <marco.trevisan@canonical.com>
 
-#ifndef GJS_ATOMS_H_
-#define GJS_ATOMS_H_
+#pragma once
 
 #include <config.h>
 
@@ -86,12 +85,13 @@ class JSTracer;
 // clang-format on
 
 struct GjsAtom {
-    GJS_JSAPI_RETURN_CONVENTION bool init(JSContext* cx, const char* str);
+    GJS_JSAPI_RETURN_CONVENTION bool init(JSContext*, const char* str);
 
     /* It's OK to return JS::HandleId here, to avoid an extra root, with the
      * caveat that you should not use this value after the GjsContext has been
      * destroyed.*/
-    [[nodiscard]] JS::HandleId operator()() const {
+    [[nodiscard]]
+    JS::HandleId operator()() const {
         return JS::HandleId::fromMarkedLocation(&m_jsid.get());
     }
 
@@ -102,16 +102,17 @@ struct GjsAtom {
 };
 
 struct GjsSymbolAtom : GjsAtom {
-    GJS_JSAPI_RETURN_CONVENTION bool init(JSContext* cx, const char* str);
+    GJS_JSAPI_RETURN_CONVENTION
+    bool init(JSContext*, const char* str);
 };
 
 class GjsAtoms {
  public:
-    GjsAtoms(void) {}
-    ~GjsAtoms(void) {}  // prevents giant destructor from being inlined
-    GJS_JSAPI_RETURN_CONVENTION bool init_atoms(JSContext* cx);
+    GjsAtoms() = default;
+    ~GjsAtoms() = default;  // prevents giant destructor from being inlined
+    GJS_JSAPI_RETURN_CONVENTION bool init_atoms(JSContext*);
 
-    void trace(JSTracer* trc);
+    void trace(JSTracer*);
 
 #define DECLARE_ATOM_MEMBER(identifier, str) GjsAtom identifier;
 #define DECLARE_SYMBOL_ATOM_MEMBER(identifier, str) GjsSymbolAtom identifier;
@@ -125,5 +126,3 @@ class GjsAtoms {
 #    undef FOR_EACH_ATOM
 #    undef FOR_EACH_SYMBOL_ATOM
 #endif
-
-#endif  // GJS_ATOMS_H_

cjs/auto.h

@@ -15,6 +15,7 @@
 
 #include <glib-object.h>
 #include <glib.h>
+// IWYU pragma: no_forward_declare _GVariant
 
 #include <js/Utility.h>  // for UniqueChars
 
@@ -128,9 +129,12 @@ struct AutoPointer {
     constexpr operator ConstPtr() const { return m_ptr; }
     constexpr operator bool() const { return m_ptr != nullptr; }
 
-    constexpr Ptr get() const { return m_ptr; }
-    constexpr Ptr* out() { return &m_ptr; }
-    constexpr ConstPtr* out() const { return const_cast<ConstPtr*>(&m_ptr); }
+    [[nodiscard]] constexpr Ptr get() const { return m_ptr; }
+    [[nodiscard]] constexpr Ptr* out() { return &m_ptr; }
+    [[nodiscard]]
+    constexpr ConstPtr* out() const {
+        return const_cast<ConstPtr*>(&m_ptr);
+    }
 
     constexpr Ptr release() {
         auto* ptr = m_ptr;
@@ -197,7 +201,8 @@ using AutoChar =
 // free(). It would cause crashes if SpiderMonkey were to stop supporting
 // embedders using the system allocator in the future. In that case, this
 // function would have to copy the string.
-[[nodiscard]] inline AutoChar js_chars_to_glib(JS::UniqueChars&& js_chars) {
+[[nodiscard]]
+inline AutoChar js_chars_to_glib(JS::UniqueChars&& js_chars) {
     return {js_chars.release()};
 }
 

cjs/byteArray.cpp

@@ -22,7 +22,7 @@
 #include <js/experimental/TypedData.h>
 #include <jsapi.h>  // for JS_NewPlainObject
 
-#include "gi/boxed.h"
+#include "gi/struct.h"
 #include "cjs/atoms.h"
 #include "cjs/byteArray.h"
 #include "cjs/context-private.h"
@@ -43,35 +43,35 @@ static bool to_string_func(JSContext* cx, unsigned argc, JS::Value* vp) {
         return false;
 
     const char* actual_encoding = encoding ? encoding.get() : "utf-8";
-    JS::RootedString str(
-        cx, gjs_decode_from_uint8array(cx, byte_array, actual_encoding,
-                                       GjsStringTermination::ZERO_TERMINATED, true));
+    JS::RootedString str{cx, gjs_decode_from_uint8array(
+                                 cx, byte_array, actual_encoding,
+                                 GjsStringTermination::ZERO_TERMINATED, true)};
     if (!str)
         return false;
 
     args.rval().setString(str);
     return true;
 }
 
-/* Workaround to keep existing code compatible. This function is tacked onto
- * any Uint8Array instances created in situations where previously a ByteArray
- * would have been created. It logs a compatibility warning. */
+/* Workaround to keep existing code compatible. This function is tacked onto any
+ * Uint8Array instances created in situations where previously a ByteArray would
+ * have been created. It logs a compatibility warning. */
 GJS_JSAPI_RETURN_CONVENTION
 static bool instance_to_string_func(JSContext* cx, unsigned argc,
                                     JS::Value* vp) {
     GJS_GET_THIS(cx, argc, vp, args, this_obj);
     JS::UniqueChars encoding;
 
-    _gjs_warn_deprecated_once_per_callsite(
+    gjs_warn_deprecated_once_per_callsite(
         cx, GjsDeprecationMessageId::ByteArrayInstanceToString);
 
     if (!gjs_parse_call_args(cx, "toString", args, "|s", "encoding", &encoding))
         return false;
 
     const char* actual_encoding = encoding ? encoding.get() : "utf-8";
-    JS::RootedString str(
-        cx, gjs_decode_from_uint8array(cx, this_obj, actual_encoding,
-                                       GjsStringTermination::ZERO_TERMINATED, true));
+    JS::RootedString str{cx, gjs_decode_from_uint8array(
+                                 cx, this_obj, actual_encoding,
+                                 GjsStringTermination::ZERO_TERMINATED, true)};
     if (!str)
         return false;
 
@@ -86,7 +86,7 @@ static bool define_legacy_tostring(JSContext* cx, JS::HandleObject array) {
                                  instance_to_string_func, 1, 0);
 }
 
-/* fromString() function implementation */
+// fromString() function implementation
 GJS_JSAPI_RETURN_CONVENTION
 static bool from_string_func(JSContext* cx, unsigned argc, JS::Value* vp) {
     JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
@@ -108,38 +108,32 @@ static bool from_string_func(JSContext* cx, unsigned argc, JS::Value* vp) {
 }
 
 GJS_JSAPI_RETURN_CONVENTION
-static bool
-from_gbytes_func(JSContext *context,
-                 unsigned   argc,
-                 JS::Value *vp)
-{
-    JS::CallArgs argv = JS::CallArgsFromVp (argc, vp);
-    JS::RootedObject bytes_obj(context);
-    GBytes *gbytes;
-
-    if (!gjs_parse_call_args(context, "fromGBytes", argv, "o",
-                             "bytes", &bytes_obj))
+static bool from_gbytes_func(JSContext* cx, unsigned argc, JS::Value* vp) {
+    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+    JS::RootedObject bytes_obj{cx};
+
+    if (!gjs_parse_call_args(cx, "fromGBytes", args, "o", "bytes", &bytes_obj))
         return false;
 
-    if (!BoxedBase::typecheck(context, bytes_obj, G_TYPE_BYTES))
+    if (!StructBase::typecheck(cx, bytes_obj, G_TYPE_BYTES))
         return false;
 
-    gbytes = BoxedBase::to_c_ptr<GBytes>(context, bytes_obj);
+    GBytes* gbytes = StructBase::to_c_ptr<GBytes>(cx, bytes_obj);
     if (!gbytes)
         return false;
 
     size_t len;
     const void* data = g_bytes_get_data(gbytes, &len);
     if (len == 0) {
-        JS::RootedObject empty_array(context, JS_NewUint8Array(context, 0));
-        if (!empty_array || !define_legacy_tostring(context, empty_array))
+        JS::RootedObject empty_array{cx, JS_NewUint8Array(cx, 0)};
+        if (!empty_array || !define_legacy_tostring(cx, empty_array))
             return false;
 
-        argv.rval().setObject(*empty_array);
+        args.rval().setObject(*empty_array);
         return true;
     }
 
-    JS::RootedObject array_buffer{context, JS::NewArrayBuffer(context, len)};
+    JS::RootedObject array_buffer{cx, JS::NewArrayBuffer(cx, len)};
     if (!array_buffer)
         return false;
 
@@ -152,12 +146,12 @@ from_gbytes_func(JSContext *context,
         std::copy_n(static_cast<const uint8_t*>(data), len, storage);
     }
 
-    JS::RootedObject obj(
-        context, JS_NewUint8ArrayWithBuffer(context, array_buffer, 0, -1));
-    if (!obj || !define_legacy_tostring(context, obj))
+    JS::RootedObject obj{cx,
+                         JS_NewUint8ArrayWithBuffer(cx, array_buffer, 0, -1)};
+    if (!obj || !define_legacy_tostring(cx, obj))
         return false;
 
-    argv.rval().setObject(*obj);
+    args.rval().setObject(*obj);
     return true;
 }
 
@@ -211,10 +205,8 @@ static JSFunctionSpec gjs_byte_array_module_funcs[] = {
     JS_FN("toString", to_string_func, 2, 0),
     JS_FS_END};
 
-bool
-gjs_define_byte_array_stuff(JSContext              *cx,
-                            JS::MutableHandleObject module)
-{
+bool gjs_define_byte_array_stuff(JSContext* cx,
+                                 JS::MutableHandleObject module) {
     module.set(JS_NewPlainObject(cx));
     return JS_DefineFunctions(cx, module, gjs_byte_array_module_funcs);
 }

cjs/byteArray.h

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
 // SPDX-FileCopyrightText: 2010 litl, LLC
 
-#ifndef GJS_BYTEARRAY_H_
-#define GJS_BYTEARRAY_H_
+#pragma once
 
 #include <config.h>
 
@@ -16,18 +15,13 @@
 #include "cjs/macros.h"
 
 GJS_JSAPI_RETURN_CONVENTION
-bool gjs_define_byte_array_stuff(JSContext              *context,
-                                 JS::MutableHandleObject module);
+bool gjs_define_byte_array_stuff(JSContext*, JS::MutableHandleObject module);
 
 GJS_JSAPI_RETURN_CONVENTION
-JSObject* gjs_byte_array_from_data_copy(JSContext* cx, size_t nbytes,
-                                        void* data);
+JSObject* gjs_byte_array_from_data_copy(JSContext*, size_t nbytes, void* data);
 
 GJS_JSAPI_RETURN_CONVENTION
-JSObject *    gjs_byte_array_from_byte_array (JSContext  *context,
-                                              GByteArray *array);
+JSObject* gjs_byte_array_from_byte_array(JSContext*, GByteArray*);
 
-[[nodiscard]] GByteArray* gjs_byte_array_get_byte_array(JSObject* obj);
-[[nodiscard]] GBytes* gjs_byte_array_get_bytes(JSObject* obj);
-
-#endif  // GJS_BYTEARRAY_H_
+[[nodiscard]] GByteArray* gjs_byte_array_get_byte_array(JSObject*);
+[[nodiscard]] GBytes* gjs_byte_array_get_bytes(JSObject*);

cjs/cjs_pch.hh

@@ -8,6 +8,7 @@
 #include <algorithm>
 #include <array>
 #include <atomic>
+#include <chrono>
 #include <cmath>
 #include <cstddef>
 #include <deque>
@@ -16,6 +17,7 @@
 #include <limits>
 #include <memory>
 #include <new>
+#include <ratio>
 #include <sstream>
 #include <string>
 #include <string_view>