perf(syntax): Refactor syntax nodes to use ISyntaxNode interface

- Replace SyntaxNode with ISyntaxNode throughout the project - Update ExpressionSyntax and derived classes to implement ISyntaxNode - Modify constructors and methods to accommodate the new interface - Ensure consistency in method signatures using ISyntaxNode
alirezanet · Jun 22, 2024 · 82e55da · 82e55da
1 parent d3c1ed8
commit 82e55da
Show file tree

Hide file tree

Showing 14 changed files with 69 additions and 64 deletions.
diff --git a/src/Gridify.Elasticsearch/ElasticsearchQueryBuilder.cs b/src/Gridify.Elasticsearch/ElasticsearchQueryBuilder.cs
@@ -13,7  13,7 @@ internal class ElasticsearchQueryBuilder<T>(IGridifyMapper<T> mapper) : BaseQuer
    private readonly IGridifyMapper<T> _mapper = mapper;
 
    protected override Query BuildNestedQuery(
-      Expression body, IGMap<T> gMap, ValueExpressionSyntax value, SyntaxNode op)
       Expression body, IGMap<T> gMap, ValueExpressionSyntax value, ISyntaxNode op)
    {
       throw new NotSupportedException();
    }
@@ -40,7  40,7 @@ protected override object BuildQueryAccordingToValueType(
       Expression body,
       ParameterExpression parameter,
       object? value,
-      SyntaxNode op,
       ISyntaxNode op,
       ValueExpressionSyntax valueExpression)
    {
       if (valueExpression.IsCaseInsensitive)

diff --git a/src/Gridify/GridifyExtensions.cs b/src/Gridify/GridifyExtensions.cs
@@ -197,9  197,9 @@ internal static IGridifyMapper<T> FixMapper<T>(this IGridifyMapper<T>? mapper, S
       return mapper;
    }
 
-   private static IEnumerable<SyntaxNode> Descendants(this SyntaxNode root)
    private static IEnumerable<ISyntaxNode> Descendants(this ISyntaxNode root)
    {
-      var nodes = new Stack<SyntaxNode>(new[] { root });
       var nodes = new Stack<ISyntaxNode>(new[] { root });
       while (nodes.Any())
       {
          var node = nodes.Pop();

diff --git a/src/Gridify/QueryBuilders/BaseQueryBuilder.cs b/src/Gridify/QueryBuilders/BaseQueryBuilder.cs
@@ -16,7  16,7 @@ internal TQuery Build(ExpressionSyntax expression)
    }
 
    protected abstract TQuery? BuildNestedQuery(
-      Expression body, IGMap<T> gMap, ValueExpressionSyntax value, SyntaxNode op);
       Expression body, IGMap<T> gMap, ValueExpressionSyntax value, ISyntaxNode op);
 
    protected abstract TQuery BuildAlwaysTrueQuery();
 
@@ -31,7  31,7 @@ internal TQuery Build(ExpressionSyntax expression)
       Expression body,
       ParameterExpression parameter,
       object? value,
-      SyntaxNode op,
       ISyntaxNode op,
       ValueExpressionSyntax valueExpression);
 
    protected abstract TQuery CombineWithAndOperator(TQuery left, TQuery right);
@@ -157,7  157,7 @@ private static object AddIndexerNullCheck(IGMap<T> gMap, object query)
       Expression body,
       ParameterExpression parameter,
       ValueExpressionSyntax valueExpression,
