Dotnet change uint to long (#295)

karthiknadig · web-flow · commit b2adefc3831a · 2023-11-16T14:17:43.000-08:00
Closes #255
diff --git a/generator/plugins/dotnet/custom/OrTypeConverter.cs b/generator/plugins/dotnet/custom/OrTypeConverter.cs
@@ -37,7 +37,7 @@ public class OrTypeConverter<T, U> : JsonConverter<OrType<T, U>>
 
         Type[] types = new Type[] { typeof(T), typeof(U) };
 
-        if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(uint)) || Validators.HasType(types, typeof(int))))
+        if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(long)) || Validators.HasType(types, typeof(int))))
         {
             return ReadIntegerToken(reader, serializer, types);
         }
@@ -61,15 +61,15 @@ public class OrTypeConverter<T, U> : JsonConverter<OrType<T, U>>
     private static OrType<T, U> ReadIntegerToken(JsonReader reader, JsonSerializer serializer, Type[] types)
     {
         long integer = serializer.Deserialize<long>(reader);
-        if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(uint)))
+        if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(long)))
         {
-            if (typeof(T) == typeof(uint))
+            if (typeof(T) == typeof(long))
             {
-                return new OrType<T, U>((T)(object)(uint)integer);
+                return new OrType<T, U>((T)(object)(long)integer);
             }
-            if (typeof(U) == typeof(uint))
+            if (typeof(U) == typeof(long))
             {
-                return new OrType<T, U>((U)(object)(uint)integer);
+                return new OrType<T, U>((U)(object)(long)integer);
             }
         }
         if (Validators.InIntegerRange(integer) && Validators.HasType(types, typeof(int)))
@@ -83,7 +83,7 @@ private static OrType<T, U> ReadIntegerToken(JsonReader reader, JsonSerializer s
                 return new OrType<T, U>((U)(object)(int)integer);
             }
         }
-        throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{uint.MinValue}:{uint.MaxValue}] => {integer}");
+        throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{long.MinValue}:{long.MaxValue}] => {integer}");
     }
 
     private static OrType<T, U> ReadFloatToken(JsonReader reader, JsonSerializer serializer, Type[] types)
@@ -136,9 +136,9 @@ private static OrType<T, U> ReadObjectToken(JToken token, JsonSerializer seriali
             try
             {
                 object? value = null;
-                if (token.Type == JTokenType.Array && type == typeof((uint, uint)))
+                if (token.Type == JTokenType.Array && type == typeof((long, long)))
                 {
-                    uint[]? o = token.ToObject<uint[]>(serializer);
+                    long[]? o = token.ToObject<long[]>(serializer);
                     if (o != null)
                     {
                         value = (o[0], o[1]);
@@ -179,10 +179,10 @@ public override void WriteJson(JsonWriter writer, OrType<T, U>? value, JsonSeria
         {
             writer.WriteNull();
         }
-        else if (value?.Value?.GetType() == typeof((uint, uint)))
+        else if (value?.Value?.GetType() == typeof((long, long)))
         {
-            ValueTuple<uint, uint> o = (ValueTuple<uint, uint>)(value.Value);
-            serializer.Serialize(writer, new uint[] { o.Item1, o.Item2 });
+            ValueTuple<long, long> o = (ValueTuple<long, long>)(value.Value);
+            serializer.Serialize(writer, new long[] { o.Item1, o.Item2 });
         }
         else
         {
@@ -204,7 +204,7 @@ public class OrTypeConverter<T, U, V> : JsonConverter<OrType<T, U, V>>
 
         Type[] types = new Type[] { typeof(T), typeof(U), typeof(V) };
 
-        if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(uint)) || Validators.HasType(types, typeof(int))))
+        if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(long)) || Validators.HasType(types, typeof(int))))
         {
             return ReadIntegerToken(reader, serializer, types);
         }
@@ -228,19 +228,19 @@ public class OrTypeConverter<T, U, V> : JsonConverter<OrType<T, U, V>>
     private static OrType<T, U, V> ReadIntegerToken(JsonReader reader, JsonSerializer serializer, Type[] types)
     {
         long integer = serializer.Deserialize<long>(reader);
-        if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(uint)))
+        if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(long)))
         {
-            if (typeof(T) == typeof(uint))
+            if (typeof(T) == typeof(long))
             {
-                return new OrType<T, U, V>((T)(object)(uint)integer);
+                return new OrType<T, U, V>((T)(object)(long)integer);
             }
-            if (typeof(U) == typeof(uint))
+            if (typeof(U) == typeof(long))
             {
-                return new OrType<T, U, V>((U)(object)(uint)integer);
+                return new OrType<T, U, V>((U)(object)(long)integer);
             }
-            if (typeof(V) == typeof(uint))
+            if (typeof(V) == typeof(long))
             {
-                return new OrType<T, U, V>((V)(object)(uint)integer);
+                return new OrType<T, U, V>((V)(object)(long)integer);
             }
         }
         if (Validators.InIntegerRange(integer) && Validators.HasType(types, typeof(int)))
