libv8-node 15.5.1.0.beta1-x86_64-linux-musl → 16.10.0.0-x86_64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3777ca657e5b16d78bf012544dd3013201c4208c6dc99a819506e18ea0ce180d
-  data.tar.gz: 357f6ffbf1fe01b2892dea4f9b33260b67754c2257803ee08de7233b332299a1
+  metadata.gz: 0cedf064ab80ddde0c0e17fdab78db263c8c7a8dd939073a974939efc2399c88
+  data.tar.gz: 5acdea59c6e8c3336e66f179dbc69ad0c4cdfb166798734d725716c076f1f914
 SHA512:
-  metadata.gz: 6d4272406dd564459365defb2efbe328c10f764d76becd2d654bb660181d223e527481cf18d115a5640f3cc0419195d46f0c228d222bf3d41df879c6cf4f2da7
-  data.tar.gz: '098a97967eb43731f657a07d93e86c84fbf3ccf3a4a923a71ce43ca89f2afffe44bd3c4320a99f595298d8fa03c96847959b4113bd3e864dfdac1e102656be1c'
+  metadata.gz: 5324e7cf6d7a8f6ad027885582d184286b0f63b81e4172d1f47dce81240fa652ccfc917efdc45fba385d5617a07c6dce930baf107171b3cf7bf9347c837c9baa
+  data.tar.gz: f6561007b43cb91839de3ead9e9846f38699616c7812df46fdea40a5d6f5ecb20a678ef5cedeebe9034a792ca99e4848251fb436a02e38a0c0a5ded405cafdb6

data/ext/libv8-node/.location.yml

@@ -1,2 +1 @@
 --- !ruby/object:Libv8::Node::Location::Vendor {}
-

data/ext/libv8-node/location.rb

@@ -1,46 +1,56 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'pathname'
-require File.expand_path '../paths', __FILE__
+require File.expand_path('paths', __dir__)
 
 module Libv8; end
 
 module Libv8::Node
   class Location
     def install!
-      File.open(Pathname(__FILE__).dirname.join('.location.yml'), "w") do |f|
-        f.write self.to_yaml
+      File.open(Pathname(__FILE__).dirname.join('.location.yml'), 'w') do |f|
+        f.write(to_yaml)
       end
-      return 0
+
+      0
     end
 
     def self.load!
       File.open(Pathname(__FILE__).dirname.join('.location.yml')) do |f|
-        YAML.load f
+        YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(f) : YAML.load(f) # rubocop:disable Security/YAMLLoad
       end
     end
 
     class Vendor < Location
       def install!
-        require File.expand_path '../builder', __FILE__
+        require File.expand_path('builder', __dir__)
+
         builder = Libv8::Node::Builder.new
         exit_status = builder.build_libv8!
+        builder.remove_intermediates!
+
         super if exit_status == 0
+
         verify_installation!
-        return exit_status
+
+        exit_status
       end
 
       def configure(context = MkmfContext.new)
-        context.incflags.insert 0, Libv8::Node::Paths.include_paths.map{ |p| "-I#{p}" }.join(" ")  + " "
-        context.ldflags.insert 0, Libv8::Node::Paths.object_paths.join(" ") + " "
+        context.incflags.insert(0, Libv8::Node::Paths.include_paths.map { |p| "-I#{p}" }.join(' ') << ' ')
+        context.ldflags.insert(0, Libv8::Node::Paths.object_paths.join(' ') << ' ')
       end
 
       def verify_installation!
         include_paths = Libv8::Node::Paths.include_paths
+
         unless include_paths.detect { |p| Pathname(p).join('v8.h').exist? }
-          fail HeaderNotFound, "Unable to locate 'v8.h' in the libv8 header paths: #{include_paths.inspect}"
+          raise(HeaderNotFound, "Unable to locate 'v8.h' in the libv8 header paths: #{include_paths.inspect}")
         end
+
         Libv8::Node::Paths.object_paths.each do |p|
-          fail ArchiveNotFound, p unless File.exist? p
+          raise(ArchiveNotFound, p) unless File.exist?(p)
         end
       end
 
