libv8-node 15.5.1.0.beta1-x86_64-darwin-19 → 16.10.0.0-x86_64-darwin-19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (58) hide show
  1. checksums.yaml +4 -4
  2. data/ext/libv8-node/.location.yml +0 -1
  3. data/ext/libv8-node/location.rb +23 -38
  4. data/ext/libv8-node/paths.rb +2 -2
  5. data/lib/libv8/node/version.rb +3 -3
  6. data/vendor/v8/include/cppgc/allocation.h +104 -45
  7. data/vendor/v8/include/cppgc/common.h +9 -6
  8. data/vendor/v8/include/cppgc/cross-thread-persistent.h +384 -0
  9. data/vendor/v8/include/cppgc/custom-space.h +37 -2
  10. data/vendor/v8/include/cppgc/default-platform.h +47 -48
  11. data/vendor/v8/include/cppgc/ephemeron-pair.h +30 -0
  12. data/vendor/v8/include/cppgc/explicit-management.h +82 -0
  13. data/vendor/v8/include/cppgc/garbage-collected.h +4 -3
  14. data/vendor/v8/include/cppgc/heap-consistency.h +236 -0
  15. data/vendor/v8/include/cppgc/heap-state.h +70 -0
  16. data/vendor/v8/include/cppgc/heap-statistics.h +120 -0
  17. data/vendor/v8/include/cppgc/heap.h +68 -6
  18. data/vendor/v8/include/cppgc/internal/api-constants.h +3 -3
  19. data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +2 -1
  20. data/vendor/v8/include/cppgc/internal/compiler-specific.h +2 -2
  21. data/vendor/v8/include/cppgc/internal/gc-info.h +44 -13
  22. data/vendor/v8/include/cppgc/internal/name-trait.h +111 -0
  23. data/vendor/v8/include/cppgc/internal/persistent-node.h +57 -1
  24. data/vendor/v8/include/cppgc/internal/pointer-policies.h +69 -28
  25. data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +1 -1
  26. data/vendor/v8/include/cppgc/internal/write-barrier.h +353 -35
  27. data/vendor/v8/include/cppgc/liveness-broker.h +7 -1
  28. data/vendor/v8/include/cppgc/macros.h +2 -0
  29. data/vendor/v8/include/cppgc/member.h +85 -25
  30. data/vendor/v8/include/cppgc/name-provider.h +65 -0
  31. data/vendor/v8/include/cppgc/object-size-trait.h +58 -0
  32. data/vendor/v8/include/cppgc/persistent.h +33 -9
  33. data/vendor/v8/include/cppgc/platform.h +48 -25
  34. data/vendor/v8/include/cppgc/prefinalizer.h +1 -1
  35. data/vendor/v8/include/cppgc/process-heap-statistics.h +36 -0
  36. data/vendor/v8/include/cppgc/sentinel-pointer.h +32 -0
  37. data/vendor/v8/include/cppgc/source-location.h +2 -1
  38. data/vendor/v8/include/cppgc/testing.h +99 -0
  39. data/vendor/v8/include/cppgc/trace-trait.h +8 -3
  40. data/vendor/v8/include/cppgc/type-traits.h +157 -19
  41. data/vendor/v8/include/cppgc/visitor.h +187 -23
  42. data/vendor/v8/include/libplatform/libplatform.h +11 -0
  43. data/vendor/v8/include/libplatform/v8-tracing.h +2 -0
  44. data/vendor/v8/include/v8-cppgc.h +258 -159
  45. data/vendor/v8/include/v8-fast-api-calls.h +562 -159
  46. data/vendor/v8/include/v8-inspector.h +23 -2
  47. data/vendor/v8/include/v8-internal.h +99 -27
  48. data/vendor/v8/include/v8-metrics.h +77 -8
  49. data/vendor/v8/include/v8-platform.h +47 -22
  50. data/vendor/v8/include/v8-profiler.h +75 -11
  51. data/vendor/v8/include/v8-unwinder-state.h +30 -0
  52. data/vendor/v8/include/v8-util.h +1 -1
  53. data/vendor/v8/include/v8-version.h +4 -4
  54. data/vendor/v8/include/v8.h +1192 -642
  55. data/vendor/v8/include/v8config.h +40 -9
  56. data/vendor/v8/{out.gn → x86_64-darwin-19}/libv8/obj/libv8_monolith.a +0 -0
  57. metadata +34 -8
  58. data/vendor/v8/include/cppgc/internal/process-heap.h +0 -34
@@ -18,6 +18,38 @@
18
18
  * &v8::CFunction::Make(FastMethod));
19
19
  * \endcode
20
20
  *
21
+ * By design, fast calls are limited by the following requirements, which
22
+ * the embedder should enforce themselves:
23
+ * - they should not allocate on the JS heap;
24
+ * - they should not trigger JS execution.
25
+ * To enforce them, the embedder could use the existing
26
+ * v8::Isolate::DisallowJavascriptExecutionScope and a utility similar to
27
+ * Blink's NoAllocationScope:
28
+ * https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/platform/heap/thread_state_scopes.h;l=16
29
+ *
30
+ * Due to these limitations, it's not directly possible to report errors by
31
+ * throwing a JS exception or to otherwise do an allocation. There is an
32
+ * alternative way of creating fast calls that supports falling back to the
33
+ * slow call and then performing the necessary allocation. When one creates
34
+ * the fast method by using CFunction::MakeWithFallbackSupport instead of
35
+ * CFunction::Make, the fast callback gets as last parameter an output variable,
36
+ * through which it can request falling back to the slow call. So one might
37
+ * declare their method like:
38
+ *
39
+ * \code
40
+ * void FastMethodWithFallback(int param, FastApiCallbackOptions& options);
41
+ * \endcode
42
+ *
43
+ * If the callback wants to signal an error condition or to perform an
44
+ * allocation, it must set options.fallback to true and do an early return from
45
+ * the fast method. Then V8 checks the value of options.fallback and if it's
46
+ * true, falls back to executing the SlowCallback, which is capable of reporting
47
+ * the error (either by throwing a JS exception or logging to the console) or
48
+ * doing the allocation. It's the embedder's responsibility to ensure that the
49
+ * fast callback is idempotent up to the point where error and fallback
50
+ * conditions are checked, because otherwise executing the slow callback might
51
+ * produce visible side-effects twice.
52
+ *
21
53
  * An example for custom embedder type support might employ a way to wrap/