@@ -258,7 +258,7 @@ private static OrType<T, U, V> ReadIntegerToken(JsonReader reader, JsonSerialize
                 return new OrType<T, U, V>((V)(object)(int)integer);
             }
         }
-        throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{uint.MinValue}:{uint.MaxValue}] => {integer}");
+        throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{long.MinValue}:{long.MaxValue}] => {integer}");
     }
 
     private static OrType<T, U, V> ReadFloatToken(JsonReader reader, JsonSerializer serializer, Type[] types)
@@ -323,9 +323,9 @@ private static OrType<T, U, V> ReadObjectToken(JToken token, JsonSerializer seri
             try
             {
                 object? value = null;
-                if (token.Type == JTokenType.Array && type == typeof((uint, uint)))
+                if (token.Type == JTokenType.Array && type == typeof((long, long)))
                 {
-                    uint[]? o = token.ToObject<uint[]>(serializer);
+                    long[]? o = token.ToObject<long[]>(serializer);
                     if (o != null)
                     {
                         value = (o[0], o[1]);
@@ -368,10 +368,10 @@ public override void WriteJson(JsonWriter writer, OrType<T, U, V>? value, JsonSe
         {
             writer.WriteNull();
         }
-        else if (value?.Value?.GetType() == typeof((uint, uint)))
+        else if (value?.Value?.GetType() == typeof((long, long)))
         {
-            ValueTuple<uint, uint> o = (ValueTuple<uint, uint>)(value.Value);
-            serializer.Serialize(writer, new uint[] { o.Item1, o.Item2 });
+            ValueTuple<long, long> o = (ValueTuple<long, long>)(value.Value);
+            serializer.Serialize(writer, new long[] { o.Item1, o.Item2 });
         }
         else
         {
@@ -393,7 +393,7 @@ public class OrTypeConverter<T, U, V, W> : JsonConverter<OrType<T, U, V, W>>
 
         Type[] types = new Type[] { typeof(T), typeof(U), typeof(V), typeof(W) };
 
-        if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(uint)) || Validators.HasType(types, typeof(int))))
+        if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(long)) || Validators.HasType(types, typeof(int))))
         {
             return ReadIntegerToken(reader, serializer, types);
         }
@@ -417,23 +417,23 @@ public class OrTypeConverter<T, U, V, W> : JsonConverter<OrType<T, U, V, W>>
     private static OrType<T, U, V, W> ReadIntegerToken(JsonReader reader, JsonSerializer serializer, Type[] types)
     {
         long integer = serializer.Deserialize<long>(reader);
-        if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(uint)))
+        if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(long)))
         {
-            if (typeof(T) == typeof(uint))
+            if (typeof(T) == typeof(long))
             {
-                return new OrType<T, U, V, W>((T)(object)(uint)integer);
+                return new OrType<T, U, V, W>((T)(object)(long)integer);
             }
-            if (typeof(U) == typeof(uint))
+            if (typeof(U) == typeof(long))
             {
-                return new OrType<T, U, V, W>((U)(object)(uint)integer);
+                return new OrType<T, U, V, W>((U)(object)(long)integer);
             }
-            if (typeof(V) == typeof(uint))
+            if (typeof(V) == typeof(long))
             {
-                return new OrType<T, U, V, W>((V)(object)(uint)integer);
+                return new OrType<T, U, V, W>((V)(object)(long)integer);
             }
-            if (typeof(W) == typeof(uint))
+            if (typeof(W) == typeof(long))
             {
-                return new OrType<T, U, V, W>((W)(object)(uint)integer);
+                return new OrType<T, U, V, W>((W)(object)(long)integer);
             }
         }
         if (Validators.InIntegerRange(integer) && Validators.HasType(types, typeof(int)))
