#170 - ZLinq (#183)

Stepami · web-flow · commit d2d7311ae2e5 · 2025-09-27T01:57:05.000+03:00
* remove unused properties * remove Where from lexer * #170 - Structure is read-only list * #170 - zlinq
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -14,6 +14,7 @@
     <PackageVersion Include="System.IO.Abstractions" Version="22.0.16" />
     <PackageVersion Include="Visitor.NET" Version="4.2.0" />
     <PackageVersion Include="Visitor.NET.AutoVisitableGen" Version="1.5.2" />
+    <PackageVersion Include="ZLinq" Version="1.5.2" />
     <PackageVersion Include="ZLogger" Version="2.5.10" />
     <PackageVersion Include="ZString" Version="2.6.0" />
   </ItemGroup>
diff --git a/benchmarks/Readme.md b/benchmarks/Readme.md
@@ -10,4 +10,4 @@ Job=InProcess  Toolchain=InProcessEmitToolchain
 ```
 | Method |     Mean |     Error |    StdDev |     Gen0 |     Gen1 | Allocated |
 |--------|---------:|----------:|----------:|---------:|---------:|----------:|
-| Invoke | 8.748 ms | 0.1720 ms | 0.2574 ms | 828.1250 | 343.7500 |  10.06 MB |
+| Invoke | 8.369 ms | 0.1315 ms | 0.1230 ms | 812.5000 | 218.7500 |   9.79 MB |
diff --git a/src/Application/HydraScript.Application.CodeGeneration/Visitors/ExpressionInstructionProvider.cs b/src/Application/HydraScript.Application.CodeGeneration/Visitors/ExpressionInstructionProvider.cs
@@ -12,6 +12,7 @@
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.AccessExpressions;
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.ComplexLiterals;
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.PrimaryExpressions;
+using ZLinq;
 
 namespace HydraScript.Application.CodeGeneration.Visitors;
 
@@ -75,9 +76,11 @@ public AddressedInstructions Visit(ObjectLiteral visitable)
 
         var result = new AddressedInstructions { createObject };
 
-        result.AddRange(visitable.Properties
-            .SelectMany(property =>
-                property.Accept(This)));
+        var propInstructions =
+            visitable.Properties.AsValueEnumerable()
+                .SelectMany(property => property.Accept(This));
+        foreach (var propInstruction in propInstructions)
+            result.Add(propInstruction);
 
         return result;
     }
@@ -278,8 +281,9 @@ public AddressedInstructions Visit(CallExpression visitable)
             result.Add(new PushParameter(new Name(caller)));
         }
 
-        foreach (var expr in visitable.Parameters)
+        for (var i = 0; i < visitable.Parameters.Count; i++)
         {
+            var expr = visitable.Parameters[i];
             if (expr is PrimaryExpression primary)
                 result.Add(new PushParameter(_valueDtoConverter.Convert(primary.ToValueDto())));
             else
diff --git a/src/Application/HydraScript.Application.CodeGeneration/Visitors/InstructionProvider.cs b/src/Application/HydraScript.Application.CodeGeneration/Visitors/InstructionProvider.cs
@@ -11,6 +11,7 @@
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.PrimaryExpressions;
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Statements;
 using Microsoft.Extensions.DependencyInjection;
+using ZLinq;
 
 namespace HydraScript.Application.CodeGeneration.Visitors;
 
@@ -168,7 +169,8 @@ public AddressedInstructions Visit(WhileStatement visitable)
         }
 
         result.AddRange(visitable.Statement.Accept(This));
-        result.OfType<Goto>().Where(g => g.JumpType is not null)
+        result.AsValueEnumerable()
+            .OfType<Goto>().Where(g => g.JumpType is not null)
             .ToList().ForEach(g =>
             {
                 // ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault
@@ -220,7 +222,8 @@ public AddressedInstructions Visit(IfStatement visitable)
         if (visitable.HasElseBlock())
             result.AddRange(visitable.Else?.Accept(This) ?? []);
 
-        result.OfType<Goto>().Where(g => g.JumpType is InsideStatementJumpType.Break)
+        result.AsValueEnumerable()
+            .OfType<Goto>().Where(g => g.JumpType is InsideStatementJumpType.Break)
             .ToList().ForEach(g => g.SetJump(endBlockLabel));
 
         result.Add(new EndBlock(BlockType.Condition, blockId), endBlockLabel.Name);
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Impl/FunctionWithUndefinedReturnStorage.cs b/src/Application/HydraScript.Application.StaticAnalysis/Impl/FunctionWithUndefinedReturnStorage.cs
@@ -8,10 +8,8 @@ internal class FunctionWithUndefinedReturnStorage : IFunctionWithUndefinedReturn
 {
     private readonly OrderedDictionary<FunctionSymbolId, FunctionDeclaration> _declarations = [];
 
-    public void Save(FunctionSymbol symbol, FunctionDeclaration declaration)
-    {
+    public void Save(FunctionSymbol symbol, FunctionDeclaration declaration) =>
         _declarations[symbol.Id] = declaration;
-    }
 
     public FunctionDeclaration Get(FunctionSymbol symbol)
     {
@@ -21,10 +19,7 @@ public FunctionDeclaration Get(FunctionSymbol symbol)
         return declaration;
     }
 
-    public void RemoveIfPresent(FunctionSymbol symbol)
-    {
-        _declarations.Remove(symbol.Id);
-    }
+    public void RemoveIfPresent(FunctionSymbol symbol) => _declarations.Remove(symbol.Id);
 
     public IEnumerable<FunctionDeclaration> Flush() => _declarations.Keys.ToList()
         .Select(x =>
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Impl/TypeDeclarationsResolver.cs b/src/Application/HydraScript.Application.StaticAnalysis/Impl/TypeDeclarationsResolver.cs
@@ -1,6 +1,6 @@
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Declarations;
 using HydraScript.Domain.IR.Impl.Symbols;
-using HydraScript.Domain.IR.Impl.Symbols.Ids;
+using ZLinq;
 
 namespace HydraScript.Application.StaticAnalysis.Impl;
 
@@ -17,26 +17,21 @@ public void Store(TypeDeclaration declaration) =>
     public void Resolve()
     {
         var defaults = provider.GetDefaultTypes()
+            .AsValueEnumerable()
             .Select(x => new TypeSymbol(x))
             .ToList();
 
-        foreach (var declarationToResolve in _declarationsToResolve)
-        {
-            symbolTables[declarationToResolve.Scope].AddSymbol(
-                new TypeSymbol(
-                    declarationToResolve.TypeValue.Accept(typeBuilder),
-                    declarationToResolve.TypeId));
-        }
-
         while (_declarationsToResolve.Count != 0)
         {
             var declarationToResolve = _declarationsToResolve.Dequeue();
-
-            var typeSymbol = symbolTables[declarationToResolve.Scope]
-                .FindSymbol(new TypeSymbolId(declarationToResolve.TypeId))!;
+            var typeSymbol = new TypeSymbol(
+                declarationToResolve.TypeValue.Accept(typeBuilder),
+                declarationToResolve.TypeId);
+            symbolTables[declarationToResolve.Scope].AddSymbol(typeSymbol);
 
             var resolvingCandidates = symbolTables[declarationToResolve.Scope]
                 .GetAvailableSymbols()
+                .AsValueEnumerable()
                 .OfType<TypeSymbol>()
                 .Except(defaults);
 
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Visitors/DeclarationVisitor.cs b/src/Application/HydraScript.Application.StaticAnalysis/Visitors/DeclarationVisitor.cs
@@ -7,6 +7,7 @@
 using HydraScript.Domain.IR.Impl.Symbols;
 using HydraScript.Domain.IR.Impl.Symbols.Ids;
 using HydraScript.Domain.IR.Types;
+using ZLinq;
 
 namespace HydraScript.Application.StaticAnalysis.Visitors;
 
@@ -71,14 +72,15 @@ public VisitUnit Visit(LexicalDeclaration visitable)
     public VisitUnit Visit(FunctionDeclaration visitable)
     {
         var parentTable = _symbolTables[visitable.Parent.Scope];
-        var indexOfFirstDefaultArgument = visitable.Arguments
+        var indexOfFirstDefaultArgument = visitable.Arguments.AsValueEnumerable()
             .Select((x, i) => new { Argument = x, Index = i })
             .FirstOrDefault(pair => pair.Argument is DefaultValueArgument)?.Index ?? -1;
 
-        var parameters = visitable.Arguments.Select(x =>
-            new VariableSymbol(
-                x.Name,
-                x.TypeValue.Accept(_typeBuilder))).ToList();
+        var parameters = visitable.Arguments.AsValueEnumerable()
+            .Select(x =>
+                new VariableSymbol(
+                    x.Name,
+                    x.TypeValue.Accept(_typeBuilder))).ToList();
         var functionSymbolId = new FunctionSymbolId(visitable.Name, parameters.Select(x => x.Type));
         _ambiguousInvocations.Clear(functionSymbolId);
         visitable.ComputedFunctionAddress = functionSymbolId.ToString();
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Visitors/SemanticChecker.cs b/src/Application/HydraScript.Application.StaticAnalysis/Visitors/SemanticChecker.cs
@@ -12,6 +12,7 @@
 using HydraScript.Domain.IR.Impl.Symbols;
 using HydraScript.Domain.IR.Impl.Symbols.Ids;
 using HydraScript.Domain.IR.Types;
+using ZLinq;
 
 namespace HydraScript.Application.StaticAnalysis.Visitors;
 
@@ -176,7 +177,7 @@ public Type Visit(ArrayLiteral visitable)
 
     public Type Visit(ObjectLiteral visitable)
     {
-        var properties = visitable.Properties.Select(prop =>
+        var properties = visitable.Properties.AsValueEnumerable().Select(prop =>
         {
             var propType = prop.Expression.Accept(This);
 
@@ -195,7 +196,9 @@ public Type Visit(ObjectLiteral visitable)
             propSymbol.Initialize();
             _symbolTables[visitable.Scope].AddSymbol(propSymbol);
             return new PropertyType(prop.Id, propType);
-        });
+        }).OrderBy(x => x.Id).ToDictionary(
+            x => x.Id,
+            x => x.Type);
         var objectLiteralType = new ObjectType(properties);
         return objectLiteralType;
     }
@@ -437,7 +440,8 @@ public Type Visit(CallExpression visitable)
         visitable.IsEmptyCall = functionSymbol.IsEmpty;
         var functionReturnType = functionSymbol.Type;
 
-        visitable.Parameters.Zip(parameters).Zip(functionSymbol.Parameters.ToArray()[(methodCall ? 1 : 0)..])
+        visitable.Parameters.AsValueEnumerable()
+            .Zip(parameters).Zip(functionSymbol.Parameters.AsValueEnumerable().Skip(methodCall ? 1 : 0))
             .ToList().ForEach(pair =>
             {
                 var ((expr, actualType), expected) = pair;
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Visitors/TypeBuilder.cs b/src/Application/HydraScript.Application.StaticAnalysis/Visitors/TypeBuilder.cs
@@ -2,6 +2,7 @@
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Declarations;
 using HydraScript.Domain.IR.Impl.Symbols.Ids;
 using HydraScript.Domain.IR.Types;
+using ZLinq;
 
 namespace HydraScript.Application.StaticAnalysis.Visitors;
 
@@ -33,12 +34,13 @@ public NullableType Visit(NullableTypeValue visitable)
     }
 
     public ObjectType Visit(ObjectTypeValue visitable) =>
-        new(visitable.Properties
+        new(visitable.Properties.AsValueEnumerable()
             .Select(x =>
             {
                 x.TypeValue.Scope = visitable.Scope;
                 return new PropertyType(
                     Id: x.Key,
                     x.TypeValue.Accept(This));
-            }));
+            }).OrderBy(x => x.Id)
+            .ToDictionary(x => x.Id, x => x.Type));
 }
diff --git a/src/Domain/HydraScript.Domain.BackEnd/AddressedInstructions.cs b/src/Domain/HydraScript.Domain.BackEnd/AddressedInstructions.cs
@@ -52,10 +52,13 @@ private void AddWithAddress(IExecutableInstruction instruction, IAddress newAddr
         _instructions.Add(newNode, instruction);
     }
 
-    public void AddRange(IEnumerable<IExecutableInstruction> instructions)
+    public void AddRange(AddressedInstructions instructions)
     {
-        foreach (var instruction in instructions)
-            AddWithAddress(instruction, instruction.Address);
+        // ReSharper disable once ConstantConditionalAccessQualifier
+        for (var address = instructions.Start; address != null; address = address?.Next)
+        {
+            AddWithAddress(instructions[address], address);
+        }
     }
 
     public void Remove(IExecutableInstruction instruction)
@@ -75,11 +78,9 @@ public void Remove(IExecutableInstruction instruction)
     }
 
     public IEnumerator<IExecutableInstruction> GetEnumerator() =>
-        _addresses.Select(address => this[address])
-            .GetEnumerator();
+        _addresses.Select(address => this[address]).GetEnumerator();
 
-    IEnumerator IEnumerable.GetEnumerator() =>
-        GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
     public override string ToString() =>
         ZString.Join<IExecutableInstruction>('\n', this);
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/HydraScript.Domain.FrontEnd.csproj b/src/Domain/HydraScript.Domain.FrontEnd/HydraScript.Domain.FrontEnd.csproj
@@ -3,6 +3,7 @@
     <ItemGroup>
         <PackageReference Include="Visitor.NET" />
         <PackageReference Include="Visitor.NET.AutoVisitableGen" PrivateAssets="all" />
+        <PackageReference Include="ZLinq" />
         <PackageReference Include="ZString" />
     </ItemGroup>
 
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Lexer/IStructure.cs b/src/Domain/HydraScript.Domain.FrontEnd/Lexer/IStructure.cs
@@ -3,7 +3,7 @@
 
 namespace HydraScript.Domain.FrontEnd.Lexer;
 
-public interface IStructure : IEnumerable<TokenType>
+public interface IStructure : IReadOnlyList<TokenType>
 {
     public Regex Regex { get; }
 
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Lexer/ITokenTypesProvider.cs b/src/Domain/HydraScript.Domain.FrontEnd/Lexer/ITokenTypesProvider.cs
@@ -1,8 +1,9 @@
+using System.Collections.Frozen;
 using HydraScript.Domain.FrontEnd.Lexer.TokenTypes;
 
 namespace HydraScript.Domain.FrontEnd.Lexer;
 
 public interface ITokenTypesProvider
 {
-    IEnumerable<TokenType> GetTokenTypes();
+    FrozenDictionary<string, TokenType> GetTokenTypes();
 }
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Lexer/Impl/RegexLexer.cs b/src/Domain/HydraScript.Domain.FrontEnd/Lexer/Impl/RegexLexer.cs
@@ -17,18 +17,19 @@ public List<Token> GetTokens(string text)
         _text = text;
         _lines = computer.GetLines(_text);
 
-        return this.Where(t => !t.Type.CanIgnore()).ToList();
+        return this.ToList();
     }
 
     public IEnumerator<Token> GetEnumerator()
     {
         foreach (Match match in Structure.Regex.Matches(_text))
         {
-            foreach (var type in Structure)
+            for (var i = 0; i < Structure.Count; i++)
             {
+                var type = Structure[i];
                 var group = match.Groups[type.Tag];
 
-                if (!group.Success) continue;
+                if (!group.Success || type.CanIgnore()) continue;
 
                 var value = group.Value;
                 var segment = new Segment(
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Lexer/Impl/Structure.cs b/src/Domain/HydraScript.Domain.FrontEnd/Lexer/Impl/Structure.cs
@@ -10,9 +10,7 @@ namespace HydraScript.Domain.FrontEnd.Lexer.Impl;
 public class Structure<TContainer>(ITokenTypesProvider provider) : IStructure
     where TContainer : IGeneratedRegexContainer
 {
-    private FrozenDictionary<string, TokenType> Types { get; } = provider.GetTokenTypes()
-        .Concat([new EndOfProgramType(), new ErrorType()])
-        .ToFrozenDictionary(x => x.Tag);
+    private FrozenDictionary<string, TokenType> Types { get; } = provider.GetTokenTypes();
 
     public Regex Regex { get; } = TContainer.Regex;
 
@@ -27,4 +25,8 @@ public IEnumerator<TokenType> GetEnumerator() =>
 
     [ExcludeFromCodeCoverage]
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public int Count => Types.Values.Length;
+
+    public TokenType this[int index] => Types.Values[index];
 }
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Lexer/Impl/TokenTypesProvider.cs b/src/Domain/HydraScript.Domain.FrontEnd/Lexer/Impl/TokenTypesProvider.cs
@@ -1,13 +1,17 @@
+using System.Collections.Frozen;
 using HydraScript.Domain.FrontEnd.Lexer.TokenTypes;
+using ZLinq;
 
 namespace HydraScript.Domain.FrontEnd.Lexer.Impl;
 
 public class TokenTypesProvider : ITokenTypesProvider
 {
-    public IEnumerable<TokenType> GetTokenTypes() =>
-        Constants.TokenTypes.Stream
+    public FrozenDictionary<string, TokenType> GetTokenTypes() =>
+        Constants.TokenTypes.Stream.AsValueEnumerable()
             .OrderBy(x => x.Priority)
             .Select(x => x.CanIgnore
                 ? new IgnorableType(x.Tag)
-                : new TokenType(x.Tag));
+                : new TokenType(x.Tag))
+            .Concat([new EndOfProgramType(), new ErrorType()])
+            .ToFrozenDictionary(x => x.Tag);
 }
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Lexer/Token.cs b/src/Domain/HydraScript.Domain.FrontEnd/Lexer/Token.cs
@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Text.RegularExpressions;
 using HydraScript.Domain.FrontEnd.Lexer.TokenTypes;
+using ZLinq;
 
 namespace HydraScript.Domain.FrontEnd.Lexer;
 
@@ -37,9 +38,9 @@ public static implicit operator string(Segment segment) =>
 
     public static implicit operator Segment(string segment)
     {
-        var coords = segment.Split("-")
+        var coords = segment.Split("-").AsValueEnumerable()
             .Select(x => x[1..^1].Replace(" ", string.Empty))
-            .Select(x => x.Split(',').Select(int.Parse).ToArray())
+            .Select(x => x.Split(',').AsValueEnumerable().Select(int.Parse).ToArray())
             .ToArray();
         return new Segment(
             new Coordinates(coords[0][0], coords[0][1]),
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/AbstractSyntaxTreeNode.cs b/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/AbstractSyntaxTreeNode.cs
@@ -1,4 +1,5 @@
 using System.Collections;
+using ZLinq;
 
 namespace HydraScript.Domain.FrontEnd.Parser.Impl.Ast;
 
@@ -33,7 +34,7 @@ IEnumerator IEnumerable.GetEnumerator() =>
         Children[index];
 
     public IReadOnlyList<IAbstractSyntaxTreeNode> GetAllNodes() =>
-        new TraverseEnumerator(this).ToList();
+        new TraverseEnumerator(this).AsValueEnumerable().ToArray();
 
     /// <summary>
     /// Метод возвращает <c>true</c>, если узел - потомок заданного типа и выполняется заданное условие.<br/>
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/ScriptBody.cs b/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/ScriptBody.cs
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Statements/BlockStatement.cs b/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Statements/BlockStatement.cs
diff --git a/src/Domain/HydraScript.Domain.IR/Types/ObjectType.cs b/src/Domain/HydraScript.Domain.IR/Types/ObjectType.cs
diff --git a/tests/HydraScript.UnitTests/Application/FunctionWithUndefinedReturnStorageTests.cs b/tests/HydraScript.UnitTests/Application/FunctionWithUndefinedReturnStorageTests.cs
diff --git a/tests/HydraScript.UnitTests/Domain/FrontEnd/RegexLexerTests.cs b/tests/HydraScript.UnitTests/Domain/FrontEnd/RegexLexerTests.cs
diff --git a/tests/HydraScript.UnitTests/Domain/FrontEnd/StructureTests.cs b/tests/HydraScript.UnitTests/Domain/FrontEnd/StructureTests.cs
diff --git a/tests/HydraScript.UnitTests/Domain/IR/ObjectTypeTests.cs b/tests/HydraScript.UnitTests/Domain/IR/ObjectTypeTests.cs
diff --git a/tests/HydraScript.UnitTests/Domain/IR/TypeTests.cs b/tests/HydraScript.UnitTests/Domain/IR/TypeTests.cs

Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,8 @@ internal class FunctionWithUndefinedReturnStorage : IFunctionWithUndefinedReturn`
`8`	`8`	`{`
`9`	`9`	`private readonly OrderedDictionary<FunctionSymbolId, FunctionDeclaration> _declarations = [];`
`10`	`10`
`11`		`- public void Save(FunctionSymbol symbol, FunctionDeclaration declaration)`
`12`		`- {`
	`11`	`+ public void Save(FunctionSymbol symbol, FunctionDeclaration declaration) =>`
`13`	`12`	`_declarations[symbol.Id] = declaration;`
`14`		`- }`
`15`	`13`
`16`	`14`	`public FunctionDeclaration Get(FunctionSymbol symbol)`
`17`	`15`	`{`
`@@ -21,10 +19,7 @@ public FunctionDeclaration Get(FunctionSymbol symbol)`
`21`	`19`	`return declaration;`
`22`	`20`	`}`
`23`	`21`
`24`		`- public void RemoveIfPresent(FunctionSymbol symbol)`
`25`		`- {`
`26`		`- _declarations.Remove(symbol.Id);`
`27`		`- }`
	`22`	`+ public void RemoveIfPresent(FunctionSymbol symbol) => _declarations.Remove(symbol.Id);`
`28`	`23`
`29`	`24`	`public IEnumerable<FunctionDeclaration> Flush() => _declarations.Keys.ToList()`
`30`	`25`	`.Select(x =>`