#59 - переход на IReadOnlyList

src/HydraScript.Lib/FrontEnd/GetTokens/Data/Token.cs

@@ -31,6 +31,9 @@ public record Segment(Coordinates Start, Coordinates End)
 
     public static Segment operator +(Segment left, Segment right) => 
         new(left.Start, right.End);
+
+    public static implicit operator string(Segment segment) =>
+        segment.ToString();
 }
 
 [ExcludeFromCodeCoverage]

src/HydraScript.Lib/FrontEnd/TopDownParse/Impl/Parser.cs

@@ -492,7 +492,10 @@ private Expression ConditionalExpression()
             var consequent = Expression();
             Expect("Colon");
             var alternate = Expression();
-            return new ConditionalExpression(test, consequent, alternate);
+            return new ConditionalExpression(test, consequent, alternate)
+            {
+                Segment = consequent.Segment + alternate.Segment
+            };
         }
 
         return test;

src/HydraScript.Lib/IR/Ast/AbstractSyntaxTreeNode.cs

@@ -1,37 +1,46 @@
 using System.Collections;
-using HydraScript.Lib.FrontEnd.GetTokens.Data;
 using HydraScript.Lib.IR.CheckSemantics.Variables;
 
 namespace HydraScript.Lib.IR.Ast;
 
 public abstract class AbstractSyntaxTreeNode :
