src: use concepts where appropriate

node.gyp

@@ -255,6 +255,7 @@
       'src/node_blob.h',
       'src/node_buffer.h',
       'src/node_builtins.h',
+      'src/node_concepts.h',
       'src/node_config_file.h',
       'src/node_constants.h',
       'src/node_context_data.h',

src/aliased_buffer-inl.h

@@ -12,6 +12,7 @@ namespace node {
 typedef size_t AliasedBufferIndex;
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
     v8::Isolate* isolate, const size_t count, const AliasedBufferIndex* index)
     : isolate_(isolate), count_(count), byte_offset_(0), index_(index) {
@@ -34,6 +35,7 @@ AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
     v8::Isolate* isolate,
     const size_t byte_offset,
@@ -65,6 +67,7 @@ AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
     const AliasedBufferBase& that)
     : isolate_(that.isolate_),
@@ -76,13 +79,15 @@ AliasedBufferBase<NativeT, V8T>::AliasedBufferBase(
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 AliasedBufferIndex AliasedBufferBase<NativeT, V8T>::Serialize(
     v8::Local<v8::Context> context, v8::SnapshotCreator* creator) {
   DCHECK(is_valid());
   return creator->AddData(context, GetJSArray());
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 inline void AliasedBufferBase<NativeT, V8T>::Deserialize(
     v8::Local<v8::Context> context) {
   DCHECK_NOT_NULL(index_);
@@ -99,6 +104,7 @@ inline void AliasedBufferBase<NativeT, V8T>::Deserialize(
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 AliasedBufferBase<NativeT, V8T>& AliasedBufferBase<NativeT, V8T>::operator=(
     AliasedBufferBase<NativeT, V8T>&& that) noexcept {
   DCHECK(is_valid());
@@ -116,41 +122,48 @@ AliasedBufferBase<NativeT, V8T>& AliasedBufferBase<NativeT, V8T>::operator=(
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 v8::Local<V8T> AliasedBufferBase<NativeT, V8T>::GetJSArray() const {
   DCHECK(is_valid());
   return js_array_.Get(isolate_);
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 void AliasedBufferBase<NativeT, V8T>::Release() {
   DCHECK_NULL(index_);
   js_array_.Reset();
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 inline void AliasedBufferBase<NativeT, V8T>::MakeWeak() {
   DCHECK(is_valid());
   js_array_.SetWeak();
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 v8::Local<v8::ArrayBuffer> AliasedBufferBase<NativeT, V8T>::GetArrayBuffer()
     const {
   return GetJSArray()->Buffer();
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 inline const NativeT* AliasedBufferBase<NativeT, V8T>::GetNativeBuffer() const {
   DCHECK(is_valid());
   return buffer_;
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 inline const NativeT* AliasedBufferBase<NativeT, V8T>::operator*() const {
   return GetNativeBuffer();
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 inline void AliasedBufferBase<NativeT, V8T>::SetValue(const size_t index,
                                                       NativeT value) {
   DCHECK_LT(index, count_);
@@ -159,6 +172,7 @@ inline void AliasedBufferBase<NativeT, V8T>::SetValue(const size_t index,
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 inline const NativeT AliasedBufferBase<NativeT, V8T>::GetValue(
     const size_t index) const {
   DCHECK(is_valid());
@@ -167,23 +181,27 @@ inline const NativeT AliasedBufferBase<NativeT, V8T>::GetValue(
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 typename AliasedBufferBase<NativeT, V8T>::Reference
 AliasedBufferBase<NativeT, V8T>::operator[](size_t index) {
   DCHECK(is_valid());
   return Reference(this, index);
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 NativeT AliasedBufferBase<NativeT, V8T>::operator[](size_t index) const {
   return GetValue(index);
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 size_t AliasedBufferBase<NativeT, V8T>::Length() const {
   return count_;
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 void AliasedBufferBase<NativeT, V8T>::reserve(size_t new_capacity) {
   DCHECK(is_valid());
   DCHECK_GE(new_capacity, count_);
@@ -214,11 +232,13 @@ void AliasedBufferBase<NativeT, V8T>::reserve(size_t new_capacity) {
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 inline bool AliasedBufferBase<NativeT, V8T>::is_valid() const {
   return index_ == nullptr && !js_array_.IsEmpty();
 }
 
 template <typename NativeT, typename V8T>
+  requires std::is_scalar_v<NativeT>
 inline size_t AliasedBufferBase<NativeT, V8T>::SelfSize() const {
   return sizeof(*this);
 }

src/aliased_buffer.h

@@ -29,10 +29,9 @@ typedef size_t AliasedBufferIndex;
  * observed. Any notification APIs will be left as a future exercise.
  */
 template <class NativeT, class V8T>
+  requires std::is_scalar_v<NativeT>
 class AliasedBufferBase final : public MemoryRetainer {
  public:
-  static_assert(std::is_scalar_v<NativeT>);
-
   AliasedBufferBase(v8::Isolate* isolate,
                     size_t count,
                     const AliasedBufferIndex* index = nullptr);

src/blob_serializer_deserializer-inl.h

@@ -90,8 +90,8 @@ std::string BlobSerializerDeserializer::GetName() const {
 // Helper for reading numeric types.
 template <typename Impl>
 template <typename T>
+  requires std::is_arithmetic_v<T>
 T BlobDeserializer<Impl>::ReadArithmetic() {
-  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
   T result;
   ReadArithmetic(&result, 1);
   return result;
@@ -158,8 +158,8 @@ std::string_view BlobDeserializer<Impl>::ReadStringView(StringLogMode mode) {
 // Helper for reading an array of numeric types.
 template <typename Impl>
 template <typename T>
+  requires std::is_arithmetic_v<T>
 void BlobDeserializer<Impl>::ReadArithmetic(T* out, size_t count) {
-  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
   DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
   if (is_debug) {
     std::string name = GetName<T>();
@@ -180,8 +180,8 @@ void BlobDeserializer<Impl>::ReadArithmetic(T* out, size_t count) {
 // Helper for reading numeric vectors.
 template <typename Impl>
 template <typename Number>
+  requires std::is_arithmetic_v<Number>
 std::vector<Number> BlobDeserializer<Impl>::ReadArithmeticVector(size_t count) {
-  static_assert(std::is_arithmetic_v<Number>, "Not an arithmetic type");
   DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
   std::vector<Number> result(count);
   ReadArithmetic(result.data(), count);
@@ -191,8 +191,8 @@ std::vector<Number> BlobDeserializer<Impl>::ReadArithmeticVector(size_t count) {
 // Helper for reading non-numeric vectors.
 template <typename Impl>
 template <typename T>
+  requires(!std::is_arithmetic_v<T>)
 std::vector<T> BlobDeserializer<Impl>::ReadNonArithmeticVector(size_t count) {
-  static_assert(!std::is_arithmetic_v<T>, "Arithmetic type");
   DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
   std::vector<T> result;
   result.reserve(count);
@@ -224,8 +224,8 @@ T BlobDeserializer<Impl>::ReadElement() {
 // Helper for writing numeric types.
 template <typename Impl>
 template <typename T>
+  requires std::is_arithmetic_v<T>
 size_t BlobSerializer<Impl>::WriteArithmetic(const T& data) {
-  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
   return WriteArithmetic(&data, 1);
 }
 
@@ -303,8 +303,8 @@ static size_t kPreviewCount = 16;
 // Helper for writing an array of numeric types.
 template <typename Impl>
 template <typename T>
+  requires std::is_arithmetic_v<T>
 size_t BlobSerializer<Impl>::WriteArithmetic(const T* data, size_t count) {
-  static_assert(std::is_arithmetic_v<T>, "Arithmetic type");
   DCHECK_GT(count, 0);  // Should not write contents for vectors of size 0.
   if (is_debug) {
     size_t preview_count = count < kPreviewCount ? count : kPreviewCount;
@@ -338,18 +338,18 @@ size_t BlobSerializer<Impl>::WriteArithmetic(const T* data, size_t count) {
 // Helper for writing numeric vectors.
 template <typename Impl>
 template <typename Number>
+  requires std::is_arithmetic_v<Number>
 size_t BlobSerializer<Impl>::WriteArithmeticVector(
     const std::vector<Number>& data) {
-  static_assert(std::is_arithmetic_v<Number>, "Arithmetic type");
   return WriteArithmetic(data.data(), data.size());
 }
 
 // Helper for writing non-numeric vectors.
 template <typename Impl>
 template <typename T>
-size_t BlobSerializer<Impl>::WriteNonArithmeticVector(
-    const std::vector<T>& data) {
-  static_assert(!std::is_arithmetic_v<T>, "Arithmetic type");
+  requires(!std::is_arithmetic_v<T>)
+size_t
+    BlobSerializer<Impl>::WriteNonArithmeticVector(const std::vector<T>& data) {
   DCHECK_GT(data.size(),
             0);  // Should not write contents for vectors of size 0.
   size_t written_total = 0;

src/blob_serializer_deserializer.h

@@ -1,7 +1,9 @@
 #ifndef SRC_BLOB_SERIALIZER_DESERIALIZER_H_
 #define SRC_BLOB_SERIALIZER_DESERIALIZER_H_
 
+#include <concepts>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
@@ -49,6 +51,7 @@ class BlobDeserializer : public BlobSerializerDeserializer {
 
   // Helper for reading numeric types.
   template <typename T>
+    requires std::is_arithmetic_v<T>
   T ReadArithmetic();
 
   // Layout of vectors:
@@ -63,15 +66,18 @@ class BlobDeserializer : public BlobSerializerDeserializer {
 
   // Helper for reading an array of numeric types.
   template <typename T>
+    requires std::is_arithmetic_v<T>
   void ReadArithmetic(T* out, size_t count);
 
   // Helper for reading numeric vectors.
   template <typename Number>
+    requires std::is_arithmetic_v<Number>
   std::vector<Number> ReadArithmeticVector(size_t count);
 
  private:
   // Helper for reading non-numeric vectors.
   template <typename T>
+    requires(!std::is_arithmetic_v<T>)
   std::vector<T> ReadNonArithmeticVector(size_t count);
 
   template <typename T>
@@ -94,6 +100,7 @@ class BlobSerializer : public BlobSerializerDeserializer {
 
   // Helper for writing numeric types.
   template <typename T>
+    requires std::is_arithmetic_v<T>
   size_t WriteArithmetic(const T& data);
 
   // Layout of vectors:
@@ -110,15 +117,18 @@ class BlobSerializer : public BlobSerializerDeserializer {
 
   // Helper for writing an array of numeric types.
   template <typename T>
+    requires std::is_arithmetic_v<T>
   size_t WriteArithmetic(const T* data, size_t count);
 
   // Helper for writing numeric vectors.
   template <typename Number>
+    requires std::is_arithmetic_v<Number>
   size_t WriteArithmeticVector(const std::vector<Number>& data);
 
  private:
   // Helper for writing non-numeric vectors.
   template <typename T>
+    requires(!std::is_arithmetic_v<T>)
   size_t WriteNonArithmeticVector(const std::vector<T>& data);
 
   template <typename T>

src/crypto/crypto_aes.cc

@@ -259,7 +259,7 @@ WebCryptoCipherStatus AES_KW_Cipher(Environment* env,
 // implementation here:
 // https://github.com/chromium/chromium/blob/7af6cfd/components/webcrypto/algorithms/aes_ctr.cc
 
-template <typename T>
+template <std::integral T>
 T CeilDiv(T a, T b) {
   return a == 0 ? 0 : 1 + (a - 1) / b;
 }

src/crypto/crypto_util.h

@@ -732,8 +732,8 @@ class ArrayBufferOrViewContents final {
   }
 
   template <typename M>
+    requires(sizeof(M) == 1)
   void CopyTo(M* dest, size_t len) const {
-    static_assert(sizeof(M) == 1, "sizeof(M) must equal 1");
     len = std::min(len, size());
     if (len > 0 && data() != nullptr) {
       memcpy(dest, data(), len);

src/debug_utils-inl.h

@@ -49,10 +49,7 @@ struct ToStringHelper {
     return value.ToStringView();
   }
 
-  template <typename T,
-            typename test_for_number = typename std::
-                enable_if_t<std::is_arithmetic_v<T> || std::is_enum_v<T>, bool>,
-            typename dummy = bool>
+  template <NumericOrEnum T>
   static std::string Convert(const T& value) {
     return std::to_string(value);
   }
@@ -81,9 +78,7 @@ struct ToStringHelper {
     return utf8_value.ToString();
   }
 
-  template <unsigned BASE_BITS,
-            typename T,
-            typename = std::enable_if_t<std::is_integral_v<T>>>
+  template <unsigned BASE_BITS, std::integral T>
   static std::string BaseConvert(const T& value) {
     auto v = static_cast<uint64_t>(value);
     char ret[3 * sizeof(T)];
@@ -96,9 +91,8 @@ struct ToStringHelper {
     } while ((v >>= BASE_BITS) != 0);
     return ptr;
   }
-  template <unsigned BASE_BITS,
-            typename T,
-            typename = std::enable_if_t<!std::is_integral_v<T>>>
+  template <unsigned BASE_BITS, typename T>
+    requires(!std::integral<T>)
   static auto BaseConvert(T&& value) {
     return Convert(std::forward<T>(value));
   }

src/json_utils.h

@@ -3,6 +3,8 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "node_concepts.h"
+
 #include <iomanip>
 #include <limits>
 #include <ostream>
@@ -132,9 +134,7 @@ class JSONWriter {
   };
 
  private:
-  template <typename T,
-            typename test_for_number = typename std::
-                enable_if<std::numeric_limits<T>::is_specialized, bool>::type>
+  template <NumericValue T>
   inline void write_value(T number) {
     if constexpr (std::is_same<T, bool>::value)
       out_ << (number ? "true" : "false");

src/memory_tracker-inl.h

@@ -203,7 +203,7 @@ void MemoryTracker::TrackField(const char* edge_name,
   TrackField(edge_name, container, node_name, element_name);
 }
 
-template <typename T, typename test_for_number, typename dummy>
+template <NumericValue T>
 void MemoryTracker::TrackField(const char* edge_name,
                                const T& value,
                                const char* node_name) {