[Proto] Partially implemented deserialization for ProtoPackable<T>

Author: Linwenxuan04

Lagrange.Proto.Generator/ProtoSourceGenerator.Emitter.TypeInfo.cs

@@ -1,3 +1,4 @@
+using Microsoft.CodeAnalysis.CSharp;
 using SF = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using SK = Microsoft.CodeAnalysis.CSharp.SyntaxKind;
 
@@ -51,6 +52,11 @@ private MethodDeclarationSyntax EmitTypeInfoCreationMethod()
                                 ]
                             )
                         ))
+                        .WithInitializer(SF.InitializerExpression(SK.ObjectInitializerExpression).AddExpressions(
+                                SF.AssignmentExpression(SK.SimpleAssignmentExpression, SF.IdentifierName("Get"), EmitTypeInfoGetter(kv.Value.Name)),
+                                SF.AssignmentExpression(SK.SimpleAssignmentExpression, SF.IdentifierName("Set"), EmitTypeInfoSetter(kv.Value.Name))
+                                )
+                    )
                 );
                 var dictionaryInitialize = SF.ObjectCreationExpression(SF.ParseTypeName("global::System.Collections.Generic.Dictionary<int, global::Lagrange.Proto.Serialization.Metadata.ProtoFieldInfo>"))
                     .WithArgumentList(SF.ArgumentList())
@@ -76,6 +82,26 @@ private MethodDeclarationSyntax EmitTypeInfoCreationMethod()
                     .AddModifiers(SF.Token(SK.PrivateKeyword), SF.Token(SK.StaticKeyword))
                     .WithBody(SF.Block(returnStatement));
             }
+            
+            private ExpressionSyntax EmitTypeInfoGetter(string prop)
+            {
+                var cast = SF.CastExpression(SF.ParseTypeName(parser.Identifier), SF.IdentifierName("obj"));
+                var access = SF.MemberAccessExpression(SK.SimpleMemberAccessExpression, SF.ParenthesizedExpression(cast), SF.IdentifierName(prop));
+
+                return SF.SimpleLambdaExpression(SF.Parameter(SF.Identifier("obj")), access);
+            }
+        
+            private ExpressionSyntax EmitTypeInfoSetter(string prop)
+            {
+                var parameters = SF.ParameterList().AddParameters(SF.Parameter(SF.Identifier("obj")), SF.Parameter(SF.Identifier("value")));
+                var cast = SF.CastExpression(SF.ParseTypeName(parser.Identifier), SF.IdentifierName("obj"));
+                var left = SF.MemberAccessExpression(SK.SimpleMemberAccessExpression, SF.ParenthesizedExpression(cast), SF.IdentifierName(prop));
+                var right = SF.IdentifierName("value");
+            
+                return SF.ParenthesizedLambdaExpression(parameters,
+                    SF.AssignmentExpression(SK.SimpleAssignmentExpression, left, right)
+                );
+            }
         }
     }
 }

Lagrange.Proto/Lagrange.Proto.csproj

@@ -14,7 +14,22 @@
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="Serialization\Metadata\" />
+      <Folder Include="Serialization\Converter\Collection\" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <None Update="Serialization\Metadata\ProtoTypeResolver.WellKnownTypes.tt">
+        <Generator>TextTemplatingFileGenerator</Generator>
+        <LastGenOutput>ProtoTypeResolver.WellKnownTypes.cs</LastGenOutput>
+      </None>
+    </ItemGroup>
+
+    <ItemGroup>
+      <Compile Update="Serialization\Metadata\ProtoTypeResolver.WellKnownTypes.cs">
+        <AutoGen>True</AutoGen>
+        <DesignTime>True</DesignTime>
+        <DependentUpon>ProtoTypeResolver.WellKnownTypes.tt</DependentUpon>
+      </Compile>
     </ItemGroup>
 
 </Project>

Lagrange.Proto/Primitives/ProtoReader.cs