@@ -53,38 +63,13 @@ module Libv8::Node
       end
     end
 
-    class System < Location
-      def configure(context = MkmfContext.new)
-        context.send(:dir_config, 'v8')
-        context.send(:find_header, 'v8.h') or fail NotFoundError
-        context.send(:find_header, 'libplatform/libplatform.h') or fail NotFoundError
-        context.send(:have_library, 'v8') or fail NotFoundError
-      end
-
-      class NotFoundError < StandardError
-        def initialize(*args)
-          super(<<-EOS)
-By using --with-system-v8, you have chosen to use the version
-of V8 found on your system and *not* the one that is bundled with
-the libv8 rubygem.
-
-However, your system version of v8 could not be located.
-
-Please make sure your system version of v8 that is compatible
-with #{Libv8::Node::VERSION} installed. You may need to use the
---with-v8-dir option if it is installed in a non-standard location
-EOS
-        end
-      end
-    end
-
     class MkmfContext
       def incflags
-        $INCFLAGS
+        $INCFLAGS # rubocop:disable Style/GlobalVars
       end
 
       def ldflags
-        $LDFLAGS
+        $LDFLAGS # rubocop:disable Style/GlobalVars
       end
     end
   end

data/ext/libv8-node/paths.rb

@@ -13,7 +13,7 @@ module Libv8::Node
 
     def object_paths
       [Shellwords.escape(File.join(vendored_source_path,
-                                   'out.gn',
+                                   Gem::Platform.local.to_s,
                                    'libv8',
                                    'obj',
                                    "libv8_monolith.#{config['LIBEXT']}"))]
@@ -24,7 +24,7 @@ module Libv8::Node
     end
 
     def vendored_source_path
-      File.expand_path "../../../vendor/v8", __FILE__
+      File.expand_path('../../vendor/v8', __dir__)
     end
   end
 end

data/lib/libv8/node/version.rb

@@ -1,7 +1,7 @@
 module Libv8; end
 
 module Libv8::Node
-  VERSION = "15.5.1.0.beta1"
-  NODE_VERSION = "15.5.1"
-  LIBV8_VERSION = "8.6.395.17" # v8/include/v8-version.h
+  VERSION = '16.10.0.0'.freeze
+  NODE_VERSION = '16.10.0'.freeze
+  LIBV8_VERSION = '9.3.345.19'.freeze # from v8/include/v8-version.h
 end

data/vendor/v8/include/cppgc/allocation.h

@@ -5,24 +5,20 @@
 #ifndef INCLUDE_CPPGC_ALLOCATION_H_
 #define INCLUDE_CPPGC_ALLOCATION_H_
 
-#include <stdint.h>
-
 #include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <new>
+#include <type_traits>
 
 #include "cppgc/custom-space.h"
-#include "cppgc/garbage-collected.h"
 #include "cppgc/internal/api-constants.h"
 #include "cppgc/internal/gc-info.h"
+#include "cppgc/type-traits.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {
 
-template <typename T>
-class MakeGarbageCollectedTraitBase;
-
-namespace internal {
-class ObjectAllocator;
-}  // namespace internal
-
 /**
  * AllocationHandle is used to allocate garbage-collected objects.
  */
@@ -39,11 +35,32 @@ class V8_EXPORT MakeGarbageCollectedTraitInternal {
             const_cast<uint16_t*>(reinterpret_cast<const uint16_t*>(
                 reinterpret_cast<const uint8_t*>(payload) -
                 api_constants::kFullyConstructedBitFieldOffsetFromPayload)));
-    uint16_t value = atomic_mutable_bitfield->load(std::memory_order_relaxed);
-    value = value | api_constants::kFullyConstructedBitMask;
-    atomic_mutable_bitfield->store(value, std::memory_order_release);
+    atomic_mutable_bitfield->fetch_or(api_constants::kFullyConstructedBitMask,
+                                      std::memory_order_release);
   }
 