22
54
  * unwrap various C++ types in JSObject instances, e.g:
23
55
  *
@@ -38,8 +70,7 @@
38
70
  * return GetInternalField<CustomEmbedderType,
39
71
  * kV8EmbedderWrapperObjectIndex>(wrapper);
40
72
  * }
41
- * static void FastMethod(v8::ApiObject receiver_obj, int param) {
42
- * v8::Object* v8_object = reinterpret_cast<v8::Object*>(&api_object);
73
+ * static void FastMethod(v8::Local<v8::Object> receiver_obj, int param) {
43
74
  * CustomEmbedderType* receiver = static_cast<CustomEmbedderType*>(
44
75
  * receiver_obj->GetAlignedPointerFromInternalField(
45
76
  * kV8EmbedderWrapperObjectIndex));
@@ -116,23 +147,73 @@
116
147
  * receiver := the {embedder_object} from above
117
148
  * param := 42
118
149
  *
119
- * Currently only void return types are supported.
150
+ * Currently supported return types:
151
+ * - void
152
+ * - bool
153
+ * - int32_t
154
+ * - uint32_t
155
+ * - float32_t
156
+ * - float64_t
120
157
  * Currently supported argument types:
121
158
  * - pointer to an embedder type
159
+ * - JavaScript array of primitive types
122
160
  * - bool
123
161
  * - int32_t
124
162
  * - uint32_t
125
163
  * - int64_t
126
164
  * - uint64_t
165
+ * - float32_t
166
+ * - float64_t
167
+ *
127
168
  * The 64-bit integer types currently have the IDL (unsigned) long long
128
169
  * semantics: https://heycam.github.io/webidl/#abstract-opdef-converttoint
129
170
  * In the future we'll extend the API to also provide conversions from/to
130
171
  * BigInt to preserve full precision.
172
+ * The floating point types currently have the IDL (unrestricted) semantics,
173
+ * which is the only one used by WebGL. We plan to add support also for
174
+ * restricted floats/doubles, similarly to the BigInt conversion policies.
175
+ * We also differ from the specific NaN bit pattern that WebIDL prescribes
176
+ * (https://heycam.github.io/webidl/#es-unrestricted-float) in that Blink
177
+ * passes NaN values as-is, i.e. doesn't normalize them.
178
+ *
131
179
  * To be supported types:
132
- * - float32_t
133
- * - float64_t
134
- * - arrays of C types
180
+ * - TypedArrays and ArrayBuffers
135
181
  * - arrays of embedder types
182
+ *
183
+ *
184
+ * The API offers a limited support for function overloads:
185
+ *
186
+ * \code
187
+ * void FastMethod_2Args(int param, bool another_param);
188
+ * void FastMethod_3Args(int param, bool another_param, int third_param);
189
+ *
190
+ * v8::CFunction fast_method_2args_c_func =
191
+ * MakeV8CFunction(FastMethod_2Args);
192
+ * v8::CFunction fast_method_3args_c_func =
193
+ * MakeV8CFunction(FastMethod_3Args);
194
+ * const v8::CFunction fast_method_overloads[] = {fast_method_2args_c_func,
195
+ * fast_method_3args_c_func};
196
+ * Local<v8::FunctionTemplate> method_template =
197
+ * v8::FunctionTemplate::NewWithCFunctionOverloads(
198
+ * isolate, SlowCallback, data, signature, length,
199
+ * constructor_behavior, side_effect_type,
200
+ * {fast_method_overloads, 2});
201
+ * \endcode
202
+ *
203
+ * In this example a single FunctionTemplate is associated to multiple C++
204
+ * functions. The overload resolution is currently only based on the number of
205
+ * arguments passed in a call. For example, if this method_template is
206
+ * registered with a wrapper JS object as described above, a call with two
207
+ * arguments:
208
+ * obj.method(42, true);
209
+ * will result in a fast call to FastMethod_2Args, while a call with three or
210
+ * more arguments:
211
+ * obj.method(42, true, 11);
212
+ * will result in a fast call to FastMethod_3Args. Instead a call with less than
213
+ * two arguments, like:
214
+ * obj.method(42);
215
+ * would not result in a fast call but would fall back to executing the
216
+ * associated SlowCallback.
136
217
  */
137
218
 
138
219
  #ifndef INCLUDE_V8_FAST_API_CALLS_H_
@@ -141,13 +222,19 @@
141
222
  #include <stddef.h>
142
223
  #include <stdint.h>
143
224
 
225
+ #include <tuple>
226
+ #include <type_traits>
227
+
228
+ #include "v8.h" // NOLINT(build/include_directory)
144
229
  #include "v8config.h" // NOLINT(build/include_directory)
145
230
 
146
231
  namespace v8 {
147
232
 
233
+ class Isolate;
234
+
148
235
  class CTypeInfo {
149
236
  public:
150
- enum class Type : char {
237
+ enum class Type : uint8_t {
151
238
  kVoid,
152
239
  kBool,
153
240
  kInt32,
@@ -157,232 +244,548 @@ class CTypeInfo {
157
244
  kFloat32,
158
245
  kFloat64,
159
246
  kV8Value,
247
+ kApiObject, // This will be deprecated once all users have
248
+ // migrated from v8::ApiObject to v8::Local<v8::Value>.
160
249
  };
161
250
 
162
- enum class ArgFlags : uint8_t {
163
- kNone = 0,
164
- kIsArrayBit = 1 << 0, // This argument is first in an array of values.
251
+ // kCallbackOptionsType is not part of the Type enum
252
+ // because it is only used internally. Use value 255 that is larger
253
+ // than any valid Type enum.
254
+ static constexpr Type kCallbackOptionsType = Type(255);
255
+
256
+ enum class SequenceType : uint8_t {
257
+ kScalar,
258
+ kIsSequence, // sequence<T>
259
+ kIsTypedArray, // TypedArray of T or any ArrayBufferView if T
260
+ // is void
261
+ kIsArrayBuffer // ArrayBuffer
165
262
  };
166
263
 
167
- static CTypeInfo FromWrapperType(ArgFlags flags = ArgFlags::kNone) {
168
- return CTypeInfo(static_cast<int>(flags) | kIsWrapperTypeBit);
169
- }
264
+ enum class Flags : uint8_t {
265
+ kNone = 0,
266
+ kAllowSharedBit = 1 << 0, // Must be an ArrayBuffer or TypedArray
267
+ kEnforceRangeBit = 1 << 1, // T must be integral
268
+ kClampBit = 1 << 2, // T must be integral
269
+ kIsRestrictedBit = 1 << 3, // T must be float or double
270
+ };
170
271
 
171
- static constexpr CTypeInfo FromCType(Type ctype,
172
- ArgFlags flags = ArgFlags::kNone) {
173
- // TODO(mslekova): Refactor the manual bit manipulations to use
174
- // PointerWithPayload instead.
175
- // ctype cannot be Type::kV8Value.
176
- return CTypeInfo(
177
- ((static_cast<uintptr_t>(ctype) << kTypeOffset) & kTypeMask) |
178
- static_cast<int>(flags));
179
- }
272
+ explicit constexpr CTypeInfo(
273
+ Type type, SequenceType sequence_type = SequenceType::kScalar,
274
+ Flags flags = Flags::kNone)
275
+ : type_(type), sequence_type_(sequence_type), flags_(flags) {}
180
276
 
181
- const void* GetWrapperInfo() const;
277
+ constexpr Type GetType() const { return type_; }
278
+ constexpr SequenceType GetSequenceType() const { return sequence_type_; }
279
+ constexpr Flags GetFlags() const { return flags_; }
182
280
 
183
- constexpr Type GetType() const {
184
- if (payload_ & kIsWrapperTypeBit) {
185
- return Type::kV8Value;
186
- }
187
- return static_cast<Type>((payload_ & kTypeMask) >> kTypeOffset);
281
+ static constexpr bool IsIntegralType(Type type) {
282
+ return type == Type::kInt32 || type == Type::kUint32 ||
283
+ type == Type::kInt64 || type == Type::kUint64;
188
284
  }
189
285
 
190
- constexpr bool IsArray() const {
191
- return payload_ & static_cast<int>(ArgFlags::kIsArrayBit);
286
+ static constexpr bool IsFloatingPointType(Type type) {
287
+ return type == Type::kFloat32 || type == Type::kFloat64;
192
288
  }
193
289
 
194
- static const CTypeInfo& Invalid() {
195
- static CTypeInfo invalid = CTypeInfo(0);
196
- return invalid;
290
+ static constexpr bool IsPrimitive(Type type) {
291
+ return IsIntegralType(type) || IsFloatingPointType(type) ||
292
+ type == Type::kBool;
197
293
  }
198
294
 
199
295
  private:
200
- explicit constexpr CTypeInfo(uintptr_t payload) : payload_(payload) {}
296
+ Type type_;
297
+ SequenceType sequence_type_;
298
+ Flags flags_;
299
+ };
300
+
301
+ template <typename T>
302
+ struct FastApiTypedArray {
303
+ T* data; // should include the typed array offset applied
304
+ size_t length; // length in number of elements
305
+ };
306
+
307
+ // Any TypedArray. It uses kTypedArrayBit with base type void
308
+ // Overloaded args of ArrayBufferView and TypedArray are not supported
309
+ // (for now) because the generic “any” ArrayBufferView doesn’t have its
310
+ // own instance type. It could be supported if we specify that
311
+ // TypedArray<T> always has precedence over the generic ArrayBufferView,
312
+ // but this complicates overload resolution.
313
+ struct FastApiArrayBufferView {
314
+ void* data;
315
+ size_t byte_length;
316
+ };
317
+
318
+ struct FastApiArrayBuffer {
319
+ void* data;
320
+ size_t byte_length;
321
+ };
322
+
323
+ class V8_EXPORT CFunctionInfo {
324
+ public:
325
+ // Construct a struct to hold a CFunction's type information.
326
+ // |return_info| describes the function's return type.
327
+ // |arg_info| is an array of |arg_count| CTypeInfos describing the
328
+ // arguments. Only the last argument may be of the special type
329
+ // CTypeInfo::kCallbackOptionsType.
330
+ CFunctionInfo(const CTypeInfo& return_info, unsigned int arg_count,
331
+ const CTypeInfo* arg_info);
332
+
333
+ const CTypeInfo& ReturnInfo() const { return return_info_; }
334
+
335
+ // The argument count, not including the v8::FastApiCallbackOptions
336
+ // if present.
337
+ unsigned int ArgumentCount() const {
338
+ return HasOptions() ? arg_count_ - 1 : arg_count_;
339
+ }
201
340
 
202
- // That must be the last bit after ArgFlags.
203
- static constexpr uintptr_t kIsWrapperTypeBit = 1 << 1;
204
- static constexpr uintptr_t kWrapperTypeInfoMask = static_cast<uintptr_t>(~0)
205
- << 2;
341
+ // |index| must be less than ArgumentCount().
342
+ // Note: if the last argument passed on construction of CFunctionInfo
343
+ // has type CTypeInfo::kCallbackOptionsType, it is not included in
344
+ // ArgumentCount().
345
+ const CTypeInfo& ArgumentInfo(unsigned int index) const;
206
346
 
207
- static constexpr unsigned int kTypeOffset = kIsWrapperTypeBit;
208
- static constexpr unsigned int kTypeSize = 8 - kTypeOffset;
209
- static constexpr uintptr_t kTypeMask =
210
- (~(static_cast<uintptr_t>(~0) << kTypeSize)) << kTypeOffset;
347
+ bool HasOptions() const {
348
+ // The options arg is always the last one.
349
+ return arg_count_ > 0 && arg_info_[arg_count_ - 1].GetType() ==
350
+ CTypeInfo::kCallbackOptionsType;
351
+ }
211
352
 
212
- const uintptr_t payload_;
353
+ private:
354
+ const CTypeInfo return_info_;
355
+ const unsigned int arg_count_;
356
+ const CTypeInfo* arg_info_;
213
357
  };
214
358
 
215
- class CFunctionInfo {
359
+ class V8_EXPORT CFunction {
216
360
  public:
217
- virtual const CTypeInfo& ReturnInfo() const = 0;
218
- virtual unsigned int ArgumentCount() const = 0;
219
- virtual const CTypeInfo& ArgumentInfo(unsigned int index) const = 0;
361
+ constexpr CFunction() : address_(nullptr), type_info_(nullptr) {}
362
+
363
+ const CTypeInfo& ReturnInfo() const { return type_info_->ReturnInfo(); }
364
+
365
+ const CTypeInfo& ArgumentInfo(unsigned int index) const {
366
+ return type_info_->ArgumentInfo(index);
367
+ }
368
+
369
+ unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
370
+
371
+ const void* GetAddress() const { return address_; }
372
+ const CFunctionInfo* GetTypeInfo() const { return type_info_; }
373
+
374
+ enum class OverloadResolution { kImpossible, kAtRuntime, kAtCompileTime };
375
+
376
+ // Returns whether an overload between this and the given CFunction can
377
+ // be resolved at runtime by the RTTI available for the arguments or at
378
+ // compile time for functions with different number of arguments.
379
+ OverloadResolution GetOverloadResolution(const CFunction* other) {
380
+ // Runtime overload resolution can only deal with functions with the
381
+ // same number of arguments. Functions with different arity are handled
382
+ // by compile time overload resolution though.
383
+ if (ArgumentCount() != other->ArgumentCount()) {
384
+ return OverloadResolution::kAtCompileTime;
385
+ }
386
+
387
+ // The functions can only differ by a single argument position.
388
+ int diff_index = -1;
389
+ for (unsigned int i = 0; i < ArgumentCount(); ++i) {
390
+ if (ArgumentInfo(i).GetSequenceType() !=
391
+ other->ArgumentInfo(i).GetSequenceType()) {
392
+ if (diff_index >= 0) {
393
+ return OverloadResolution::kImpossible;
394
+ }
395
+ diff_index = i;
396
+
397
+ // We only support overload resolution between sequence types.
398
+ if (ArgumentInfo(i).GetSequenceType() ==
399
+ CTypeInfo::SequenceType::kScalar ||
400
+ other->ArgumentInfo(i).GetSequenceType() ==
401
+ CTypeInfo::SequenceType::kScalar) {
402
+ return OverloadResolution::kImpossible;
403
+ }
404
+ }
405
+ }
406
+
407
+ return OverloadResolution::kAtRuntime;
408
+ }
409
+
410
+ template <typename F>
411
+ static CFunction Make(F* func) {
412
+ return ArgUnwrap<F*>::Make(func);
413
+ }
414
+
415
+ template <typename F>
416
+ V8_DEPRECATED("Use CFunctionBuilder instead.")
417
+ static CFunction MakeWithFallbackSupport(F* func) {
418
+ return ArgUnwrap<F*>::Make(func);
419
+ }
420
+
421
+ CFunction(const void* address, const CFunctionInfo* type_info);
422
+
423
+ private:
424
+ const void* address_;
425
+ const CFunctionInfo* type_info_;
426
+
427
+ template <typename F>
428
+ class ArgUnwrap {
429
+ static_assert(sizeof(F) != sizeof(F),
430
+ "CFunction must be created from a function pointer.");
431
+ };
432
+
433
+ template <typename R, typename... Args>
434
+ class ArgUnwrap<R (*)(Args...)> {
435
+ public:
436
+ static CFunction Make(R (*func)(Args...));
437
+ };
220
438
  };
221
439
 
222
440
  struct ApiObject {
223
441
  uintptr_t address;
224
442
  };
225
443
 
444
+ /**
445
+ * A struct which may be passed to a fast call callback, like so:
446
+ * \code
447
+ * void FastMethodWithOptions(int param, FastApiCallbackOptions& options);
448
+ * \endcode
449
+ */
450
+ struct FastApiCallbackOptions {
451
+ /**
452
+ * Creates a new instance of FastApiCallbackOptions for testing purpose. The
453
+ * returned instance may be filled with mock data.
454
+ */
455
+ static FastApiCallbackOptions CreateForTesting(Isolate* isolate) {
456
+ return {false, {0}};
457
+ }
458
+
459
+ /**
460
+ * If the callback wants to signal an error condition or to perform an
461
+ * allocation, it must set options.fallback to true and do an early return
462
+ * from the fast method. Then V8 checks the value of options.fallback and if
463
+ * it's true, falls back to executing the SlowCallback, which is capable of
464
+ * reporting the error (either by throwing a JS exception or logging to the
465
+ * console) or doing the allocation. It's the embedder's responsibility to
466
+ * ensure that the fast callback is idempotent up to the point where error and
467
+ * fallback conditions are checked, because otherwise executing the slow
468
+ * callback might produce visible side-effects twice.
469
+ */
470
+ bool fallback;
471
+
472
+ /**
473
+ * The `data` passed to the FunctionTemplate constructor, or `undefined`.
474
+ * `data_ptr` allows for default constructing FastApiCallbackOptions.
475
+ */
476
+ union {
477
+ uintptr_t data_ptr;
478
+ v8::Value data;
479
+ };
480
+ };
481
+
226
482
  namespace internal {
227
483
 
228
- template <typename T>
229
- struct GetCType {
230
- static constexpr CTypeInfo Get() {
231
- return CTypeInfo::FromCType(CTypeInfo::Type::kV8Value);
484
+ // Helper to count the number of occurances of `T` in `List`
485
+ template <typename T, typename... List>
486
+ struct count : std::integral_constant<int, 0> {};
487
+ template <typename T, typename... Args>
488
+ struct count<T, T, Args...>
489
+ : std::integral_constant<std::size_t, 1 + count<T, Args...>::value> {};
490
+ template <typename T, typename U, typename... Args>
491
+ struct count<T, U, Args...> : count<T, Args...> {};
492
+
493
+ template <typename RetBuilder, typename... ArgBuilders>
494
+ class CFunctionInfoImpl : public CFunctionInfo {
495
+ static constexpr int kOptionsArgCount =
496
+ count<FastApiCallbackOptions&, ArgBuilders...>();
497
+ static constexpr int kReceiverCount = 1;
498
+
499
+ static_assert(kOptionsArgCount == 0 || kOptionsArgCount == 1,
500
+ "Only one options parameter is supported.");
501
+
502
+ static_assert(sizeof...(ArgBuilders) >= kOptionsArgCount + kReceiverCount,
503
+ "The receiver or the options argument is missing.");
504
+
505
+ public:
506
+ constexpr CFunctionInfoImpl()
507
+ : CFunctionInfo(RetBuilder::Build(), sizeof...(ArgBuilders),
508
+ arg_info_storage_),
509
+ arg_info_storage_{ArgBuilders::Build()...} {
510
+ constexpr CTypeInfo::Type kReturnType = RetBuilder::Build().GetType();
511
+ static_assert(kReturnType == CTypeInfo::Type::kVoid ||
512
+ kReturnType == CTypeInfo::Type::kBool ||
513
+ kReturnType == CTypeInfo::Type::kInt32 ||
514
+ kReturnType == CTypeInfo::Type::kUint32 ||
515
+ kReturnType == CTypeInfo::Type::kFloat32 ||
516
+ kReturnType == CTypeInfo::Type::kFloat64,
517
+ "64-bit int and api object values are not currently "
518
+ "supported return types.");
232
519
  }
520
+
521
+ private:
522
+ const CTypeInfo arg_info_storage_[sizeof...(ArgBuilders)];
233
523
  };
234
524
 
235
- #define SPECIALIZE_GET_C_TYPE_FOR(ctype, ctypeinfo) \
236
- template <> \
237
- struct GetCType<ctype> { \
238
- static constexpr CTypeInfo Get() { \
239
- return CTypeInfo::FromCType(CTypeInfo::Type::ctypeinfo); \
240
- } \
525
+ template <typename T>
526
+ struct TypeInfoHelper {
527
+ static_assert(sizeof(T) != sizeof(T), "This type is not supported");
528
+ };
529
+
530
+ #define SPECIALIZE_GET_TYPE_INFO_HELPER_FOR(T, Enum) \
531
+ template <> \
532
+ struct TypeInfoHelper<T> { \
533
+ static constexpr CTypeInfo::Flags Flags() { \
534
+ return CTypeInfo::Flags::kNone; \
535
+ } \
536
+ \
537
+ static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::Enum; } \
538
+ static constexpr CTypeInfo::SequenceType SequenceType() { \
539
+ return CTypeInfo::SequenceType::kScalar; \
540
+ } \
241
541
  };
242
542
 
243
- #define SUPPORTED_C_TYPES(V) \
244
- V(void, kVoid) \
543
+ template <CTypeInfo::Type type>
544
+ struct CTypeInfoTraits {};
545
+
546
+ #define DEFINE_TYPE_INFO_TRAITS(CType, Enum) \
547
+ template <> \
548
+ struct CTypeInfoTraits<CTypeInfo::Type::Enum> { \
549
+ using ctype = CType; \
550
+ };
551
+
552
+ #define PRIMITIVE_C_TYPES(V) \
245
553
  V(bool, kBool) \
246
554
  V(int32_t, kInt32) \
247
555
  V(uint32_t, kUint32) \
248
556
  V(int64_t, kInt64) \
249
557
  V(uint64_t, kUint64) \
250
558
  V(float, kFloat32) \
251
- V(double, kFloat64) \
252
- V(ApiObject, kV8Value)
559
+ V(double, kFloat64)
560
+
561
+ // Same as above, but includes deprecated types for compatibility.
562
+ #define ALL_C_TYPES(V) \
563
+ PRIMITIVE_C_TYPES(V) \
564
+ V(void, kVoid) \
565
+ V(v8::Local<v8::Value>, kV8Value) \
566
+ V(v8::Local<v8::Object>, kV8Value) \
567
+ V(ApiObject, kApiObject)
568
+
569
+ // ApiObject was a temporary solution to wrap the pointer to the v8::Value.
570
+ // Please use v8::Local<v8::Value> in new code for the arguments and
571
+ // v8::Local<v8::Object> for the receiver, as ApiObject will be deprecated.
572
+
573
+ ALL_C_TYPES(SPECIALIZE_GET_TYPE_INFO_HELPER_FOR)
574
+ PRIMITIVE_C_TYPES(DEFINE_TYPE_INFO_TRAITS)
575
+
576
+ #undef PRIMITIVE_C_TYPES
577
+ #undef ALL_C_TYPES
578
+
579
+ #define SPECIALIZE_GET_TYPE_INFO_HELPER_FOR_TA(T, Enum) \
580
+ template <> \
581
+ struct TypeInfoHelper<FastApiTypedArray<T>> { \
582
+ static constexpr CTypeInfo::Flags Flags() { \
583
+ return CTypeInfo::Flags::kNone; \
584
+ } \
585
+ \
586
+ static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::Enum; } \
587
+ static constexpr CTypeInfo::SequenceType SequenceType() { \
588
+ return CTypeInfo::SequenceType::kIsTypedArray; \
589
+ } \
590
+ };
253
591
 
254
- SUPPORTED_C_TYPES(SPECIALIZE_GET_C_TYPE_FOR)
592
+ #define TYPED_ARRAY_C_TYPES(V) \
593
+ V(int32_t, kInt32) \
594
+ V(uint32_t, kUint32) \
595
+ V(int64_t, kInt64) \
596
+ V(uint64_t, kUint64) \
597
+ V(float, kFloat32) \
598
+ V(double, kFloat64)
255
599
 
256
- // T* where T is a primitive (array of primitives).
257
- template <typename T, typename = void>
258
- struct GetCTypePointerImpl {
259
- static constexpr CTypeInfo Get() {
260
- return CTypeInfo::FromCType(GetCType<T>::Get().GetType(),
261
- CTypeInfo::ArgFlags::kIsArrayBit);
262
- }
263
- };
600
+ TYPED_ARRAY_C_TYPES(SPECIALIZE_GET_TYPE_INFO_HELPER_FOR_TA)
264
601
 
265
- // T* where T is an API object.
266
- template <typename T>
267
- struct GetCTypePointerImpl<T, void> {
268
- static constexpr CTypeInfo Get() { return CTypeInfo::FromWrapperType(); }
269
- };
602
+ #undef TYPED_ARRAY_C_TYPES
270
603
 
271
- // T** where T is a primitive. Not allowed.
272
- template <typename T, typename = void>
273
- struct GetCTypePointerPointerImpl {
274
- static_assert(sizeof(T**) != sizeof(T**), "Unsupported type");
275
- };
604
+ template <>
605
+ struct TypeInfoHelper<v8::Local<v8::Array>> {
606
+ static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
276
607
 
277
- // T** where T is an API object (array of API objects).
278
- template <typename T>
279
- struct GetCTypePointerPointerImpl<T, void> {
280
- static constexpr CTypeInfo Get() {
281
- return CTypeInfo::FromWrapperType(CTypeInfo::ArgFlags::kIsArrayBit);
608
+ static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::kVoid; }
609
+ static constexpr CTypeInfo::SequenceType SequenceType() {
610
+ return CTypeInfo::SequenceType::kIsSequence;
282
611
  }
283
612
  };
284
613
 
285
- template <typename T>
286
- struct GetCType<T**> : public GetCTypePointerPointerImpl<T> {};
287
-
288
- template <typename T>
289
- struct GetCType<T*> : public GetCTypePointerImpl<T> {};
614
+ template <>
615
+ struct TypeInfoHelper<v8::Local<v8::Uint32Array>> {
616
+ static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
290
617
 
291
- template <typename R, bool RaisesException, typename... Args>
292
- class CFunctionInfoImpl : public CFunctionInfo {
293
- public:
294
- static constexpr int kHasErrorArgCount = (RaisesException ? 1 : 0);
295
- static constexpr int kReceiverCount = 1;
296
- CFunctionInfoImpl()
297
- : return_info_(internal::GetCType<R>::Get()),
298
- arg_count_(sizeof...(Args) - kHasErrorArgCount),
299
- arg_info_{internal::GetCType<Args>::Get()...} {
300
- static_assert(sizeof...(Args) >= kHasErrorArgCount + kReceiverCount,
301
- "The receiver or the has_error argument is missing.");
302
- static_assert(
303
- internal::GetCType<R>::Get().GetType() == CTypeInfo::Type::kVoid,
304
- "Only void return types are currently supported.");
618
+ static constexpr CTypeInfo::Type Type() { return CTypeInfo::Type::kUint32; }
619
+ static constexpr CTypeInfo::SequenceType SequenceType() {
620
+ return CTypeInfo::SequenceType::kIsTypedArray;
305
621
  }
622
+ };
306
623
 
307
- const CTypeInfo& ReturnInfo() const override { return return_info_; }
308
- unsigned int ArgumentCount() const override { return arg_count_; }
309
- const CTypeInfo& ArgumentInfo(unsigned int index) const override {
310
- if (index >= ArgumentCount()) {
311
- return CTypeInfo::Invalid();
312
- }
313
- return arg_info_[index];
314
- }
624
+ template <>
625
+ struct TypeInfoHelper<FastApiCallbackOptions&> {
626
+ static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
315
627
 
316
- private:
317
- const CTypeInfo return_info_;
318
- const unsigned int arg_count_;
319
- const CTypeInfo arg_info_[sizeof...(Args)];
628
+ static constexpr CTypeInfo::Type Type() {
629
+ return CTypeInfo::kCallbackOptionsType;
630
+ }
631
+ static constexpr CTypeInfo::SequenceType SequenceType() {
632
+ return CTypeInfo::SequenceType::kScalar;
633
+ }
320
634
  };
321
635
 
322
- } // namespace internal
636
+ #define STATIC_ASSERT_IMPLIES(COND, ASSERTION, MSG) \
637
+ static_assert(((COND) == 0) || (ASSERTION), MSG)
323
638
 
324
- class V8_EXPORT CFunction {
639
+ template <typename T, CTypeInfo::Flags... Flags>
640
+ class CTypeInfoBuilder {
325
641
  public:
326
- constexpr CFunction() : address_(nullptr), type_info_(nullptr) {}
327
-
328
- const CTypeInfo& ReturnInfo() const { return type_info_->ReturnInfo(); }
329
-
330
- const CTypeInfo& ArgumentInfo(unsigned int index) const {
331
- return type_info_->ArgumentInfo(index);
642
+ using BaseType = T;
643
+
644
+ static constexpr CTypeInfo Build() {
645
+ constexpr CTypeInfo::Flags kFlags =
646
+ MergeFlags(TypeInfoHelper<T>::Flags(), Flags...);
647
+ constexpr CTypeInfo::Type kType = TypeInfoHelper<T>::Type();
648
+ constexpr CTypeInfo::SequenceType kSequenceType =
649
+ TypeInfoHelper<T>::SequenceType();
650
+
651
+ STATIC_ASSERT_IMPLIES(
652
+ uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kAllowSharedBit),
653
+ (kSequenceType == CTypeInfo::SequenceType::kIsTypedArray ||
654
+ kSequenceType == CTypeInfo::SequenceType::kIsArrayBuffer),
655
+ "kAllowSharedBit is only allowed for TypedArrays and ArrayBuffers.");
656
+ STATIC_ASSERT_IMPLIES(
657
+ uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kEnforceRangeBit),
658
+ CTypeInfo::IsIntegralType(kType),
659
+ "kEnforceRangeBit is only allowed for integral types.");
660
+ STATIC_ASSERT_IMPLIES(
661
+ uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kClampBit),
662
+ CTypeInfo::IsIntegralType(kType),
663
+ "kClampBit is only allowed for integral types.");
664
+ STATIC_ASSERT_IMPLIES(
665
+ uint8_t(kFlags) & uint8_t(CTypeInfo::Flags::kIsRestrictedBit),
666
+ CTypeInfo::IsFloatingPointType(kType),
667
+ "kIsRestrictedBit is only allowed for floating point types.");
668
+ STATIC_ASSERT_IMPLIES(kSequenceType == CTypeInfo::SequenceType::kIsSequence,
669
+ kType == CTypeInfo::Type::kVoid,
670
+ "Sequences are only supported from void type.");
671
+ STATIC_ASSERT_IMPLIES(
672
+ kSequenceType == CTypeInfo::SequenceType::kIsTypedArray,
673
+ CTypeInfo::IsPrimitive(kType) || kType == CTypeInfo::Type::kVoid,
674
+ "TypedArrays are only supported from primitive types or void.");
675
+
676
+ // Return the same type with the merged flags.
677
+ return CTypeInfo(TypeInfoHelper<T>::Type(),
678
+ TypeInfoHelper<T>::SequenceType(), kFlags);
332
679
  }
333
680
 
334
- unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
681
+ private:
682
+ template <typename... Rest>
683
+ static constexpr CTypeInfo::Flags MergeFlags(CTypeInfo::Flags flags,
684
+ Rest... rest) {
685
+ return CTypeInfo::Flags(uint8_t(flags) | uint8_t(MergeFlags(rest...)));
686
+ }
687
+ static constexpr CTypeInfo::Flags MergeFlags() { return CTypeInfo::Flags(0); }
688
+ };
335
689
 
336
- const void* GetAddress() const { return address_; }
337
- const CFunctionInfo* GetTypeInfo() const { return type_info_; }
690
+ template <typename RetBuilder, typename... ArgBuilders>
691
+ class CFunctionBuilderWithFunction {
692
+ public:
693
+ explicit constexpr CFunctionBuilderWithFunction(const void* fn) : fn_(fn) {}
338
694
 
339
- template <typename F>
340
- static CFunction Make(F* func) {
341
- return ArgUnwrap<F*>::Make(func);
695
+ template <CTypeInfo::Flags... Flags>
696
+ constexpr auto Ret() {
697
+ return CFunctionBuilderWithFunction<
698
+ CTypeInfoBuilder<typename RetBuilder::BaseType, Flags...>,
699
+ ArgBuilders...>(fn_);
342
700
  }
343
701
 
344
- template <typename F>
345
- static CFunction MakeWithErrorSupport(F* func) {
346
- return ArgUnwrap<F*>::MakeWithErrorSupport(func);
702
+ template <unsigned int N, CTypeInfo::Flags... Flags>
703
+ constexpr auto Arg() {
704
+ // Return a copy of the builder with the Nth arg builder merged with
705
+ // template parameter pack Flags.
706
+ return ArgImpl<N, Flags...>(
707
+ std::make_index_sequence<sizeof...(ArgBuilders)>());
347
708
  }
348
709
 
349
- template <typename F>
350
- static CFunction Make(F* func, const CFunctionInfo* type_info) {
351
- return CFunction(reinterpret_cast<const void*>(func), type_info);
710
+ auto Build() {
711
+ static CFunctionInfoImpl<RetBuilder, ArgBuilders...> instance;
712
+ return CFunction(fn_, &instance);
352
713
  }
353
714
 
354
715
  private:
355
- const void* address_;
356
- const CFunctionInfo* type_info_;
716
+ template <bool Merge, unsigned int N, CTypeInfo::Flags... Flags>
717
+ struct GetArgBuilder;
718
+
719
+ // Returns the same ArgBuilder as the one at index N, including its flags.
720
+ // Flags in the template parameter pack are ignored.
721
+ template <unsigned int N, CTypeInfo::Flags... Flags>
722
+ struct GetArgBuilder<false, N, Flags...> {
723
+ using type =
724
+ typename std::tuple_element<N, std::tuple<ArgBuilders...>>::type;
725
+ };
357
726
 
358
- CFunction(const void* address, const CFunctionInfo* type_info);
727
+ // Returns an ArgBuilder with the same base type as the one at index N,
728
+ // but merges the flags with the flags in the template parameter pack.
729
+ template <unsigned int N, CTypeInfo::Flags... Flags>
730
+ struct GetArgBuilder<true, N, Flags...> {
731
+ using type = CTypeInfoBuilder<
732
+ typename std::tuple_element<N,
733
+ std::tuple<ArgBuilders...>>::type::BaseType,
734
+ std::tuple_element<N, std::tuple<ArgBuilders...>>::type::Build()
735
+ .GetFlags(),
736
+ Flags...>;
737
+ };
359
738
 
360
- template <typename R, bool RaisesException, typename... Args>
361
- static CFunctionInfo* GetCFunctionInfo() {
362
- static internal::CFunctionInfoImpl<R, RaisesException, Args...> instance;
363
- return &instance;
739
+ // Return a copy of the CFunctionBuilder, but merges the Flags on
740
+ // ArgBuilder index N with the new Flags passed in the template parameter
741
+ // pack.
742
+ template <unsigned int N, CTypeInfo::Flags... Flags, size_t... I>
743
+ constexpr auto ArgImpl(std::index_sequence<I...>) {
744
+ return CFunctionBuilderWithFunction<
745
+ RetBuilder, typename GetArgBuilder<N == I, I, Flags...>::type...>(fn_);
364
746
  }
365
747
 
366
- template <typename F>
367
- class ArgUnwrap {
368
- static_assert(sizeof(F) != sizeof(F),
369
- "CFunction must be created from a function pointer.");
370
- };
748
+ const void* fn_;
749
+ };
750
+
751
+ class CFunctionBuilder {
752
+ public:
753
+ constexpr CFunctionBuilder() {}
371
754
 
372
755
  template <typename R, typename... Args>
373
- class ArgUnwrap<R (*)(Args...)> {
374
- public:
375
- static CFunction Make(R (*func)(Args...)) {
376
- return CFunction(reinterpret_cast<const void*>(func),
377
- GetCFunctionInfo<R, false, Args...>());
378
- }
379
- static CFunction MakeWithErrorSupport(R (*func)(Args...)) {
380
- return CFunction(reinterpret_cast<const void*>(func),
381
- GetCFunctionInfo<R, true, Args...>());
382
- }
383
- };
756
+ constexpr auto Fn(R (*fn)(Args...)) {
757
+ return CFunctionBuilderWithFunction<CTypeInfoBuilder<R>,
758
+ CTypeInfoBuilder<Args>...>(
759
+ reinterpret_cast<const void*>(fn));
760
+ }
384
761
  };
385
762
 
763
+ } // namespace internal
764
+
765
+ // static
766
+ template <typename R, typename... Args>
767
+ CFunction CFunction::ArgUnwrap<R (*)(Args...)>::Make(R (*func)(Args...)) {
768
+ return internal::CFunctionBuilder().Fn(func).Build();
769
+ }
770
+
771
+ using CFunctionBuilder = internal::CFunctionBuilder;
772
+
773
+ /**
774
+ * Copies the contents of this JavaScript array to a C++ buffer with
775
+ * a given max_length. A CTypeInfo is passed as an argument,
776
+ * instructing different rules for conversion (e.g. restricted float/double).
777
+ * The element type T of the destination array must match the C type
778
+ * corresponding to the CTypeInfo (specified by CTypeInfoTraits).
779
+ * If the array length is larger than max_length or the array is of
780
+ * unsupported type, the operation will fail, returning false. Generally, an
781
+ * array which contains objects, undefined, null or anything not convertible
782
+ * to the requested destination type, is considered unsupported. The operation
783
+ * returns true on success. `type_info` will be used for conversions.
784
+ */
785
+ template <const CTypeInfo* type_info, typename T>
786
+ bool CopyAndConvertArrayToCppBuffer(Local<Array> src, T* dst,
787
+ uint32_t max_length);
788
+
386
789
  } // namespace v8
387
790
 
388
791
  #endif // INCLUDE_V8_FAST_API_CALLS_H_