Merge branch 'master' of https://github.com/jonathandturner/rhai

.github/workflows/benchmark.yml

@@ -1,29 +0,0 @@
-name: Benchmark
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  benchmark:
-    name: Run Rust benchmark
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: rustup toolchain update nightly && rustup default nightly
-      - name: Run benchmark
-        run: cargo +nightly bench | tee output.txt
-      - name: Store benchmark result
-        uses: rhysd/github-action-benchmark@v1
-        with:
-          name: Rust Benchmark
-          tool: 'cargo'
-          output-file-path: output.txt
-          # Use personal access token instead of GITHUB_TOKEN due to https://github.community/t5/GitHub-Actions/Github-action-not-triggering-gh-pages-upon-push/td-p/26869/highlight/false
-          github-token: ${{ secrets.RHAI }}
-          auto-push: true
-          # Show alert with commit comment on detecting possible performance regression
-          alert-threshold: '200%'
-          comment-on-alert: true
-          fail-on-alert: true
-          alert-comment-cc-users: '@schungx'

src/serde/de.rs

@@ -162,10 +162,12 @@ impl<'de> Deserializer<'de> for &mut DynamicDeserializer<'de> {
             Union::Variant(value) if value.is::<i16>() => self.deserialize_i16(visitor),
             Union::Variant(value) if value.is::<i32>() => self.deserialize_i32(visitor),
             Union::Variant(value) if value.is::<i64>() => self.deserialize_i64(visitor),
+            Union::Variant(value) if value.is::<i128>() => self.deserialize_i128(visitor),
             Union::Variant(value) if value.is::<u8>() => self.deserialize_u8(visitor),
             Union::Variant(value) if value.is::<u16>() => self.deserialize_u16(visitor),
             Union::Variant(value) if value.is::<u32>() => self.deserialize_u32(visitor),
             Union::Variant(value) if value.is::<u64>() => self.deserialize_u64(visitor),
+            Union::Variant(value) if value.is::<u128>() => self.deserialize_u128(visitor),
 
             Union::Variant(_) => self.type_error(),
         }
@@ -219,6 +221,18 @@ impl<'de> Deserializer<'de> for &mut DynamicDeserializer<'de> {
         }
     }
 
+    fn deserialize_i128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Box<EvalAltResult>> {
+        if let Ok(v) = self.value.as_int() {
+            self.deserialize_int(v, visitor)
+        } else if cfg!(not(feature = "only_i32")) {
+            self.type_error()
+        } else {
+            self.value
+                .downcast_ref::<i128>()
+                .map_or_else(|| self.type_error(), |&x| visitor.visit_i128(x))
+        }
+    }
+
     fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Box<EvalAltResult>> {
         if let Ok(v) = self.value.as_int() {
             self.deserialize_int(v, visitor)
@@ -259,6 +273,16 @@ impl<'de> Deserializer<'de> for &mut DynamicDeserializer<'de> {
         }
     }
 
+    fn deserialize_u128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Box<EvalAltResult>> {
+        if let Ok(v) = self.value.as_int() {
+            self.deserialize_int(v, visitor)
+        } else {
+            self.value
+                .downcast_ref::<u128>()
+                .map_or_else(|| self.type_error(), |&x| visitor.visit_u128(x))
+        }
+    }
+
     fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Box<EvalAltResult>> {
         #[cfg(not(feature = "no_float"))]
         return self

src/serde/ser.rs

@@ -150,6 +150,21 @@ impl Serializer for &mut DynamicSerializer {
         }
     }
 
+    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Box<EvalAltResult>> {
+        #[cfg(not(feature = "only_i32"))]
+        if v > i64::MAX as i128 {
+            return Ok(Dynamic::from(v));
+        } else {
+            return self.serialize_i64(v as i64);
+        }
+        #[cfg(feature = "only_i32")]
+        if v > i32::MAX as i128 {
+            return Ok(Dynamic::from(v));
+        } else {
+            return self.serialize_i32(v as i32);
+        }
+    }
+
     fn serialize_u8(self, v: u8) -> Result<Self::Ok, Box<EvalAltResult>> {
         #[cfg(not(feature = "only_i32"))]
         return self.serialize_i64(i64::from(v));
@@ -190,6 +205,21 @@ impl Serializer for &mut DynamicSerializer {
         }
     }
 
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Box<EvalAltResult>> {
+        #[cfg(not(feature = "only_i32"))]
+        if v > i64::MAX as u128 {
+            return Ok(Dynamic::from(v));
+        } else {
+            return self.serialize_i64(v as i64);
+        }
+        #[cfg(feature = "only_i32")]
+        if v > i32::MAX as u128 {
+            return Ok(Dynamic::from(v));
+        } else {
+            return self.serialize_i32(v as i32);
+        }
+    }
+
     fn serialize_f32(self, v: f32) -> Result<Self::Ok, Box<EvalAltResult>> {
         Ok(Dynamic::from(v))
     }