@@ -455,7 +455,7 @@ private static OrType<T, U, V, W> ReadIntegerToken(JsonReader reader, JsonSerial
                 return new OrType<T, U, V, W>((W)(object)(int)integer);
             }
         }
-        throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{uint.MinValue}:{uint.MaxValue}] => {integer}");
+        throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{long.MinValue}:{long.MaxValue}] => {integer}");
     }
 
     private static OrType<T, U, V, W> ReadFloatToken(JsonReader reader, JsonSerializer serializer, Type[] types)
@@ -532,9 +532,9 @@ private static OrType<T, U, V, W> ReadObjectToken(JToken token, JsonSerializer s
             try
             {
                 object? value = null;
-                if (token.Type == JTokenType.Array && type == typeof((uint, uint)))
+                if (token.Type == JTokenType.Array && type == typeof((long, long)))
                 {
-                    uint[]? o = token.ToObject<uint[]>(serializer);
+                    long[]? o = token.ToObject<long[]>(serializer);
                     if (o != null)
                     {
                         value = (o[0], o[1]);
@@ -582,10 +582,10 @@ public override void WriteJson(JsonWriter writer, OrType<T, U, V, W>? value, Jso
         {
             writer.WriteNull();
         }
-        else if (value?.Value?.GetType() == typeof((uint, uint)))
+        else if (value?.Value?.GetType() == typeof((long, long)))
         {
-            ValueTuple<uint, uint> o = (ValueTuple<uint, uint>)(value.Value);
-            serializer.Serialize(writer, new uint[] { o.Item1, o.Item2 });
+            ValueTuple<long, long> o = (ValueTuple<long, long>)(value.Value);
+            serializer.Serialize(writer, new long[] { o.Item1, o.Item2 });
         }
         else
         {
diff --git a/generator/plugins/dotnet/custom/Validators.cs b/generator/plugins/dotnet/custom/Validators.cs
@@ -17,4 +17,24 @@ public static bool InUIntegerRange(long value)
     {
         return value >= uint.MinValue && value <= uint.MaxValue;
     }
+
+    public static long? validUInteger(long? value){
+        if(value == null){
+            return null;
+        }
+
+        if (Validators.InUIntegerRange((long)value))
+        {
+            return value;
+        }
+        throw new ArgumentOutOfRangeException("value", value, "Value is not in the range of LSP uinteger");
+    }
+
+    public static long validUInteger(long value){
+        if (Validators.InUIntegerRange(value))
+        {
+            return value;
+        }
+        throw new ArgumentOutOfRangeException("value", value, "Value is not in the range of LSP uinteger");
+    }
 }
diff --git a/generator/plugins/dotnet/dotnet_classes.py b/generator/plugins/dotnet/dotnet_classes.py
@@ -60,7 +60,7 @@ def lsp_to_base_types(lsp_type: model.BaseType):
     elif lsp_type.name in ["integer"]:
         return "int"
     elif lsp_type.name in ["uinteger"]:
-        return "uint"
+        return "long"
     elif lsp_type.name in ["boolean"]:
         return "bool"
     elif lsp_type.name in ["null"]:
@@ -250,6 +250,12 @@ def generate_property(
         lines.append(
             f'public {type_name}{optional} {name} {{ get; init; }} = "{prop_def.type.value}";'
         )
+    elif prop_def.type.kind == "base" and prop_def.type.name == "uinteger":
+        private_name = f"_{prop_def.name}" if prop_def.name == name else prop_def.name
+        lines.append(
+            f"public {type_name}{optional} {name} {{ get => {private_name}; set => {private_name} = Validators.validUInteger(value); }}"
+        )
+        lines.append(f"private {type_name}{optional} {private_name};")
     else:
         lines.append(f"public {type_name}{optional} {name} {{ get; init; }}")
 

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public class OrTypeConverter<T, U> : JsonConverter<OrType<T, U>>`
`37`	`37`
`38`	`38`	`Type[] types = new Type[] { typeof(T), typeof(U) };`
`39`	`39`
`40`		`- if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(uint)) \|\| Validators.HasType(types, typeof(int))))`
	`40`	`+ if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(long)) \|\| Validators.HasType(types, typeof(int))))`
`41`	`41`	`{`
`42`	`42`	`return ReadIntegerToken(reader, serializer, types);`
`43`	`43`	`}`
`@@ -61,15 +61,15 @@ public class OrTypeConverter<T, U> : JsonConverter<OrType<T, U>>`
`61`	`61`	`private static OrType<T, U> ReadIntegerToken(JsonReader reader, JsonSerializer serializer, Type[] types)`
`62`	`62`	`{`
`63`	`63`	`long integer = serializer.Deserialize<long>(reader);`
`64`		`- if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(uint)))`
	`64`	`+ if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(long)))`
`65`	`65`	`{`
`66`		`- if (typeof(T) == typeof(uint))`
	`66`	`+ if (typeof(T) == typeof(long))`
`67`	`67`	`{`
`68`		`- return new OrType<T, U>((T)(object)(uint)integer);`
	`68`	`+ return new OrType<T, U>((T)(object)(long)integer);`
`69`	`69`	`}`
`70`		`- if (typeof(U) == typeof(uint))`
	`70`	`+ if (typeof(U) == typeof(long))`
`71`	`71`	`{`
`72`		`- return new OrType<T, U>((U)(object)(uint)integer);`
	`72`	`+ return new OrType<T, U>((U)(object)(long)integer);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`if (Validators.InIntegerRange(integer) && Validators.HasType(types, typeof(int)))`
`@@ -83,7 +83,7 @@ private static OrType<T, U> ReadIntegerToken(JsonReader reader, JsonSerializer s`
`83`	`83`	`return new OrType<T, U>((U)(object)(int)integer);`
`84`	`84`	`}`
`85`	`85`	`}`
`86`		`- throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{uint.MinValue}:{uint.MaxValue}] => {integer}");`
	`86`	`+ throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{long.MinValue}:{long.MaxValue}] => {integer}");`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`private static OrType<T, U> ReadFloatToken(JsonReader reader, JsonSerializer serializer, Type[] types)`
`@@ -136,9 +136,9 @@ private static OrType<T, U> ReadObjectToken(JToken token, JsonSerializer seriali`
`136`	`136`	`try`
`137`	`137`	`{`
`138`	`138`	`object? value = null;`
`139`		`- if (token.Type == JTokenType.Array && type == typeof((uint, uint)))`
	`139`	`+ if (token.Type == JTokenType.Array && type == typeof((long, long)))`
`140`	`140`	`{`
`141`		`- uint[]? o = token.ToObject<uint[]>(serializer);`
	`141`	`+ long[]? o = token.ToObject<long[]>(serializer);`
`142`	`142`	`if (o != null)`
`143`	`143`	`{`
`144`	`144`	`value = (o[0], o[1]);`
`@@ -179,10 +179,10 @@ public override void WriteJson(JsonWriter writer, OrType<T, U>? value, JsonSeria`
`179`	`179`	`{`
`180`	`180`	`writer.WriteNull();`
`181`	`181`	`}`
`182`		`- else if (value?.Value?.GetType() == typeof((uint, uint)))`
	`182`	`+ else if (value?.Value?.GetType() == typeof((long, long)))`
`183`	`183`	`{`
`184`		`- ValueTuple<uint, uint> o = (ValueTuple<uint, uint>)(value.Value);`
`185`		`- serializer.Serialize(writer, new uint[] { o.Item1, o.Item2 });`
	`184`	`+ ValueTuple<long, long> o = (ValueTuple<long, long>)(value.Value);`
	`185`	`+ serializer.Serialize(writer, new long[] { o.Item1, o.Item2 });`
`186`	`186`	`}`
`187`	`187`	`else`
`188`	`188`	`{`
`@@ -204,7 +204,7 @@ public class OrTypeConverter<T, U, V> : JsonConverter<OrType<T, U, V>>`
`204`	`204`
`205`	`205`	`Type[] types = new Type[] { typeof(T), typeof(U), typeof(V) };`
`206`	`206`
`207`		`- if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(uint)) \|\| Validators.HasType(types, typeof(int))))`
	`207`	`+ if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(long)) \|\| Validators.HasType(types, typeof(int))))`
`208`	`208`	`{`
`209`	`209`	`return ReadIntegerToken(reader, serializer, types);`
`210`	`210`	`}`
`@@ -228,19 +228,19 @@ public class OrTypeConverter<T, U, V> : JsonConverter<OrType<T, U, V>>`
`228`	`228`	`private static OrType<T, U, V> ReadIntegerToken(JsonReader reader, JsonSerializer serializer, Type[] types)`
`229`	`229`	`{`
`230`	`230`	`long integer = serializer.Deserialize<long>(reader);`
`231`		`- if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(uint)))`
	`231`	`+ if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(long)))`
`232`	`232`	`{`
`233`		`- if (typeof(T) == typeof(uint))`
	`233`	`+ if (typeof(T) == typeof(long))`
`234`	`234`	`{`
`235`		`- return new OrType<T, U, V>((T)(object)(uint)integer);`
	`235`	`+ return new OrType<T, U, V>((T)(object)(long)integer);`
`236`	`236`	`}`
`237`		`- if (typeof(U) == typeof(uint))`
	`237`	`+ if (typeof(U) == typeof(long))`
`238`	`238`	`{`
`239`		`- return new OrType<T, U, V>((U)(object)(uint)integer);`
	`239`	`+ return new OrType<T, U, V>((U)(object)(long)integer);`
`240`	`240`	`}`
`241`		`- if (typeof(V) == typeof(uint))`
	`241`	`+ if (typeof(V) == typeof(long))`
`242`	`242`	`{`
`243`		`- return new OrType<T, U, V>((V)(object)(uint)integer);`
	`243`	`+ return new OrType<T, U, V>((V)(object)(long)integer);`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`	`if (Validators.InIntegerRange(integer) && Validators.HasType(types, typeof(int)))`
`@@ -258,7 +258,7 @@ private static OrType<T, U, V> ReadIntegerToken(JsonReader reader, JsonSerialize`
`258`	`258`	`return new OrType<T, U, V>((V)(object)(int)integer);`
`259`	`259`	`}`
`260`	`260`	`}`
`261`		`- throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{uint.MinValue}:{uint.MaxValue}] => {integer}");`
	`261`	`+ throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{long.MinValue}:{long.MaxValue}] => {integer}");`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`private static OrType<T, U, V> ReadFloatToken(JsonReader reader, JsonSerializer serializer, Type[] types)`
