Directly implement assignment from numeric types & nullptr to folly::…

…dynamic

Summary: Should avoid intermediate folly::dynamic construction (and consequent cheap-but-not-free ~dynamic invocation) when possible.

Reviewed By: ot

Differential Revision: D45837998

fbshipit-source-id: 42477e3c8a0a6af138b13ad0cd7fd79aae20d4d3

folly/dynamic-inl.h

@@ -393,6 +393,20 @@ dynamic::dynamic(Iterator first, Iterator last) : type_(ARRAY) {
   new (&u_.array) Array(first, last);
 }
 
+template <
+    class T,
+    class NumericType /* = typename NumericTypeHelper<T>::type */>
+dynamic& dynamic::operator=(T t) {
+  const auto newType = TypeInfo<NumericType>::type;
+  if (type_ == newType) {
+    *getAddress<NumericType>() = t;
+  } else {
+    destroy();
+    new (getAddress<NumericType>()) NumericType(t);
+    type_ = newType;
+  }
+  return *this;
+}
 //////////////////////////////////////////////////////////////////////
 
 inline dynamic::const_iterator dynamic::begin() const {

folly/dynamic.cpp

@@ -177,6 +177,17 @@ dynamic& dynamic::operator=(dynamic&& o) noexcept {
   return *this;
 }
 
+dynamic& dynamic::operator=(std::nullptr_t) {
+  if (type_ == NULLT) {
+    // Do nothing -- nul has only one possible value.
+  } else {
+    destroy();
+    u_.nul = nullptr;
+    type_ = NULLT;
+  }
+  return *this;
+}
+
 dynamic const& dynamic::atImpl(dynamic const& idx) const& {
   if (auto* parray = get_nothrow<Array>()) {
     if (!idx.isInt()) {

folly/dynamic.h

@@ -365,6 +365,15 @@ struct dynamic {
   dynamic& operator=(dynamic const&);
   dynamic& operator=(dynamic&&) noexcept;
 
+  /*
+   * Minor performance optimization: allow assignment from cheap
+   * primitive types without creating a temporary dynamic.
+   */
+  template <class T, class NumericType = typename NumericTypeHelper<T>::type>
+  dynamic& operator=(T t);
+
+  dynamic& operator=(std::nullptr_t);
+
   /*
    * For simple dynamics (not arrays or objects), this prints the
    * value to an std::ostream in the expected way.  Respects the

folly/test/DynamicBenchmark.cpp

@@ -60,6 +60,16 @@ BENCHMARK(copyBool, iters) {
   }
 }
 
+BENCHMARK(assignRawBool, iters) {
+  bool b = true;
+  dynamic other = false;
+  folly::makeUnpredictable(b);
+  for (size_t i = 0; i < iters; ++i) {
+    other = b;
+    folly::doNotOptimizeAway(other);
+  }
+}
+
 BENCHMARK(copyShortString, iters) {
   dynamic s = "short";
   folly::makeUnpredictable(s);