+  template <typename U, typename CustomSpace>
+  struct SpacePolicy {
+    static void* Allocate(AllocationHandle& handle, size_t size) {
+      // Custom space.
+      static_assert(std::is_base_of<CustomSpaceBase, CustomSpace>::value,
+                    "Custom space must inherit from CustomSpaceBase.");
+      return MakeGarbageCollectedTraitInternal::Allocate(
+          handle, size, internal::GCInfoTrait<U>::Index(),
+          CustomSpace::kSpaceIndex);
+    }
+  };
+
+  template <typename U>
+  struct SpacePolicy<U, void> {
+    static void* Allocate(AllocationHandle& handle, size_t size) {
+      // Default space.
+      return MakeGarbageCollectedTraitInternal::Allocate(
+          handle, size, internal::GCInfoTrait<U>::Index());
+    }
+  };
+
+ private:
   static void* Allocate(cppgc::AllocationHandle& handle, size_t size,
                         GCInfoIndex index);
   static void* Allocate(cppgc::AllocationHandle& handle, size_t size,
@@ -65,26 +82,12 @@ template <typename T>
 class MakeGarbageCollectedTraitBase
     : private internal::MakeGarbageCollectedTraitInternal {
  private:
-  template <typename U, typename CustomSpace>
-  struct SpacePolicy {
-    static void* Allocate(AllocationHandle& handle, size_t size) {
-      // Custom space.
-      static_assert(std::is_base_of<CustomSpaceBase, CustomSpace>::value,
-                    "Custom space must inherit from CustomSpaceBase.");
-      return internal::MakeGarbageCollectedTraitInternal::Allocate(
-          handle, size, internal::GCInfoTrait<T>::Index(),
-          CustomSpace::kSpaceIndex);
-    }
-  };
-
-  template <typename U>
-  struct SpacePolicy<U, void> {
-    static void* Allocate(AllocationHandle& handle, size_t size) {
-      // Default space.
-      return internal::MakeGarbageCollectedTraitInternal::Allocate(
-          handle, size, internal::GCInfoTrait<T>::Index());
-    }
-  };
+  static_assert(internal::IsGarbageCollectedType<T>::value,
+                "T needs to be a garbage collected object");
+  static_assert(!IsGarbageCollectedWithMixinTypeV<T> ||
+                    sizeof(T) <=
+                        internal::api_constants::kLargeObjectSizeThreshold,
+                "GarbageCollectedMixin may not be a large object");
 
  protected:
   /**
@@ -95,9 +98,15 @@ class MakeGarbageCollectedTraitBase
    * \param size The size that should be reserved for the object.
    * \returns the memory to construct an object of type T on.
    */
-  static void* Allocate(AllocationHandle& handle, size_t size) {
-    return SpacePolicy<T, typename SpaceTrait<T>::Space>::Allocate(handle,
-                                                                   size);
+  V8_INLINE static void* Allocate(AllocationHandle& handle, size_t size) {
+    static_assert(
+        std::is_base_of<typename T::ParentMostGarbageCollectedType, T>::value,
+        "U of GarbageCollected<U> must be a base of T. Check "
+        "GarbageCollected<T> base class inheritance.");
+    return SpacePolicy<
+        typename internal::GCInfoFolding<
+            T, typename T::ParentMostGarbageCollectedType>::ResultType,
+        typename SpaceTrait<T>::Space>::Allocate(handle, size);
   }
 
   /**
@@ -106,39 +115,70 @@ class MakeGarbageCollectedTraitBase
    *
    * \param payload The base pointer the object is allocated at.
    */
-  static void MarkObjectAsFullyConstructed(const void* payload) {
+  V8_INLINE static void MarkObjectAsFullyConstructed(const void* payload) {
     internal::MakeGarbageCollectedTraitInternal::MarkObjectAsFullyConstructed(
         payload);
   }
 };
 
+/**
+ * Passed to MakeGarbageCollected to specify how many bytes should be appended
+ * to the allocated object.
+ *
+ * Example:
+ * \code
+ * class InlinedArray final : public GarbageCollected<InlinedArray> {
+ *  public:
+ *   explicit InlinedArray(size_t bytes) : size(bytes), byte_array(this + 1) {}
+ *   void Trace(Visitor*) const {}
+
+ *   size_t size;
+ *   char* byte_array;
+ * };
+ *
+ * auto* inlined_array = MakeGarbageCollected<InlinedArray(
+ *    GetAllocationHandle(), AdditionalBytes(4), 4);
+ * for (size_t i = 0; i < 4; i++) {
+ *   Process(inlined_array->byte_array[i]);
+ * }
+ * \endcode
+ */
+struct AdditionalBytes {
+  constexpr explicit AdditionalBytes(size_t bytes) : value(bytes) {}
+  const size_t value;
+};
+
 /**
  * Default trait class that specifies how to construct an object of type T.
  * Advanced users may override how an object is constructed using the utilities
  * that are provided through MakeGarbageCollectedTraitBase.
  *
  * Any trait overriding construction must
- * - allocate through MakeGarbageCollectedTraitBase<T>::Allocate;
+ * - allocate through `MakeGarbageCollectedTraitBase<T>::Allocate`;
  * - mark the object as fully constructed using
- *   MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed;
+ *   `MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed`;
  */
 template <typename T>
 class MakeGarbageCollectedTrait : public MakeGarbageCollectedTraitBase<T> {
  public:
   template <typename... Args>
   static T* Call(AllocationHandle& handle, Args&&... args) {
-    static_assert(internal::IsGarbageCollectedType<T>::value,
-                  "T needs to be a garbage collected object");
-    static_assert(
-        !internal::IsGarbageCollectedMixinType<T>::value ||
-            sizeof(T) <= internal::api_constants::kLargeObjectSizeThreshold,
-        "GarbageCollectedMixin may not be a large object");
     void* memory =
         MakeGarbageCollectedTraitBase<T>::Allocate(handle, sizeof(T));
     T* object = ::new (memory) T(std::forward<Args>(args)...);
     MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed(object);
     return object;
   }
+
+  template <typename... Args>
+  static T* Call(AllocationHandle& handle, AdditionalBytes additional_bytes,
+                 Args&&... args) {
+    void* memory = MakeGarbageCollectedTraitBase<T>::Allocate(
+        handle, sizeof(T) + additional_bytes.value);
+    T* object = ::new (memory) T(std::forward<Args>(args)...);
+    MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed(object);
+    return object;
+  }
 };
 
 /**
@@ -168,6 +208,25 @@ T* MakeGarbageCollected(AllocationHandle& handle, Args&&... args) {
   return object;
 }
 
+/**
+ * Constructs a managed object of type T where T transitively inherits from
+ * GarbageCollected. Created objects will have additional bytes appended to
+ * it. Allocated memory would suffice for `sizeof(T) + additional_bytes`.
+ *
+ * \param additional_bytes Denotes how many bytes to append to T.
+ * \param args List of arguments with which an instance of T will be
+ *   constructed.
+ * \returns an instance of type T.
+ */
+template <typename T, typename... Args>
+T* MakeGarbageCollected(AllocationHandle& handle,
+                        AdditionalBytes additional_bytes, Args&&... args) {
+  T* object = MakeGarbageCollectedTrait<T>::Call(handle, additional_bytes,
+                                                 std::forward<Args>(args)...);
+  PostConstructionCallbackTrait<T>::Call(object);
+  return object;
+}
+
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_ALLOCATION_H_

data/vendor/v8/include/cppgc/common.h

@@ -10,15 +10,18 @@
 
 namespace cppgc {
 
-// Indicator for the stack state of the embedder.
+/**
+ *  Indicator for the stack state of the embedder.
+ */
 enum class EmbedderStackState {
+  /**
+   * Stack may contain interesting heap pointers.
+   */
   kMayContainHeapPointers,
+  /**
+   * Stack does not contain any interesting heap pointers.
+   */
   kNoHeapPointers,
-  kUnknown V8_ENUM_DEPRECATE_SOON("Use kMayContainHeapPointers") =
-      kMayContainHeapPointers,
-  kNonEmpty V8_ENUM_DEPRECATE_SOON("Use kMayContainHeapPointers") =
-      kMayContainHeapPointers,
-  kEmpty V8_ENUM_DEPRECATE_SOON("Use kNoHeapPointers") = kNoHeapPointers,
 };
 
 }  // namespace cppgc