`@@ -323,9 +323,9 @@ private static OrType<T, U, V> ReadObjectToken(JToken token, JsonSerializer seri`
`323`	`323`	`try`
`324`	`324`	`{`
`325`	`325`	`object? value = null;`
`326`		`- if (token.Type == JTokenType.Array && type == typeof((uint, uint)))`
	`326`	`+ if (token.Type == JTokenType.Array && type == typeof((long, long)))`
`327`	`327`	`{`
`328`		`- uint[]? o = token.ToObject<uint[]>(serializer);`
	`328`	`+ long[]? o = token.ToObject<long[]>(serializer);`
`329`	`329`	`if (o != null)`
`330`	`330`	`{`
`331`	`331`	`value = (o[0], o[1]);`
`@@ -368,10 +368,10 @@ public override void WriteJson(JsonWriter writer, OrType<T, U, V>? value, JsonSe`
`368`	`368`	`{`
`369`	`369`	`writer.WriteNull();`
`370`	`370`	`}`
`371`		`- else if (value?.Value?.GetType() == typeof((uint, uint)))`
	`371`	`+ else if (value?.Value?.GetType() == typeof((long, long)))`
`372`	`372`	`{`
`373`		`- ValueTuple<uint, uint> o = (ValueTuple<uint, uint>)(value.Value);`
`374`		`- serializer.Serialize(writer, new uint[] { o.Item1, o.Item2 });`
	`373`	`+ ValueTuple<long, long> o = (ValueTuple<long, long>)(value.Value);`
	`374`	`+ serializer.Serialize(writer, new long[] { o.Item1, o.Item2 });`
