Add LTokenEqualityComparer class.

Get LTokenParseTest passing.
Add docs.

Author: CXuesong

Luaon.NET/Linq/LField.cs

@@ -104,10 +104,27 @@ public override void WriteTo(LuaTableTextWriter writer)
             Value.WriteTo(writer);
         }
 
+        /// <inheritdoc />
+        internal override int GetDeepHashCode()
+        {
+            int hash = Value.GetDeepHashCode();
+            if (Name != null) hash ^= Name.GetHashCode();
+            return hash;
+        }
+
+        /// <inheritdoc />
+        internal override bool DeepEquals(LToken other)
+        {
+            var y = other as LField;
+            if (y == null) return false;
+            return DeepEquals(Name, y.Name) && DeepEquals(_Value, y._Value);
+        }
+
         /// <inheritdoc />
         public override LToken DeepClone()
         {
             return new LField(Name, Value);
         }
+
     }
 }

Luaon.NET/Linq/LTable.cs

@@ -277,6 +277,33 @@ public override void WriteTo(LuaTableTextWriter writer)
             writer.WriteEndTable();
         }
 
+        /// <inheritdoc />
+        internal override int GetDeepHashCode()
+        {
+            int hash = 0;
+            foreach (var field in store)
+            {
+                hash = unchecked(hash * 13 + field.GetDeepHashCode());
+            }
+            return hash;
+        }
+
+        /// <inheritdoc />
+        internal override bool DeepEquals(LToken other)
+        {
+            var y = other as LTable;
+            if (y == null) return false;
+            if (ReferenceEquals(this, y)) return true; 
+            if (store.Count != y.store.Count) return false;
+            var count = store.Count;
+            for (int i = 0; i < count; i++)
+            {
+                if (!DeepEquals(store[i], y.store[i]))
+                    return false;
+            }
+            return true;
+        }
+
         /// <inheritdoc />
         public override LToken DeepClone()
         {

Luaon.NET/Linq/LToken.cs

@@ -5,9 +5,19 @@
 
 namespace Luaon.Linq
 {
+    /// <summary>
+    /// Represents a token in the Lua table expression.
+    /// </summary>
     public abstract class LToken
     {
 
+        /// <summary>
+        /// Loads next <see cref="LToken"/> from the specified <see cref="LuaTableTextReader"/>.
+        /// </summary>
+        /// <param name="reader">The reader from which to load the next <see cref="LToken"/>.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="reader"/> is <c>null</c>.</exception>
+        /// <exception cref="LuaTableReaderException">There are unexpected input in the <paramref name="reader"/>.</exception>
+        /// <returns>The loaded Lua token.</returns>
         public static LToken Load(LuaTableTextReader reader)
         {
             if (reader == null) throw new ArgumentNullException(nameof(reader));
@@ -28,8 +38,16 @@ public static LToken Load(LuaTableTextReader reader)
             }
         }
 
+        /// <summary>
+        /// Parses the <see cref="LToken"/> from the specified Lua expression.
+        /// </summary>
+        /// <param name="expression">The Lua expression to be parsed.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="expression"/> is <c>null</c>.</exception>
+        /// <exception cref="LuaTableReaderException"><paramref name="expression"/> is empty or invalid; or it contains extra content after the first parsed token.</exception>
+        /// <returns>The loaded Lua token.</returns>
         public static LToken Parse(string expression)
         {
+            if (expression == null) throw new ArgumentNullException(nameof(expression));
             using (var reader = new StringReader(expression))
             using (var lreader = new LuaTableTextReader(reader))
             {
@@ -195,6 +213,18 @@ public static implicit operator LToken(string value)
 
         #endregion
 
+        internal abstract int GetDeepHashCode();
+
+        internal abstract bool DeepEquals(LToken other);
+
+        public static bool DeepEquals(LToken x, LToken y)
+        {
+            if (x == null || y == null) return x == null && y == null;
+            return x.DeepEquals(y);
+        }
+
+        #region Accessors
+
         /// <summary>
         /// Gets/sets the child token associated with the specified key.
         /// </summary>
@@ -228,6 +258,8 @@ public virtual LToken this[LValue name]
             set => throw new NotSupportedException($"Cannot access child token of {GetType()}.");
         }
 
+        #endregion
+
     }
 
     public enum LTokenType

Luaon.NET/Linq/LTokenEqualityComparer.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Luaon.Linq
+{
+    /// <summary>
+    /// Contains functionality for comparing the deep equality of <see cref="LToken"/> instances.
+    /// </summary>
+    public class LTokenEqualityComparer : IEqualityComparer<LToken>
+    {
+
+        /// <summary>
+        /// Gets an instance of <see cref="LTokenEqualityComparer"/>.
+        /// </summary>
+        public static LTokenEqualityComparer Instance { get; } = new LTokenEqualityComparer();
+
+        /// <inheritdoc />
+        public bool Equals(LToken x, LToken y)
+        {
+            return LToken.DeepEquals(x, y);
+        }
+
+        /// <inheritdoc />
+        public int GetHashCode(LToken obj)
+        {
+            if (ReferenceEquals(obj, null)) return 0;
+            return obj.GetDeepHashCode();
+        }
+
+    }
+}

Luaon.NET/Linq/LValue.cs

@@ -36,9 +36,15 @@ public class LValue : LToken, IEquatable<LValue>
                 reader.Read();
             SkipComments(reader);
             AssertReaderToken(reader, LuaTableReaderToken.Value);
-            var v = new LValue(reader.CurrentValue);
+            var rawValue = reader.CurrentValue;
             reader.Read();
-            return v;
+            if (rawValue == null)
+                return Nil;
+            if (rawValue is bool b)
+                return b ? True : False;
+            if (rawValue is int i)
+                return i;
+            return new LValue(rawValue);
         }
 
         public LValue(LValue other)
@@ -271,6 +277,20 @@ public override void WriteTo(LuaTableTextWriter writer)
             writer.WriteLiteral(Value);
         }
 
