Implement C# Generation and Runtime

.circleci/config.yml

@@ -44,17 +44,21 @@ jobs:
           name: Setup Additional Languages
           command: |
             sudo apt-get update && sudo apt-get upgrade -y
-            sudo apt-get install python3-all-dev python3-pip python3-numpy clang llvm default-jdk
+            sudo apt-get install -y apt-transport-https python3-all-dev python3-pip python3-numpy clang llvm default-jdk
             python3 -m pip install pyre-check
             curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash
             export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
             [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm
             nvm install v12.18.0
             echo 'export NVM_DIR="$HOME/.nvm"' >> $BASH_ENV
             echo '[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"' >> $BASH_ENV
+            wget https://packages.microsoft.com/config/debian/10/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
+            sudo dpkg -i packages-microsoft-prod.deb
+            sudo apt-get update
+            sudo apt-get install -y dotnet-sdk-2.1
       - run:
           name: Version Information
-          command: rustc --version; cargo --version; rustup --version; python3 --version; clang++ --version; javac -version; go version; echo "node $(node -v)"; echo "npm $(npm -v)"
+          command: rustc --version; cargo --version; rustup --version; python3 --version; clang++ --version; javac -version; go version; echo "node $(node -v)"; echo "npm $(npm -v)"; dotnet --list-sdks
       - run:
           name: Setup Env
           command: |

.gitignore

@@ -4,3 +4,6 @@ __pycache__
 .class
 .o
 .idea
+obj/
+bin/
+.vs/

serde-generate/Cargo.toml

@@ -30,6 +30,7 @@ bincode = { version = "1.3.1" }
 libra-canonical-serialization = { version = "0.1.0" }
 
 [dev-dependencies]
+lazy_static = "1"
 tempfile = "3.1"
 hex = "0.4.2"
 which = "4.0.2"

serde-generate/runtime/csharp/Serde.Tests/Serde.Tests.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard1.6</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+
+    <LangVersion>7.2</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.16.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Serde\Serde.csproj" />
+  </ItemGroup>
+
+</Project>

serde-generate/runtime/csharp/Serde.Tests/TestLcs.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Numerics;
+using NUnit.Framework;
+using Serde.Lcs;
+
+namespace Serde.Tests
+{
+    public class TestLcs
+    {
+        [Test]
+        public void TestSerializeU128()
+        {
+            LcsSerializer serializer = new LcsSerializer();
+            serializer.serialize_u128((BigInteger.One << 128) - 1);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 });
+
+            serializer = new LcsSerializer();
+            serializer.serialize_u128(BigInteger.One);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
+
+            serializer = new LcsSerializer();
+            serializer.serialize_u128(BigInteger.Zero);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => serializer.serialize_u128(BigInteger.MinusOne));
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => serializer.serialize_u128((BigInteger.One << 128) + 1));
+        }
+
+        [Test]
+        public void TestSerializeI128()
+        {
+            LcsSerializer serializer = new LcsSerializer();
+            serializer.serialize_i128(BigInteger.MinusOne);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 });
+
+            serializer = new LcsSerializer();
+            serializer.serialize_i128(BigInteger.One);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
+
+            serializer = new LcsSerializer();
+            serializer.serialize_i128((BigInteger.One << 127) - 1);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127 });
+
+            serializer = new LcsSerializer();
+            serializer.serialize_i128(-(BigInteger.One << 127));
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80 });
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => serializer.serialize_i128(BigInteger.One << 127));
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => serializer.serialize_i128(-((BigInteger.One << 127) + 1)));
+        }
+
+        [Test]
+        public void TestSliceOrdering()
+        {
+            LcsSerializer serializer = new LcsSerializer();
+            serializer.serialize_u8(255);
+            serializer.serialize_u32(1);
+            serializer.serialize_u32(1);
+            serializer.serialize_u32(2);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 255, /**/ 1, /**/ 0, 0, /**/ 0, 1, 0, /**/ 0, /**/ 0, /**/ 2, 0, 0, 0 });
+
+            int[] offsets = { 1, 2, 4, 7, 8, 9 };
+            serializer.sort_map_entries(offsets);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 255, /**/ 0, /**/ 0, /**/ 0, 0, /**/ 0, 1, 0,  /**/ 1, /**/ 2, 0, 0, 0 });
+        }
+
+        [Test]
+        public void TestULEB128Encoding()
+        {
+            LcsSerializer serializer = new LcsSerializer();
+            serializer.serialize_len(0);
+            serializer.serialize_len(1);
+            serializer.serialize_len(127);
+            serializer.serialize_len(128);
+            serializer.serialize_len(3000);
+            CollectionAssert.AreEqual(serializer.get_bytes(), new byte[] { 0, 1, 127, 128, 1, 184, 23 });
+        }
+    }
+}