`375`	`375`	`}`
`376`	`376`	`else`
`377`	`377`	`{`
`@@ -393,7 +393,7 @@ public class OrTypeConverter<T, U, V, W> : JsonConverter<OrType<T, U, V, W>>`
`393`	`393`
`394`	`394`	`Type[] types = new Type[] { typeof(T), typeof(U), typeof(V), typeof(W) };`
`395`	`395`
`396`		`- if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(uint)) \|\| Validators.HasType(types, typeof(int))))`
	`396`	`+ if (reader.TokenType == JsonToken.Integer && (Validators.HasType(types, typeof(long)) \|\| Validators.HasType(types, typeof(int))))`
`397`	`397`	`{`
`398`	`398`	`return ReadIntegerToken(reader, serializer, types);`
`399`	`399`	`}`
`@@ -417,23 +417,23 @@ public class OrTypeConverter<T, U, V, W> : JsonConverter<OrType<T, U, V, W>>`
`417`	`417`	`private static OrType<T, U, V, W> ReadIntegerToken(JsonReader reader, JsonSerializer serializer, Type[] types)`
`418`	`418`	`{`
`419`	`419`	`long integer = serializer.Deserialize<long>(reader);`
`420`		`- if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(uint)))`
	`420`	`+ if (Validators.InUIntegerRange(integer) && Validators.HasType(types, typeof(long)))`