-    IEnumerable<AbstractSyntaxTreeNode>,
+    IReadOnlyList<AbstractSyntaxTreeNode>,
     IVisitable<AbstractSyntaxTreeNode>
 {
-    public AbstractSyntaxTreeNode? Parent { get; set; }
+    public AbstractSyntaxTreeNode Parent { get; set; } = default!;
+
+    protected virtual bool IsRoot => false;
 
     public SymbolTable SymbolTable { get; set; } = default!;
 
-    public Segment Segment { get; init; } = default!;
+    public string Segment { get; init; } = string.Empty;
+
+    protected virtual IReadOnlyList<AbstractSyntaxTreeNode> Children { get; } = [];
+
+    public IEnumerator<AbstractSyntaxTreeNode> GetEnumerator() =>
+        Children.ToList().GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() =>
+        GetEnumerator();
+
+    public int Count => Children.Count;
+
+    public AbstractSyntaxTreeNode this[int index] =>
+        Children[index];
 
     internal List<AbstractSyntaxTreeNode> GetAllNodes()
     {
-        var result = new List<AbstractSyntaxTreeNode>
-        {
-            this
-        };
-        foreach (var child in this)
-        {
-            result.AddRange(child.GetAllNodes());
-        }
+        List<AbstractSyntaxTreeNode> result = [this];
+        for (var index = 0; index < Children.Count; index++)
+            result.AddRange(Children[index].GetAllNodes());
 
         return result;
     }
 
     public bool ChildOf<T>() where T : AbstractSyntaxTreeNode
     {
         var parent = Parent;
-        while (parent != null)
+        while (!parent.IsRoot)
         {
             if (parent is T)
             {
@@ -44,11 +53,6 @@ public bool ChildOf<T>() where T : AbstractSyntaxTreeNode
         return false;
     }
 
-    public abstract IEnumerator<AbstractSyntaxTreeNode> GetEnumerator();
-
-    IEnumerator IEnumerable.GetEnumerator() =>
-        GetEnumerator();
-
     public virtual TReturn Accept<TReturn>(IVisitor<AbstractSyntaxTreeNode, TReturn> visitor) =>
         visitor.DefaultVisit;
 

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Declarations/AfterTypesAreLoaded/FunctionDeclaration.cs

@@ -6,7 +6,7 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Declarations.AfterTypesAreLoaded;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class FunctionDeclaration : AfterTypesAreLoadedDeclaration
 {
-    private IReadOnlyCollection<ReturnStatement>? _returnStatements;
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children => [Statements];
 
     public IdentifierReference Name { get; }
     public TypeValue ReturnTypeValue { get; }
@@ -25,25 +25,18 @@ public FunctionDeclaration(
 
         Statements = blockStatement;
         Statements.Parent = this;
-    }
-
-    public bool HasReturnStatement()
-    {
-        _returnStatements ??= GetReturnStatements();
-        return _returnStatements.Count > 0;
-    }
 
-    public IReadOnlyCollection<ReturnStatement> GetReturnStatements() =>
-        _returnStatements ??= Statements
+        ReturnStatements = Statements
             .GetAllNodes()
             .OfType<ReturnStatement>()
             .ToArray();
-
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator()
-    {
-        yield return Statements;
     }
 
+    public bool HasReturnStatement() =>
+        ReturnStatements.Count > 0;
+
+    public IReadOnlyCollection<ReturnStatement> ReturnStatements { get; }
+
     protected override string NodeRepresentation() =>
         "function " + Name;
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Declarations/AfterTypesAreLoaded/LexicalDeclaration.cs

@@ -5,18 +5,20 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Declarations.AfterTypesAreLoaded;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class LexicalDeclaration(bool readOnly) : AfterTypesAreLoadedDeclaration
 {
+    private readonly List<AssignmentExpression> _assignments = [];
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children =>
+        _assignments;
+
     public bool ReadOnly { get; } = readOnly;
-    public List<AssignmentExpression> Assignments { get; } = [];
+    public IReadOnlyList<AssignmentExpression> Assignments =>
+        _assignments;
 
     public void AddAssignment(AssignmentExpression assignment)
     {
         assignment.Parent = this;
-        Assignments.Add(assignment);
+        _assignments.Add(assignment);
     }
 
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator() =>
-        Assignments.GetEnumerator();
-
     protected override string NodeRepresentation() =>
         ReadOnly ? "const" : "let";
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Declarations/TypeDeclaration.cs

@@ -3,25 +3,13 @@
 namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Declarations;
 
 [AutoVisitable<AbstractSyntaxTreeNode>]
-public partial class TypeDeclaration : Declaration
+public partial class TypeDeclaration(IdentifierReference typeId, TypeValue typeValue) : Declaration
 {
-    private readonly TypeValue _typeValue;
-    public IdentifierReference TypeId { get; }
-
-    public TypeDeclaration(IdentifierReference typeId, TypeValue typeValue)
-    {
-        TypeId = typeId;
-        _typeValue = typeValue;
-    }
+    public IdentifierReference TypeId { get; } = typeId;
 
     public Type BuildType() =>
-        _typeValue.BuildType(SymbolTable);
-
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator()
-    {
-        yield break;
-    }
+        typeValue.BuildType(SymbolTable);
 
     protected override string NodeRepresentation() =>
-        $"type {TypeId.Name} = {_typeValue}";
+        $"type {TypeId.Name} = {typeValue}";
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Expressions/AccessExpressions/DotAccess.cs

@@ -5,6 +5,9 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Expressions.AccessExpressions;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class DotAccess : AccessExpression
 {
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children =>
+        HasNext() ? [Property, Next!] : [Property];
+
     public IdentifierReference Property { get; }
 
     public DotAccess(IdentifierReference property, AccessExpression? prev = null) : base(prev)
@@ -13,14 +16,5 @@ public DotAccess(IdentifierReference property, AccessExpression? prev = null) :
         Property.Parent = this;
     }
 
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator()
-    {
-        yield return Property;
-        if (HasNext())
-        {
-            yield return Next!;
-        }
-    }
-
     protected override string NodeRepresentation() => ".";
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Expressions/AccessExpressions/IndexAccess.cs

@@ -3,6 +3,9 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Expressions.AccessExpressions;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class IndexAccess : AccessExpression
 {
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children =>
+        HasNext() ? [Index, Next!] : [Index];
+
     public Expression Index { get; }
 
     public IndexAccess(Expression index, AccessExpression? prev = null) : base(prev)
@@ -11,14 +14,5 @@ public IndexAccess(Expression index, AccessExpression? prev = null) : base(prev)
         Index.Parent = this;
     }
 
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator()
-    {
-        yield return Index;
-        if (HasNext())
-        {
-            yield return Next!;
-        }
-    }
-
     protected override string NodeRepresentation() => "[]";
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Expressions/AssignmentExpression.cs

@@ -5,6 +5,9 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Expressions;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class AssignmentExpression : Expression
 {
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children =>
+        [Destination, Source];
+
     public LeftHandSideExpression Destination { get; }
     public Expression Source { get; }
     public TypeValue? DestinationType { get; }
@@ -23,11 +26,5 @@ public AssignmentExpression(
         DestinationType = destinationType;
     }
 
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator()
-    {
-        yield return Destination;
-        yield return Source;
-    }
-
     protected override string NodeRepresentation() => "=";
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Expressions/BinaryExpression.cs

@@ -3,6 +3,9 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Expressions;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class BinaryExpression : Expression
 {
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children =>
+        [Left, Right];
+
     public Expression Left { get; }
     public string Operator { get; }
     public Expression Right { get; }
@@ -18,11 +21,5 @@ public BinaryExpression(Expression left, string @operator, Expression right)
         Right.Parent = this;
     }
 
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator()
-    {
-        yield return Left;
-        yield return Right;
-    }
-
     protected override string NodeRepresentation() => Operator;
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Expressions/CallExpression.cs

@@ -5,33 +5,26 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Expressions;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class CallExpression : LeftHandSideExpression
 {
+    private readonly List<Expression> _parameters;
+
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children =>
+        [Member, .._parameters];
+
     public MemberExpression Member { get; }
-    public List<Expression> Parameters { get; }
+    public IReadOnlyList<Expression> Parameters => _parameters;
 
     public CallExpression(MemberExpression member, IEnumerable<Expression> expressions)
     {
         Member = member;
         Member.Parent = this;
 
-        Parameters = new List<Expression>(expressions);
-        Parameters.ForEach(expr => expr.Parent = this);
+        _parameters = new List<Expression>(expressions);
+        _parameters.ForEach(expr => expr.Parent = this);
     }
 
-    public override IdentifierReference Id =>
-        Member.Id;
-
-    public override bool Empty() =>
-        Member.Empty();
+    public override IdentifierReference Id => Member.Id;
 
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator()
-    {
-        var nodes = new List<AbstractSyntaxTreeNode>
-        {
-            Member
-        };
-        nodes.AddRange(Parameters);
-        return nodes.GetEnumerator();
-    }
+    public override bool Empty() => Member.Empty();
 
     protected override string NodeRepresentation() => "()";
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Expressions/CastAsExpression.cs

@@ -5,6 +5,9 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Expressions;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class CastAsExpression : Expression
 {
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children =>
+        [Expression];
+
     public Expression Expression { get; }
     public TypeValue Cast { get; }
 
@@ -16,10 +19,5 @@ public CastAsExpression(Expression expression, TypeValue cast)
         Cast = cast;
     }
 
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator()
-    {
-        yield return Expression;
-    }
-
     protected override string NodeRepresentation() => $"as {Cast}";
 }

src/HydraScript.Lib/IR/Ast/Impl/Nodes/Expressions/ComplexLiterals/ArrayLiteral.cs

@@ -3,16 +3,18 @@ namespace HydraScript.Lib.IR.Ast.Impl.Nodes.Expressions.ComplexLiterals;
 [AutoVisitable<AbstractSyntaxTreeNode>]
 public partial class ArrayLiteral : ComplexLiteral
 {
-    public List<Expression> Expressions { get; }
+    private readonly List<Expression> _expressions;
+
+    protected override IReadOnlyList<AbstractSyntaxTreeNode> Children =>
+        _expressions;
+
+    public IReadOnlyList<Expression> Expressions => _expressions;
 
     public ArrayLiteral(IEnumerable<Expression> expressions)
     {
-        Expressions = new List<Expression>(expressions);
-        Expressions.ForEach(expr => expr.Parent = this);
+        _expressions = new List<Expression>(expressions);
+        _expressions.ForEach(expr => expr.Parent = this);
     }
 
-    public override IEnumerator<AbstractSyntaxTreeNode> GetEnumerator() =>
-        Expressions.GetEnumerator();
-
     protected override string NodeRepresentation() => "[]";
 }