-      SyntaxNode op,
       ISyntaxNode op,
       Func<string, object>? convertor)
    {
       // Remove the boxing for value types

diff --git a/src/Gridify/QueryBuilders/LinqQueryBuilder.cs b/src/Gridify/QueryBuilders/LinqQueryBuilder.cs
@@ -10,7  10,7 @@ namespace Gridify.QueryBuilders;
 internal class LinqQueryBuilder<T>(IGridifyMapper<T> mapper) : BaseQueryBuilder<Expression<Func<T, bool>>, T>(mapper)
 {
    protected override Expression<Func<T, bool>>? BuildNestedQuery(
-      Expression body, IGMap<T> gMap, ValueExpressionSyntax value, SyntaxNode op)
       Expression body, IGMap<T> gMap, ValueExpressionSyntax value, ISyntaxNode op)
    {
       while (true)
          switch (body)
@@ -105,7  105,7 @@ protected override Expression<Func<T, bool>> BuildAlwaysFalseQuery(ParameterExpr
       Expression body,
       ParameterExpression parameter,
       object? value,
-      SyntaxNode op,
       ISyntaxNode op,
       ValueExpressionSyntax valueExpression)
    {
       Expression be;
@@ -229,7  229,7 @@ protected override Expression<Func<T, bool>> BuildAlwaysFalseQuery(ParameterExpr
 
             break;
          case SyntaxKind.CustomOperator:
-            var token = op as SyntaxToken;
             var token = (SyntaxToken)op;
             var customOperator = GridifyGlobalConfiguration.CustomOperators.Operators.First(q => q.GetOperator() == token!.Text);
             var customExp = customOperator.OperatorHandler();
 
@@ -257,7  257,7 @@ protected override Expression<Func<T, bool>> CombineWithOrOperator(Expression<Fu
       return left.Or(right);
    }
 
-   private Expression<Func<T, bool>>? GenerateNestedExpression(Expression body, IGMap<T> gMap, ValueExpressionSyntax value, SyntaxNode op)
    private Expression<Func<T, bool>>? GenerateNestedExpression(Expression body, IGMap<T> gMap, ValueExpressionSyntax value, ISyntaxNode op)
    {
       while (true)
          switch (body)

diff --git a/src/Gridify/Syntax/BinaryExpressionSyntax.cs b/src/Gridify/Syntax/BinaryExpressionSyntax.cs
@@ -1,4  1,4 @@
-using System.Collections.Generic;
 using System.Collections.Generic;
 
 namespace Gridify.Syntax;
 
@@ -17,10  17,10 @@ public BinaryExpressionSyntax(ExpressionSyntax left, SyntaxToken operatorToken,
 
    public override SyntaxKind Kind => SyntaxKind.BinaryExpression;
 
-   public override IEnumerable<SyntaxNode> GetChildren()
    public override IEnumerable<ISyntaxNode> GetChildren()
    {
       yield return Left;
       yield return OperatorToken;
       yield return Right;
    }
-}
 }
diff --git a/src/Gridify/Syntax/ExpressionSyntax.cs b/src/Gridify/Syntax/ExpressionSyntax.cs
@@ -1,5  1,9 @@
-namespace Gridify.Syntax;
 using System.Collections.Generic;
 
-public abstract class ExpressionSyntax : SyntaxNode
 namespace Gridify.Syntax;
 
 public abstract class ExpressionSyntax : ISyntaxNode
 {
-}
    public abstract SyntaxKind Kind { get; }
    public abstract IEnumerable<ISyntaxNode> GetChildren();
 }
diff --git a/src/Gridify/Syntax/FieldExpressionSyntax.cs b/src/Gridify/Syntax/FieldExpressionSyntax.cs
@@ -12,7  12,7 @@ internal FieldExpressionSyntax(SyntaxToken fieldToken, string? indexer = default
 
    public override SyntaxKind Kind => SyntaxKind.FieldExpression;
 
-   public override IEnumerable<SyntaxNode> GetChildren()
    public override IEnumerable<ISyntaxNode> GetChildren()
    {
       yield return FieldToken;
    }

diff --git a/src/Gridify/Syntax/ISyntaxNode.cs b/src/Gridify/Syntax/ISyntaxNode.cs
@@ -0,0  1,9 @@
 using System.Collections.Generic;
 
 namespace Gridify.Syntax;
 
 public interface ISyntaxNode
 {
    public SyntaxKind Kind { get; }
    public IEnumerable<ISyntaxNode> GetChildren();
 }
diff --git a/src/Gridify/Syntax/Lexer.cs b/src/Gridify/Syntax/Lexer.cs
@@ -192,7  192,7 @@ private bool TryParseIndexer(char peek, out SyntaxToken nextToken)
       return false;
    }
 
-   private bool TryToReadTheValue(out SyntaxToken? valueToken)
    private bool TryToReadTheValue(out SyntaxToken valueToken)
    {
       if (_waitingForValue)
       {
@@ -249,7  249,7 @@ private bool TryToReadTheValue(out SyntaxToken? valueToken)
          }
       }
 
-      valueToken = null;
       valueToken = new SyntaxToken();
       return false;
    }
 

diff --git a/src/Gridify/Syntax/ParenthesizedExpressionSyntax.cs b/src/Gridify/Syntax/ParenthesizedExpressionSyntax.cs
@@ -1,4  1,4 @@
-using System.Collections.Generic;
 using System.Collections.Generic;
 
 namespace Gridify.Syntax;
 
@@ -7,18  7,18 @@ internal sealed class ParenthesizedExpressionSyntax : ExpressionSyntax
    public SyntaxToken OpenParenthesisToken { get; }
    public ExpressionSyntax Expression { get; }
    public SyntaxToken CloseParenthesisToken { get; }
-   public override SyntaxKind Kind  => SyntaxKind.ParenthesizedExpression;
    public override SyntaxKind Kind => SyntaxKind.ParenthesizedExpression;
 
-   public ParenthesizedExpressionSyntax(SyntaxToken openParenthesisToken,ExpressionSyntax expression,SyntaxToken closeParenthesisToken)
    public ParenthesizedExpressionSyntax(SyntaxToken openParenthesisToken, ExpressionSyntax expression, SyntaxToken closeParenthesisToken)
    {
       OpenParenthesisToken = openParenthesisToken;
       Expression = expression;
       CloseParenthesisToken = closeParenthesisToken;
    }
-   public override IEnumerable<SyntaxNode> GetChildren()
    public override IEnumerable<ISyntaxNode> GetChildren()
    {
       yield return OpenParenthesisToken;
       yield return Expression;
       yield return CloseParenthesisToken;
    }
-}
 }