`421`	`421`	`{`
`422`		`- if (typeof(T) == typeof(uint))`
	`422`	`+ if (typeof(T) == typeof(long))`
`423`	`423`	`{`
`424`		`- return new OrType<T, U, V, W>((T)(object)(uint)integer);`
	`424`	`+ return new OrType<T, U, V, W>((T)(object)(long)integer);`
`425`	`425`	`}`
`426`		`- if (typeof(U) == typeof(uint))`
	`426`	`+ if (typeof(U) == typeof(long))`
`427`	`427`	`{`
`428`		`- return new OrType<T, U, V, W>((U)(object)(uint)integer);`
	`428`	`+ return new OrType<T, U, V, W>((U)(object)(long)integer);`
`429`	`429`	`}`
`430`		`- if (typeof(V) == typeof(uint))`
	`430`	`+ if (typeof(V) == typeof(long))`
`431`	`431`	`{`
`432`		`- return new OrType<T, U, V, W>((V)(object)(uint)integer);`
	`432`	`+ return new OrType<T, U, V, W>((V)(object)(long)integer);`
`433`	`433`	`}`
`434`		`- if (typeof(W) == typeof(uint))`
	`434`	`+ if (typeof(W) == typeof(long))`
`435`	`435`	`{`
`436`		`- return new OrType<T, U, V, W>((W)(object)(uint)integer);`
	`436`	`+ return new OrType<T, U, V, W>((W)(object)(long)integer);`
`437`	`437`	`}`
`438`	`438`	`}`
`439`	`439`	`if (Validators.InIntegerRange(integer) && Validators.HasType(types, typeof(int)))`
`@@ -455,7 +455,7 @@ private static OrType<T, U, V, W> ReadIntegerToken(JsonReader reader, JsonSerial`
`455`	`455`	`return new OrType<T, U, V, W>((W)(object)(int)integer);`
`456`	`456`	`}`
`457`	`457`	`}`
`458`		`- throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{uint.MinValue}:{uint.MaxValue}] => {integer}");`
	`458`	`+ throw new ArgumentOutOfRangeException($"Integer out-of-range of LSP Signed Integer[{int.MinValue}:{int.MaxValue}] and out-of-range of LSP Unsigned Integer [{long.MinValue}:{long.MaxValue}] => {integer}");`
`459`	`459`	`}`
`460`	`460`
`461`	`461`	`private static OrType<T, U, V, W> ReadFloatToken(JsonReader reader, JsonSerializer serializer, Type[] types)`
`@@ -532,9 +532,9 @@ private static OrType<T, U, V, W> ReadObjectToken(JToken token, JsonSerializer s`
`532`	`532`	`try`
`533`	`533`	`{`
`534`	`534`	`object? value = null;`
`535`		`- if (token.Type == JTokenType.Array && type == typeof((uint, uint)))`
	`535`	`+ if (token.Type == JTokenType.Array && type == typeof((long, long)))`
`536`	`536`	`{`
`537`		`- uint[]? o = token.ToObject<uint[]>(serializer);`
	`537`	`+ long[]? o = token.ToObject<long[]>(serializer);`
`538`	`538`	`if (o != null)`
`539`	`539`	`{`
`540`	`540`	`value = (o[0], o[1]);`
`@@ -582,10 +582,10 @@ public override void WriteJson(JsonWriter writer, OrType<T, U, V, W>? value, Jso`
`582`	`582`	`{`
`583`	`583`	`writer.WriteNull();`
`584`	`584`	`}`
`585`		`- else if (value?.Value?.GetType() == typeof((uint, uint)))`
	`585`	`+ else if (value?.Value?.GetType() == typeof((long, long)))`
`586`	`586`	`{`
`587`		`- ValueTuple<uint, uint> o = (ValueTuple<uint, uint>)(value.Value);`
`588`		`- serializer.Serialize(writer, new uint[] { o.Item1, o.Item2 });`
	`587`	`+ ValueTuple<long, long> o = (ValueTuple<long, long>)(value.Value);`
	`588`	`+ serializer.Serialize(writer, new long[] { o.Item1, o.Item2 });`
`589`	`589`	`}`
`590`	`590`	`else`
`591`	`591`	`{`