serde-generate/runtime/csharp/Serde/BinaryDeserializer.cs

@@ -0,0 +1,143 @@
+// Copyright (c) Facebook, Inc. and its affiliates
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+using System;
+using System.Collections.Immutable;
+using System.IO;
+using System.Numerics;
+using System.Text;
+
+namespace Serde
+{
+    public abstract class BinaryDeserializer : IDeserializer, IDisposable
+    {
+        protected readonly ArraySegment<byte> input;
+        protected readonly BinaryReader reader;
+        protected readonly Encoding utf8 = Encoding.GetEncoding("utf-8", new EncoderExceptionFallback(), new DecoderExceptionFallback());
+        private long containerDepthBudget;
+
+        public BinaryDeserializer(byte[] _input, long maxContainerDepth) : this(new ArraySegment<byte>(_input), maxContainerDepth) { }
+
+        public BinaryDeserializer(ArraySegment<byte> _input, long maxContainerDepth)
+        {
+            input = _input;
+            reader = new BinaryReader(new MemoryStream(input.Array, input.Offset, input.Count));
+            containerDepthBudget = maxContainerDepth;
+        }
+
+        public void Dispose() => reader.Dispose();
+
+        public int get_buffer_offset() => (int)reader.BaseStream.Position;
+
+        public abstract long deserialize_len();
+        public abstract int deserialize_variant_index();
+        public abstract void check_that_key_slices_are_increasing(Range key1, Range key2);
+
+        public char deserialize_char() => throw new DeserializationException("Not implemented: char deserialization");
+
+        public float deserialize_f32() => reader.ReadSingle();
+
+        public double deserialize_f64() => reader.ReadDouble();
+
+        public void increase_container_depth()
+        {
+            if (containerDepthBudget == 0)
+            {
+                throw new DeserializationException("Exceeded maximum container depth");
+            }
+            containerDepthBudget -= 1;
+        }
+
+        public void decrease_container_depth()
+        {
+            containerDepthBudget += 1;
+        }
+
+        public string deserialize_str()
+        {
+            long len = deserialize_len();
+            if (len < 0 || len > int.MaxValue)
+            {
+                throw new DeserializationException("Incorrect length value for C# string");
+            }
+            byte[] content = reader.ReadBytes((int)len);
+            if (content.Length < len)
+                throw new DeserializationException($"Need {len - content.Length} more bytes for string");
+            return utf8.GetString(content);
+        }
+
+        public ImmutableArray<byte> deserialize_bytes()
+        {
+            long len = deserialize_len();
+            if (len < 0 || len > int.MaxValue)
+            {
+                throw new DeserializationException("Incorrect length value for C# array");
+            }
+            byte[] content = reader.ReadBytes((int)len);
+            if (content.Length < len)
+                throw new DeserializationException($"Need {len - content.Length} more bytes for byte array");
+            return ImmutableArray.CreateRange<byte>(content);
+        }
+
+        public bool deserialize_bool()
+        {
+            byte value = reader.ReadByte();
+            switch (value)
+            {
+                case 0: return false;
+                case 1: return true;
+                default: throw new DeserializationException("Incorrect value for bool: " + value);
+            }
+        }
+
+        public Unit deserialize_unit() => new Unit();
+
+        public byte deserialize_u8() => reader.ReadByte();
+
+        public ushort deserialize_u16() => reader.ReadUInt16();
+
+        public uint deserialize_u32() => reader.ReadUInt32();
+
+        public ulong deserialize_u64() => reader.ReadUInt64();
+
+        public BigInteger deserialize_u128()
+        {
+            BigInteger signed = deserialize_i128();
+            if (signed >= 0)
+            {
+                return signed;
+            }
+            else
+            {
+                return signed + (BigInteger.One << 128);
+            }
+        }
+
+        public sbyte deserialize_i8() => reader.ReadSByte();
+
+        public short deserialize_i16() => reader.ReadInt16();
+
+        public int deserialize_i32() => reader.ReadInt32();
+
+        public long deserialize_i64() => reader.ReadInt64();
+
+        public BigInteger deserialize_i128()
+        {
+            byte[] content = reader.ReadBytes(16);
+            if (content.Length < 16)
+                throw new DeserializationException("Need more bytes to deserialize 128-bit integer");
+            return new BigInteger(content);
+        }
+
+        public bool deserialize_option_tag()
+        {
+            byte value = reader.ReadByte();
+            switch (value)
+            {
+                case 0: return false;
+                case 1: return true;
+                default: throw new DeserializationException("Incorrect value for Option tag: " + value);
+            }
+        }
+    }
+}