+        /// <inheritdoc />
+        internal override int GetDeepHashCode()
+        {
+            var hash = (int)TokenType;
+            if (Value != null) hash = Value.GetHashCode();
+            return hash;
+        }
+
+        /// <inheritdoc />
+        internal override bool DeepEquals(LToken other)
+        {
+            return Equals(other);
+        }
+
         /// <inheritdoc />
         public override LToken DeepClone()
         {
@@ -284,8 +304,22 @@ public bool Equals(LValue other)
             if (ReferenceEquals(this, other)) return true;
             if (TokenType != other.TokenType) return false;
             if (Equals(Value, other.Value)) return true;
-            if (TokenType == LTokenType.Integer && Value.GetType() != other.Value.GetType())
-                return Convert.ToDecimal(Value) == Convert.ToDecimal(other.Value);
+            if (TokenType == LTokenType.Integer)
+            {
+                var t1 = Value.GetType();
+                var t2 = other.Value.GetType();
+                if (t1 != t2)
+                {
+                    if (t1 == typeof(ulong) || t2 == typeof(ulong) || t1 == typeof(decimal) || t2 == typeof(decimal))
+                    {
+                        return Convert.ToDecimal(Value) == Convert.ToDecimal(other.Value);
+                    }
+                    else
+                    {
+                        return Convert.ToInt64(Value) == Convert.ToInt64(other.Value);
+                    }
+                }
+            }
             return false;
         }
 

XUnitTestProject1/Tests/LinqTests.cs

@@ -66,15 +66,25 @@ public void LTableToStringTest()
 }", table.ToString());
         }
 
+        private void AssertTokenEquals(LToken expected, LToken actual)
+        {
+            Assert.Equal(expected, actual, LTokenEqualityComparer.Instance);
+        }
+
+        private void AssertTokenEquals(LToken expected, string actual)
+        {
+            Assert.Equal(expected, LToken.Parse(actual), LTokenEqualityComparer.Instance);
+        }
+
         [Fact]
         public void LTokenParseTest()
         {
-            Assert.Equal(LValue.True, LToken.Parse("true"));
-            Assert.Equal(LValue.False, LToken.Parse("--content\nfalse\n--content"));
-            Assert.Equal(LValue.Nil, LToken.Parse("nil"));
-            Assert.Equal(new LTable { 10, 20, 30 }, LToken.Parse("{10, 20, 30}"));
-            Assert.Equal(new LTable { 10, 20, 30, new LTable { 40, 50 } }, LToken.Parse("{10, 20, 30, {40, 50}}"));
-            Assert.Equal(new LTable
+            AssertTokenEquals(LValue.True, "true");
+            AssertTokenEquals(LValue.False, "--content\nfalse\n--content");
+            AssertTokenEquals(LValue.Nil, "nil");
+            AssertTokenEquals(new LTable { 10, 20, 30 }, "{10, 20, 30}");
+            AssertTokenEquals(new LTable { 10, 20, 30, new LTable { 40, 50 } }, "{10, 20, 30, {40, 50}}");
+            AssertTokenEquals(new LTable
             {
                 {"Test1", 1},
                 2,
@@ -83,7 +93,7 @@ public void LTokenParseTest()
                 {20, 5},
                 {true, "6"},
                 {"Child", new LTable(1, 2, 3, 4, 5)}
-            }, LToken.Parse(@"{
+            }, @"{
   Test1 = 1,
   2,
   Test2 = 3,
@@ -97,7 +107,7 @@ public void LTokenParseTest()
     4,
     5
   }
-}"));
+}");
         }
 
     }