@@ -23,6 +23,8 @@ public ref struct ProtoReader
     private static readonly Vector128<ulong> Shift4 = Vector128.Create(2ul, 1ul);
 
     private static readonly Vector128<sbyte> Ascend = Vector128.Create(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+    
+    public bool IsCompleted => _offset == _length;
 
     public ProtoReader(ReadOnlySpan<byte> src)
     {

Lagrange.Proto/Serialization/Converter/Generic/ProtoNullableConverter.cs

@@ -7,15 +7,13 @@ internal class ProtoNullableConverter<T> : ProtoConverter<T?> where T : struct
 {
     private readonly ProtoConverter<T> _converter = ProtoTypeResolver.GetConverter<T>();
 
-    public override WireType WireType => _converter.WireType;
-    
-    public override void Write(int field, ProtoWriter writer, T? value)
+    public override void Write(int field, WireType wireType, ProtoWriter writer, T? value)
     {
-        if (value.HasValue) _converter.Write(0, writer, value.Value);
+        if (value.HasValue) _converter.Write(0, wireType, writer, value.Value);
     }
 
-    public override T? Read(int field, ref ProtoReader reader)
+    public override T? Read(int field, WireType wireType, ref ProtoReader reader)
     {
-        return _converter.Read(field, ref reader);
+        return _converter.Read(field, wireType, ref reader);
     }
 }

Lagrange.Proto/Serialization/Converter/Object/ProtoSerializableConverter.cs

@@ -0,0 +1,20 @@
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter.Object;
+
+internal class ProtoSerializableConverter<T> : ProtoConverter<T> where T : IProtoSerializable<T>
+{
+    public override void Write(int field, WireType wireType, ProtoWriter writer, T value)
+    {
+        int length = T.MeasureHandler(value);
+        writer.EncodeVarInt(length);
+        if (length > 0) T.SerializeHandler(value, writer);
+    }
+
+    public override T Read(int field, WireType wireType, ref ProtoReader reader)
+    {
+        int length = reader.DecodeVarInt<int>();
+        var span = reader.CreateSpan(length);
+        return ProtoSerializer.DeserializeProtoPackable<T>(span);
+    }
+}

Lagrange.Proto/Serialization/Converter/Value/ProtoBooleanConverter.cs

@@ -5,14 +5,12 @@ namespace Lagrange.Proto.Serialization.Converter;
 
 internal class ProtoBooleanConverter : ProtoConverter<bool>
 {
-    public override WireType WireType => WireType.VarInt;
-    
-    public override void Write(int field, ProtoWriter writer, bool value)
+    public override void Write(int field, WireType wireType, ProtoWriter writer, bool value)
     {
         writer.WriteRawByte(Unsafe.As<bool, byte>(ref value));
     }
 
-    public override bool Read(int field, ref ProtoReader reader)
+    public override bool Read(int field, WireType wireType, ref ProtoReader reader)
     {
         byte b = reader.DecodeVarInt<byte>();
         return Unsafe.As<byte, bool>(ref b);

Lagrange.Proto/Serialization/Converter/Value/ProtoBytesConverter.cs

@@ -4,15 +4,13 @@ namespace Lagrange.Proto.Serialization.Converter;
 
 public class ProtoBytesConverter : ProtoConverter<byte[]>
 {
-    public override WireType WireType => WireType.LengthDelimited;
-    
-    public override void Write(int field, ProtoWriter writer, byte[] value)
+    public override void Write(int field, WireType wireType, ProtoWriter writer, byte[] value)
     {
         writer.EncodeVarInt(value.Length);
         writer.WriteRawBytes(value);
     }
 
-    public override byte[] Read(int field, ref ProtoReader reader)
+    public override byte[] Read(int field, WireType wireType, ref ProtoReader reader)
     {
         int length = reader.DecodeVarInt<int>();
         if (length == 0) return [];

Lagrange.Proto/Serialization/Converter/Value/ProtoFixed32Converter.cs

@@ -0,0 +1,36 @@
+using System.Numerics;
+using Lagrange.Proto.Primitives;
+
+namespace Lagrange.Proto.Serialization.Converter;
+
+internal class ProtoNumberConverter<T> : ProtoConverter<T> where T : unmanaged, INumber<T>
+{
+    public override void Write(int field, WireType wireType, ProtoWriter writer, T value)
+    {
+        switch (wireType)
+        {
+            case WireType.Fixed32:
+                writer.EncodeFixed32<T>(value);
+                break;
+            case WireType.Fixed64:
+                writer.EncodeFixed64<T>(value);
+                break;
+            case WireType.VarInt:
+                writer.EncodeVarInt<T>(value);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(wireType), wireType, null);
+        }
+    }
+
+    public override T Read(int field, WireType wireType, ref ProtoReader reader)
+    {
+        return wireType switch
+        {
+            WireType.Fixed32 => reader.DecodeFixed32<T>(),
+            WireType.Fixed64 => reader.DecodeFixed64<T>(),
+            WireType.VarInt => reader.DecodeVarInt<T>(),
+            _ => throw new ArgumentOutOfRangeException(nameof(wireType), wireType, null)
+        };
+    }
+}