Fixed comments. Implemented node paths. Fixed exports reading. Added …

…new tests. All tests have been passed.

src/GDShrapt.Reader.Tests/AssertHelper.cs

@@ -4,7 +4,7 @@ namespace GDShrapt.Reader.Tests
 {
     public static class AssertHelper
     {
-        internal static void CompareStrings(string s1, string s2)
+        internal static void CompareCodeStrings(string s1, string s2)
         {
             Assert.AreEqual(
                 s1.Replace("\r", "").Replace("    ", "\t"), 

src/GDShrapt.Reader.Tests/GDShrapt.Reader.Tests.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
     <PackageReference Include="MSTest.TestAdapter" Version="2.1.1" />
     <PackageReference Include="MSTest.TestFramework" Version="2.1.1" />

src/GDShrapt.Reader.Tests/SyntaxTests.cs

@@ -1,4 +1,6 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Linq;
 
 namespace GDShrapt.Reader.Tests
 {
@@ -41,7 +43,36 @@ func get_recognized_extensions(res): # func comment
             var @class = reader.ParseFileContent(code);
 
             Assert.IsNotNull(@class);
-            AssertHelper.CompareStrings(code, @class.ToString());
+
+            var comments = @class.AllTokens
+                .OfType<GDComment>()
+                .Select(x => x.ToString())
+                .ToArray();
+
+            Assert.AreEqual(17, comments.Length);
+
+            comments.Should().BeEquivalentTo(new[]
+            {
+                "# before tool comment",
+                "# tool comment",
+                "# before class name comment",
+                "# class name comment",
+                "# before extends comment",
+                "# extends comment",
+                "# before const comment",
+                "# const comment",
+                "# before func comment 1",
+                "# before func comment 2",
+                "# func comment",
+                "# before if statement comment",
+                "# if expression comment",
+                "# before return statement comment",
+                "# if true statement comment",
+                "# end file comment 1",
+                "# end file comment 2"
+            });
+
+            AssertHelper.CompareCodeStrings(code, @class.ToString());
         }
 
         [TestMethod]
@@ -63,7 +94,48 @@ enum { a, # a comment
             var @class = reader.ParseFileContent(code);
 
             Assert.IsNotNull(@class);
-            AssertHelper.CompareStrings(code, @class.ToString());
+
+            var comments = @class.AllTokens
+               .OfType<GDComment>()
+               .Select(x => x.ToString())
+               .ToArray();
+
+            Assert.AreEqual(8, comments.Length);
+
+            comments.Should().BeEquivalentTo(new[]
+            {
+                "# before enum comment",
+                "# a comment",
+                "# before b comment",
+                "# b comment",
+                "# before c comment",
+                "# c comment}",
+                "# after c comment",
+                "# enum ending comment"
+            });
+
+            AssertHelper.CompareCodeStrings(code, @class.ToString());
+        }
+
+        [TestMethod]
+        public void DictionaryCodeStyleTest()
+        {
+            var reader = new GDScriptReader();
+
+            var code = @"
+{
+a: 0,
+""1"": x # : x [1,2,3] + d = l
+    f + d = lkj  :[1,2,3]
+# : xa: 0, 
+}";
+
+            var expression = reader.ParseExpression(code);
+            Assert.IsNotNull(expression);
+            Assert.IsInstanceOfType(expression, typeof(GDDictionaryInitializerExpression));
+            Assert.AreEqual(3, ((GDDictionaryInitializerExpression)expression).KeyValues.Count);
+            Assert.AreEqual(2, expression.AllTokens.OfType<GDComment>().Count());
+            AssertHelper.CompareCodeStrings(code, "\n"+expression.ToString());
         }
     }
 }

src/GDShrapt.Reader/Basics/GDNode.cs

@@ -7,7 +7,7 @@ namespace GDShrapt.Reader
     /// <summary>
     /// Basic GDScript node, may contains multiple tokens
     /// </summary>
-    public abstract partial class GDNode : GDSyntaxToken, IStyleTokensReceiver
+    public abstract class GDNode : GDSyntaxToken, IStyleTokensReceiver
     {
         internal abstract GDTokensForm Form { get; }
 
@@ -17,19 +17,36 @@ public IEnumerable<GDSyntaxToken> AllTokens
         {
             get
             {
-                foreach (var token in Tokens)
+                foreach (var token in Form)
                 {
                     if (token is GDNode node)
                     {
                         foreach (var nodeToken in node.AllTokens)
-                            yield return token;
+                            yield return nodeToken;
                     }
                     else
                         yield return token;
                 }
             }
         }
 
+        public IEnumerable<GDNode> AllNodes
+        {
+            get
+            {
+                foreach (var token in Form)
+                {
+                    if (token is GDNode node)
+                    {
+                        yield return node;
+
+                        foreach (var nodeToken in node.AllNodes)
+                            yield return nodeToken;
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Removes child node or does nothing if node is already removed.
         /// </summary>

src/GDShrapt.Reader/Declarations/GDEnumValueDeclaration.cs

@@ -13,19 +13,16 @@ public GDIdentifier Identifier
             get => _form.Token0;
             set => _form.Token0 = value;
         }
-
         internal GDColon Colon
         {
             get => (GDColon)_form.Token1;
             set => _form.Token1 = value;
         }
-
         internal GDAssign Assign
         {
             get => (GDAssign)_form.Token1;
             set => _form.Token1 = value;
         }
-
         public GDExpression Value
         {
             get => _form.Token2;

src/GDShrapt.Reader/Declarations/GDExportDeclaration.cs

@@ -43,27 +43,23 @@ public GDExportDeclaration()
 
         internal override void HandleChar(char c, GDReadingState state)
         {
-            if (IsSpace(c))
-            {
-                _form.AddBeforeActiveToken(state.Push(new GDSpace()));
-                state.PassChar(c);
-                return;
-            }
-
             switch (_form.State)
             {
                 case State.Export:
-                    this.ResolveKeyword(c, state);
+                    if (!this.ResolveStyleToken(c, state))
+                        this.ResolveKeyword(c, state);
                     break;
                 case State.OpenBracket:
-                    this.ResolveOpenBracket(c, state);
+                    if (!this.ResolveStyleToken(c, state))
+                        this.ResolveOpenBracket(c, state);
                     break;
                 case State.Parameters:
                     _form.State = State.CloseBracket;
                     state.PushAndPass(Parameters, c);
                     break;
                 case State.CloseBracket:
-                    this.ResolveCloseBracket(c, state);
+                    if (!this.ResolveStyleToken(c, state))
+                        this.ResolveCloseBracket(c, state);
                     break;
                 default:
                     state.PopAndPass(c);
@@ -73,6 +69,13 @@ internal override void HandleChar(char c, GDReadingState state)
 
         internal override void HandleNewLineChar(GDReadingState state)
         {
+            if (_form.State == State.Parameters)
+            {
+                _form.State = State.CloseBracket;
+                state.PushAndPassNewLine(Parameters);
+                return;
+            }
+
             state.PopAndPassNewLine();
         }