diff --git a/src/Gridify/Syntax/Parser.cs b/src/Gridify/Syntax/Parser.cs
@@ -3,10  3,10 @@
 
 namespace Gridify.Syntax;
 
-internal class Parser
 internal struct Parser
 {
-   private readonly List<string> _diagnostics = new();
-   private readonly SyntaxToken[] _tokens;
    private List<string>? _diagnostics = null;
    private readonly List<SyntaxToken> _tokens = [];
    private int _position;
 
    private static bool IsOperator(SyntaxKind kind)
@@ -28,32  28,31 @@ SyntaxKind.NotEndsWith or
 
    public Parser(string text, IEnumerable<IGridifyOperator> customOperators)
    {
-      var tokens = new List<SyntaxToken>();
       var lexer = new Lexer(text, customOperators);
       SyntaxToken token;
       do
       {
          token = lexer.NextToken();
-         if (token.Kind != SyntaxKind.WhiteSpace) tokens.Add(token);
          if (token.Kind != SyntaxKind.WhiteSpace) _tokens.Add(token);
       } while (token.Kind != SyntaxKind.End);
 
-      _tokens = tokens.ToArray();
-      _diagnostics.AddRange(lexer.Diagnostics);
       if (lexer.Diagnostics.Any())
          AddDiagnostics(lexer.Diagnostics);
    }
 
    private SyntaxToken Current => Peek(0);
 
    private SyntaxToken Peek(int offset)
    {
       var index = _position   offset;
-      return index >= _tokens.Length ? _tokens[_tokens.Length - 1] : _tokens[index];
       return index >= _tokens.Count ? _tokens[_tokens.Count - 1] : _tokens[index];
    }
 
    public SyntaxTree Parse()
    {
       var expression = ParseTerm();
       var end = Match(SyntaxKind.End, GetExpectation(expression.Kind));
-      return new SyntaxTree(_diagnostics, expression, end);
       return new SyntaxTree(_diagnostics ?? Enumerable.Empty<string>(), expression, end);
    }
 
    private SyntaxKind GetExpectation(SyntaxKind kind)
@@ -141,8  140,8 @@ private SyntaxToken Match(SyntaxKind kind, SyntaxKind? expectation = null)
 
       expectation ??= kind;
 
-      if (!_diagnostics.Any(q => q.StartsWith("Unexpected token")))
-         _diagnostics.Add($"Unexpected token <{Current.Kind}> at index {Current.Position}, expected <{expectation}>");
       if (_diagnostics != null && !_diagnostics.Any(q => q.StartsWith("Unexpected token")))
          AddDiagnostics($"Unexpected token <{Current.Kind}> at index {Current.Position}, expected <{expectation}>");
 
       return new SyntaxToken(kind, Current.Position, Current.Text);
    }
@@ -165,4  164,14 @@ private ExpressionSyntax ParseFieldExpression()
          ? new FieldExpressionSyntax(fieldToken, fieldIndexer.Text)
          : new FieldExpressionSyntax(fieldToken);
    }
    private void AddDiagnostics(string message)
    {
       _diagnostics ??= [];
       _diagnostics.Add(message);
    }
    private void AddDiagnostics(IEnumerable<string> messages)
    {
       _diagnostics ??= [];
       _diagnostics.AddRange(messages);
    }
 }
diff --git a/src/Gridify/Syntax/SyntaxNode.cs b/src/Gridify/Syntax/SyntaxNode.cs
diff --git a/src/Gridify/Syntax/SyntaxToken.cs b/src/Gridify/Syntax/SyntaxToken.cs
@@ -3,26  3,18 @@
 
 namespace Gridify.Syntax;
 
-public class SyntaxToken : SyntaxNode
 public struct SyntaxToken(SyntaxKind kind, int position, string text) : ISyntaxNode
 {
-   public override SyntaxKind Kind { get; }
-   public int Position { get; }
-   public string Text { get; }
    public int Position { get; } = position;
    public string Text { get; } = text;
    public SyntaxKind Kind { get; } = kind;
 
-   public override IEnumerable<SyntaxNode> GetChildren()
    public IEnumerable<ISyntaxNode> GetChildren()
    {
-      return Enumerable.Empty<SyntaxNode>();
       return Enumerable.Empty<ISyntaxNode>();
    }
 
-   public SyntaxToken(SyntaxKind kind, int position, string text)
    public SyntaxToken() : this(SyntaxKind.End, 0, string.Empty)
    {
-      Kind = kind;
-      Position = position;
-      Text = text;
-   }
-
-   public SyntaxToken()
-   {
-      Text = string.Empty;
    }
 }
diff --git a/src/Gridify/Syntax/ValueExpressionSyntax.cs b/src/Gridify/Syntax/ValueExpressionSyntax.cs
@@ -1,10  1,10 @@
-using System.Collections.Generic;
 using System.Collections.Generic;
 
 namespace Gridify.Syntax;
 
 internal sealed class ValueExpressionSyntax : ExpressionSyntax
 {
-   public ValueExpressionSyntax(SyntaxToken valueToken,bool isCaseInsensitive, bool isNullOrDefault)
    public ValueExpressionSyntax(SyntaxToken valueToken, bool isCaseInsensitive, bool isNullOrDefault)
    {
       ValueToken = valueToken;
       IsCaseInsensitive = isCaseInsensitive;
@@ -13,12  13,12 @@ public ValueExpressionSyntax(SyntaxToken valueToken,bool isCaseInsensitive, bool
 
    public override SyntaxKind Kind => SyntaxKind.ValueExpression;
 
-   public override IEnumerable<SyntaxNode> GetChildren()
    public override IEnumerable<ISyntaxNode> GetChildren()
    {
       yield return ValueToken;
    }
 
    public SyntaxToken ValueToken { get; }
    public bool IsCaseInsensitive { get; }
    public bool IsNullOrDefault { get; }
-}
 }